@yyopc/yyork 0.1.0-alpha.1

package/.agents/skills/yyork-cli/SKILL.md

@@ -0,0 +1,128 @@
+ ---
+name: yyork-cli
+description: Operate yyork's CLI correctly for local agent orchestration. Use when an agent needs to start or reason about the yyork dashboard/server, spawn yyork worker or orchestrator sessions, list sessions, send follow-up messages, stop sessions, work with yyork.localhost/portless dev startup, or avoid planned-but-unimplemented yyork commands.
+---
+
+# yyork CLI
+
+## Overview
+
+Use this skill to choose yyork commands from the actual CLI surface, not from guessed orchestration terminology. If a command or flag is unclear, run `yyork <command> --help` first; in the yyork source checkout, use `go run . <command> --help` when testing the local CLI implementation.
+
+## Command Surface
+
+Implemented public operational verbs:
+
+- `yyork [projectPath] [--addr <host:port>] [--open=false]`: start the local dashboard/API server. `projectPath` must resolve inside a git repo. There is no public `start` or `dashboard` verb.
+- `yyork spawn [--json] [--flags]`: spawn a session. Defaults to `--type worker` and `--agent claude-code`.
+- `yyork session list [--json] [--project <absolute-project-path>]`: list known sessions.
+- `yyork send [--json] --session <id> [--project <absolute-project-path>] "<message>"`: send a follow-up message to a session.
+- `yyork stop [--json] <sessionID>`: terminate a session, remove its worktree when applicable, and delete its store row.
+
+Hidden/internal or dev-only surfaces:
+
+- `yyork dev` is driven by `pnpm dev` in the yyork repo. Prefer `pnpm dev`; it runs `portless run`, which launches `go run . dev`.
+- `yyork hooks ...` is the machine hook entrypoint for Codex/Claude Code lifecycle hooks. Do not call it manually except for explicit hook cleanup work.
+
+Commands shown under `PLANNED` in help, such as `status`, `open`, `batch-spawn`, `plugin`, `review`, or `verify`, are not implemented. Do not use a planned command until help shows it under `COMMANDS`.
+
+## Starting yyork
+
+For normal use:
+
+```bash
+yyork /absolute/path/to/project
+```
+
+Use `--open=false` when running headless or when a browser launch would be noisy:
+
+```bash
+yyork /absolute/path/to/project --open=false
+```
+
+In the yyork source checkout, start the dev stack with:
+
+```bash
+pnpm dev
+```
+
+Under portless, use `https://yyork.localhost` as the stable local URL after the ready banner appears. The hidden `dev` command gets web host/port from `PORTLESS_URL`, `PORT`, `HOST`, `VITE_HOST`, and `VITE_PORT`; backend port is ephemeral unless `YYORK_BACKEND_PORT` is set.
+
+## Spawning Sessions
+
+Orchestrators coordinate; workers implement scoped tasks.
+
+Spawn a worker:
+
+```bash
+yyork spawn --json --type worker --prompt "Implement the focused task, run the relevant checks, and summarize the result."
+```
+
+Rules:
+
+- Worker sessions require a non-empty `--prompt`.
+- `--type` accepts only `worker` or `orchestrator`.
+- `--workspace` accepts only `new-worktree` or `local`, and matters for workers. Orchestrator sessions always run in the main project worktree.
+- If isolation matters, pass `--workspace new-worktree` explicitly. Use `--workspace local` only when the worker should continue in the main worktree.
+- Workers spawned from an orchestrator inherit `YYORK_PROJECT_PATH`; do not override it unless intentionally targeting a different absolute project path.
+- Project IDs are absolute project paths, not slugs. Use the path shown by `yyork session list` or `$YYORK_PROJECT_PATH` for `--project`.
+- Use `--agent codex` only when the Codex plugin is the intended runtime; otherwise the default is `claude-code`.
+- Use `--permissions <mode>` only when the target agent plugin supports the mode you are passing. Check `yyork spawn --help` and local plugin code if unsure.
+- Use `--json` whenever you need to parse yyork output. Human output is for display only.
+
+For multi-line prompts, build a shell variable to avoid quoting mistakes:
+
+```bash
+prompt=$(cat <<'EOF'
+Implement the scoped change described here.
+
+Include:
+- exact files to inspect
+- constraints
+- checks to run
+- expected final summary
+EOF
+)
+
+yyork spawn --json --type worker --workspace new-worktree --prompt "$prompt"
+```
+
+## Coordinating Sessions
+
+List sessions before sending or stopping:
+
+```bash
+yyork session list --json
+yyork session list --json --project "$YYORK_PROJECT_PATH"
+```
+
+The JSON shape is `{"sessions":[...],"count":N}`. Use each session's `id`, `projectPath`, `kind`, `agent`, and `state` fields for follow-up commands.
+
+Send a follow-up:
+
+```bash
+yyork send --json --session <id> "Please run the missing test and report the output."
+```
+
+Add `--project <absolute-project-path>` when IDs may be ambiguous across projects:
+
+```bash
+yyork send --json --project "$YYORK_PROJECT_PATH" --session <id> "Continue with the narrower fix."
+```
+
+Stop only when intentionally ending work:
+
+```bash
+yyork stop --json <sessionID>
+```
+
+`stop` is idempotent for missing IDs, but for real sessions it kills the Zellij session, removes the session worktree when applicable, and deletes the store row. Make sure useful changes are pushed, merged, or otherwise preserved before stopping a worker.
+
+## Orchestrator Habits
+
+- Inspect repository and session context before spawning workers.
+- Spawn small, independently checkable worker tasks rather than broad vague goals.
+- Put enough context in each prompt: task, relevant paths, constraints, verification command, and expected final answer.
+- Avoid implementing directly from the orchestrator unless explicitly asked; use workers for code changes.
+- Prefer CLI commands over direct edits to `~/.yyork/state.db`. Inspect the database only for debugging store-level issues.
+- If `yyork` is unavailable, ask the user before installing missing tools. In the yyork source checkout, use `go run .` for local CLI testing.

package/.agents/skills/yyork-cli/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "yyork CLI"
+  short_description: "Use yyork orchestrator CLI safely"
+  default_prompt: "Use $yyork-cli to inspect yyork sessions and delegate worker tasks correctly."

package/LICENSE

@@ -0,0 +1,76 @@
+YYOIT License
+Version 1.0
+
+Copyright (c) 2026 yyopc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, study, and modify the Software for private or internal purposes, subject
+to the following conditions.
+
+1. Definitions
+
+"Original Author" means yyopc, the original author and owner of yyork.
+
+"Fork" means any copy, modification, adaptation, derivative work, renamed
+version, reimplementation substantially based on the Software, or product or
+service that incorporates a substantial portion of the Software.
+
+"Redistribute" means to publish, sell, sublicense, host for third-party access,
+transfer, provide, package, release, or otherwise make a Fork available to any
+third party, whether in source, binary, hosted, or bundled form.
+
+2. Private Use Grant
+
+You may use, copy, study, and modify the Software privately or inside your own
+organization. You may create private Forks for evaluation, development, and
+internal use.
+
+3. Fork Redistribution Condition
+
+You may Redistribute a Fork only if, before the first Redistribution, you and
+the Original Author have entered into a separate written agreement, signed by
+both parties, that makes the Original Author a cofounder of the project,
+company, organization, or other venture responsible for the Fork.
+
+That written agreement must define, at minimum, the Original Author's title,
+ownership or equity share, vesting or revenue rights, governance or voting
+rights, responsibilities, termination terms, and intellectual-property rights.
+
+If no such written agreement exists, this license grants you no permission to
+Redistribute the Fork.
+
+4. Original Copies
+
+You may share an unmodified copy of the Software only if you include this
+license and all copyright, permission, limitation, and warranty notices.
+
+5. No Trademark Grant
+
+This license does not grant permission to use the names "yyork", "yyopc",
+"YYOIT", or any related names, logos, marks, or branding to imply endorsement,
+partnership, or official status.
+
+6. No Implied Cofounder Relationship
+
+Redistributing a Fork without the written agreement required by Section 3 does
+not make the Original Author your cofounder. It is an unlicensed act. The
+Original Author has no obligation to accept any proposed cofounder role or enter
+into any agreement.
+
+7. Existing MIT-Licensed Copies
+
+This license applies only to copies or versions of the Software that expressly
+include this YYOIT License. Copies of the Software that were previously received
+under another license remain governed by the license under which they were
+received.
+
+8. Warranty Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
+OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+<p align="center">
+  <img src="internal/web/public/favicon.svg" alt="yyork" width="84" />
+</p>
+<h1 align="center">yyork</h1>
+<p align="center">Run AI coding agents in parallel, each inside its own durable workspace.</p>
+
+<p align="center">
+  <img src="yyork-light.png#gh-light-mode-only" alt="yyork app showing parallel AI coding agents in isolated workspaces" width="100%" />
+  <img src="yyork-dark.png#gh-dark-mode-only" alt="yyork app showing parallel AI coding agents in isolated workspaces" width="100%" />
+</p>
+
+> [!WARNING]
+> yyork is still being built. Expect rough edges, breaking changes, and unfinished workflows. There is no merge flow yet, and cleanup commands can remove session worktrees and branches. Push or merge anything important before stopping a session.
+
+## What it does
+
+yyork is a local app for supervising multiple AI coding agents at once.
+
+- Each session runs in its own `git worktree` and branch.
+- [Zellij](https://zellij.dev) keeps agent sessions durable, invisibly — a session looks like a bare terminal running the agent CLI.
+- The app shows live session state from your machine.
+- A per-session canvas adds the workspace file tree, a review diff of the session's changes, and an embedded browser preview of your dev server.
+- Annotations dropped on the previewed page go straight back to the session's agent.
+- Claude Code and Codex run as their normal CLIs; yyork wraps the workspace around them.
+
+## Install
+
+```bash
+npm i -g @yyopc/yyork
+```
+
+The npm package installs a prebuilt native `yyork` binary for your OS/CPU
+through optional platform packages such as `@yyopc/yyork-darwin-arm64` and
+`@yyopc/yyork-linux-x64`. It also installs the bundled `yyork-cli` agent skill
+into `~/.agents/skills/yyork-cli` and runs `yyork doctor` as a warning-only
+postinstall check.
+
+Requirements: npm/Node.js for the npm launcher, plus git and at least one
+supported agent CLI on your `PATH` to run sessions. Native packages carry a
+pinned bundled Zellij runtime for yyork's private session management.
+
+## Basic flow
+
+```bash
+yyork ~/Projects/my-app
+
+# optional/manual worker spawn
+yyork spawn --type worker --prompt "add a health-check endpoint"
+yyork session list
+yyork stop <sessionId>
+```
+
+`yyork ~/Projects/my-app` starts the app and ensures the project has a
+yyork-owned orchestrator in its own worktree and Zellij session. That
+orchestrator can delegate workers with `yyork spawn --type worker --prompt ...`;
+nested spawns keep targeting the original project.
+Session state stays in `~/.yyork/state.db`, with no external orchestrator
+runtime required.
+
+## Development
+
+```bash
+nix develop
+# or, with direnv:
+direnv allow
+
+pnpm install
+pnpm dev
+pnpm test
+```
+
+The Nix dev shell supplies the repo-local Go, Node.js, pnpm, and helper tooling.
+Inside that shell, `yyork` is a development shortcut for `pnpm dev`.
+
+## Release
+
+```bash
+nix develop
+pnpm release:check
+```
+
+`release:check` builds the app, stages the native package for the current
+OS/CPU, packs the thin `@yyopc/yyork` wrapper, installs both into an isolated
+temp prefix with `go` intentionally unavailable, and runs the installed
+`yyork` binary. The native package step fetches and caches the pinned Zellij
+binary under `third_party/zellij/<platform>/` before copying it into the
+tarball.
+
+Distribution builds run in GitHub Actions. The release workflow uses
+GoReleaser to build stripped platform-specific `yyork` archives and publish
+the GitHub release assets. A dependent npm packaging job wraps those exact
+archives into native npm packages with bundled Zellij, smoke-tests install with
+`go` unavailable, uploads the npm tarballs, and publishes the native packages
+before the `@yyopc/yyork` wrapper.
+
+YYOIT © [yyopc](https://github.com/yyopc)

package/bin/install-yyork.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// postinstall: finish package-level setup for @yyopc/yyork. The actual app is
+// shipped as a prebuilt native package; this step only installs the bundled
+// agent skill and runs a warning-only runtime check.
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveYyorkBinary } from './native-package.mjs';
+
+const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+if (!isPackageInstall() && process.env.YYORK_FORCE_POSTINSTALL !== '1') {
+  process.exit(0);
+}
+
+let binaryPath;
+try {
+  binaryPath = resolveYyorkBinary();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+
+installGlobalAgentSkill();
+runInstallDoctor(binaryPath);
+
+function isPackageInstall() {
+  return rootDir.split(sep).includes('node_modules');
+}
+
+function installGlobalAgentSkill() {
+  const sourceDir = resolve(rootDir, '.agents', 'skills', 'yyork-cli');
+  if (!existsSync(sourceDir)) {
+    console.warn(
+      'yyork CLI skill was not bundled; skipping global skill install.'
+    );
+    return;
+  }
+
+  const targetDir = resolve(homedir(), '.agents', 'skills', 'yyork-cli');
+  mkdirSync(resolve(targetDir, '..'), { recursive: true });
+  rmSync(targetDir, { recursive: true, force: true });
+  cpSync(sourceDir, targetDir, { recursive: true });
+}
+
+function runInstallDoctor(binaryPath) {
+  console.log('\nyyork doctor: checking local runtime dependencies...');
+  const result = spawnSync(binaryPath, ['doctor'], {
+    cwd: rootDir,
+    shell: process.platform === 'win32',
+    stdio: 'inherit',
+  });
+
+  if (result.error) {
+    console.warn(`yyork doctor could not run: ${result.error.message}`);
+    return;
+  }
+  if (result.signal) {
+    console.warn(`yyork doctor stopped with signal ${result.signal}.`);
+    return;
+  }
+  if (result.status !== 0) {
+    console.warn(
+      'yyork installed, but doctor found missing dependencies. ' +
+        'Install the missing tools before running sessions.'
+    );
+  }
+}

package/bin/native-package.mjs

@@ -0,0 +1,129 @@
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+
+const nativePackages = {
+  'darwin arm64': {
+    target: 'darwin-arm64',
+    name: '@yyopc/yyork-darwin-arm64',
+    os: 'darwin',
+    cpu: 'arm64',
+    goos: 'darwin',
+    goarch: 'arm64',
+  },
+  'darwin x64': {
+    target: 'darwin-x64',
+    name: '@yyopc/yyork-darwin-x64',
+    os: 'darwin',
+    cpu: 'x64',
+    goos: 'darwin',
+    goarch: 'amd64',
+  },
+  'linux arm64': {
+    target: 'linux-arm64',
+    name: '@yyopc/yyork-linux-arm64',
+    os: 'linux',
+    cpu: 'arm64',
+    goos: 'linux',
+    goarch: 'arm64',
+  },
+  'linux x64': {
+    target: 'linux-x64',
+    name: '@yyopc/yyork-linux-x64',
+    os: 'linux',
+    cpu: 'x64',
+    goos: 'linux',
+    goarch: 'amd64',
+  },
+};
+
+const nativePackagesByTarget = Object.fromEntries(
+  Object.values(nativePackages).map((metadata) => [metadata.target, metadata])
+);
+
+export function nativePackageMetadata(
+  platform = process.platform,
+  arch = process.arch
+) {
+  const metadata = nativePackages[`${platform} ${arch}`];
+  if (!metadata) {
+    throw new Error(
+      `yyork does not publish a native npm package for ${platform}/${arch}. ` +
+        `Supported platforms: ${supportedNativePackages().join(', ')}.`
+    );
+  }
+  return metadata;
+}
+
+export function nativePackageMetadataForTarget(target) {
+  const metadata = nativePackagesByTarget[target];
+  if (!metadata) {
+    throw new Error(
+      `yyork does not publish a native npm package for target ${target}. ` +
+        `Supported targets: ${supportedNativePackageTargets().join(', ')}.`
+    );
+  }
+  return metadata;
+}
+
+export function supportedNativePackages() {
+  return Object.values(nativePackages).map((metadata) => metadata.name);
+}
+
+export function supportedNativePackageTargets() {
+  return Object.keys(nativePackagesByTarget);
+}
+
+export function yyorkBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'yyork.exe' : 'yyork';
+}
+
+export function zellijBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'zellij.exe' : 'zellij';
+}
+
+export function resolveYyorkBinary() {
+  const metadata = nativePackageMetadata();
+  const require = createRequire(import.meta.url);
+
+  let packageJSONPath;
+  try {
+    packageJSONPath = require.resolve(`${metadata.name}/package.json`);
+  } catch (_error) {
+    throw new Error(
+      `Unable to find ${metadata.name}, the native yyork package for ` +
+        `${process.platform}/${process.arch}. Reinstall @yyopc/yyork with ` +
+        `optional dependencies enabled.`
+    );
+  }
+
+  const binaryPath = resolve(
+    dirname(packageJSONPath),
+    'bin',
+    yyorkBinaryName()
+  );
+  try {
+    accessSync(
+      binaryPath,
+      process.platform === 'win32' ? constants.F_OK : constants.X_OK
+    );
+  } catch (_error) {
+    throw new Error(
+      `The native yyork package ${metadata.name} is installed, but its ` +
+        `binary is missing or not executable at ${binaryPath}.`
+    );
+  }
+
+  return binaryPath;
+}
+
+export function runYyork(args, options = {}) {
+  const binaryPath = resolveYyorkBinary();
+  return spawnSync(binaryPath, args, {
+    shell: process.platform === 'win32',
+    stdio: options.stdio ?? 'inherit',
+    cwd: options.cwd,
+    env: options.env,
+  });
+}

package/bin/yyork.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Thin launcher for the published @yyopc/yyork package: resolve the native
+// package for this OS/CPU and exec its prebuilt yyork binary. Everything else
+// lives in the Go binary. From a source checkout, run the CLI with `go run .`
+// or the repo's `yyork` pnpm script.
+import { runYyork } from './native-package.mjs';
+
+let result;
+try {
+  result = runYyork(process.argv.slice(2));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+} else {
+  process.exit(result.status ?? 1);
+}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@yyopc/yyork",
+  "version": "0.1.0-alpha.1",
+  "private": false,
+  "description": "Agent routing platform with an interface to the agent router.",
+  "homepage": "https://github.com/yyopc/yyork#readme",
+  "bugs": {
+    "url": "https://github.com/yyopc/yyork/issues"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "yyopc",
+    "email": "itsyyopc@gmail.com",
+    "url": "https://github.com/yyopc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yyopc/yyork.git"
+  },
+  "bin": {
+    "yyork": "./bin/yyork.mjs"
+  },
+  "files": [
+    ".agents/skills/yyork-cli/**",
+    "bin/yyork.mjs",
+    "bin/install-yyork.mjs",
+    "bin/native-package.mjs"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "npm-run-all": "4.1.5",
+    "openapi-zod-client": "^1.18.3",
+    "portless": "0.14.0"
+  },
+  "optionalDependencies": {
+    "@yyopc/yyork-darwin-arm64": "0.1.0-alpha.1",
+    "@yyopc/yyork-darwin-x64": "0.1.0-alpha.1",
+    "@yyopc/yyork-linux-arm64": "0.1.0-alpha.1",
+    "@yyopc/yyork-linux-x64": "0.1.0-alpha.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "portless": {
+    "name": "yyork",
+    "script": "dev:app"
+  },
+  "scripts": {
+    "postinstall": "node ./bin/install-yyork.mjs",
+    "release:check": "node ./bin/check-release.mjs",
+    "release:fetch-zellij": "node ./bin/fetch-zellij.mjs",
+    "release:fetch-zellij:all": "node ./bin/fetch-zellij.mjs --all",
+    "release:pack:native": "pnpm web:build && node ./bin/pack-native-package.mjs",
+    "release:pack:npm": "node ./bin/pack-npm-release.mjs",
+    "release:dry-run": "pnpm release:check",
+    "release:publish": "echo \"Use the GitHub Actions Release workflow; release publishing is disabled locally.\" && exit 1",
+    "api:generate": "pnpm api:generate:openapi && pnpm api:generate:zod",
+    "api:generate:openapi": "go run ./api/generate-workspace-contract.go",
+    "api:generate:zod": "openapi-zod-client ./api/openapi.generated.json -o ./internal/web/src/features/home/domain/session-workspace-contract.generated.ts -t ./api/session-workspace-contract.hbs --export-schemas && pnpm --filter @yyork/web exec oxfmt src/features/home/domain/session-workspace-contract.generated.ts",
+    "yyork": "go run .",
+    "dev": "run-p dev:stack docs:dev mock:dev",
+    "dev:stack": "portless run",
+    "dev:app": "go run . dev",
+    "web:dev": "pnpm --filter @yyork/web dev",
+    "web:build": "pnpm --filter @yyork/web build",
+    "web:lint": "pnpm --filter @yyork/web lint",
+    "web:test": "pnpm --filter @yyork/web test:ci",
+    "docs:dev": "portless docs.yyork -- pnpm --filter @yyork/docs exec react-router dev",
+    "docs:dev:direct": "pnpm --filter @yyork/docs dev",
+    "storybook:dev": "portless storybook.yyork -- pnpm --filter @yyork/web storybook",
+    "storybook:dev:direct": "pnpm --filter @yyork/web storybook:direct",
+    "mock:dev": "portless mock.yyork --force -- pnpm --filter @yyork/web mock:dev",
+    "mock:dev:direct": "pnpm --filter @yyork/web mock:dev:direct",
+    "docs:build": "pnpm --filter @yyork/docs build",
+    "backend:build": "pnpm web:build && go build -o ./yyork .",
+    "backend:test": "go test ./...",
+    "build": "pnpm web:build && pnpm backend:build",
+    "lint": "pnpm backend:test && pnpm web:lint",
+    "lint:ts": "pnpm --filter @yyork/web lint:ts",
+    "test": "pnpm backend:test && pnpm web:test",
+    "test:ci": "pnpm --filter @yyork/web test:ci",
+    "doctor": "pnpm --filter @yyork/web run doctor",
+    "doctor:full": "pnpm --filter @yyork/web run doctor:full",
+    "e2e": "pnpm --filter @yyork/web e2e",
+    "e2e:live-terminal": "pnpm --dir internal/web e2e:live-terminal"
+  }
+}