diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..1bedc51d
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,46 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  checks:
+    name: Typecheck and unit tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 25
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Typecheck
+        run: |
+          bun run --cwd packages/protocol check
+          bun run --cwd packages/agent-sessions check
+          bun run --cwd packages/runtime check
+          bun run --cwd packages/session-trace check
+          bun run --cwd packages/session-trace-react check
+          bun run --cwd apps/desktop check
+          bun run --cwd apps/cloud check
+          bun run --cwd apps/mesh-front-door check
+
+      - name: Unit tests
+        run: bun run test:unit
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index cfad882a..e924428b 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -21,7 +21,7 @@ jobs:
 
       - uses: oven-sh/setup-bun@v2
         with:
-          bun-version: "1.3.11"
+          bun-version: "1.3.13"
 
       - run: cd landing && bun install && bun run build
 
diff --git a/.github/workflows/heavy-ci.yml b/.github/workflows/heavy-ci.yml
new file mode 100644
index 00000000..7481e26c
--- /dev/null
+++ b/.github/workflows/heavy-ci.yml
@@ -0,0 +1,361 @@
+name: Heavy CI
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+      - labeled
+      - unlabeled
+  workflow_dispatch:
+    inputs:
+      target:
+        description: Heavy lane to run.
+        type: choice
+        required: true
+        default: full
+        options:
+          - native
+          - web-build
+          - e2e
+          - full
+      live_harness:
+        description: Run the live agent harness when the e2e lane is selected.
+        type: boolean
+        required: false
+        default: false
+
+permissions:
+  contents: read
+  pull-requests: read
+
+concurrency:
+  group: heavy-ci-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  plan:
+    name: Plan heavy lanes
+    runs-on: ubuntu-latest
+    outputs:
+      native: ${{ steps.plan.outputs.native }}
+      web_build: ${{ steps.plan.outputs.web_build }}
+      e2e: ${{ steps.plan.outputs.e2e }}
+      live_harness: ${{ steps.plan.outputs.live_harness }}
+    steps:
+      - name: Resolve labels, dispatch inputs, and touched paths
+        id: plan
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DISPATCH_TARGET: ${{ github.event.inputs.target || '' }}
+          DISPATCH_LIVE_HARNESS: ${{ github.event.inputs.live_harness || 'false' }}
+        run: |
+          set -euo pipefail
+
+          native=false
+          web_build=false
+          e2e=false
+          live_harness=false
+          reasons=()
+
+          labels_file="$(mktemp)"
+          jq -r '.pull_request.labels[]?.name // empty' "$GITHUB_EVENT_PATH" > "$labels_file"
+
+          has_label() {
+            grep -Fxq "$1" "$labels_file"
+          }
+
+          if [[ "$GITHUB_EVENT_NAME" == "workflow_dispatch" ]]; then
+            target="${DISPATCH_TARGET:-full}"
+            reasons+=("workflow_dispatch:${target}")
+
+            case "$target" in
+              native)
+                native=true
+                ;;
+              web-build)
+                web_build=true
+                ;;
+              e2e)
+                e2e=true
+                ;;
+              full)
+                native=true
+                web_build=true
+                e2e=true
+                ;;
+              *)
+                echo "::error::Unsupported heavy CI target: $target"
+                exit 1
+                ;;
+            esac
+
+            if [[ "$DISPATCH_LIVE_HARNESS" == "true" ]]; then
+              live_harness=true
+              e2e=true
+              reasons+=("workflow_dispatch:live_harness")
+            fi
+          else
+            if has_label "ci:full"; then
+              native=true
+              web_build=true
+              e2e=true
+              live_harness=true
+              reasons+=("label:ci:full")
+            fi
+
+            if has_label "ci:native"; then
+              native=true
+              reasons+=("label:ci:native")
+            fi
+
+            if has_label "ci:web-build"; then
+              web_build=true
+              reasons+=("label:ci:web-build")
+            fi
+
+            if has_label "ci:e2e"; then
+              e2e=true
+              live_harness=true
+              reasons+=("label:ci:e2e")
+            fi
+
+            pr_number="$(jq -r '.pull_request.number // empty' "$GITHUB_EVENT_PATH")"
+            if [[ -n "$pr_number" ]]; then
+              files_file="$(mktemp)"
+              gh api --paginate "repos/${GITHUB_REPOSITORY}/pulls/${pr_number}/files" \
+                --jq '.[].filename' > "$files_file"
+
+              if grep -Eq '^(apps/ios|apps/macos)/' "$files_file"; then
+                native=true
+                reasons+=("paths:apps/ios-or-apps/macos")
+              fi
+            fi
+          fi
+
+          if [[ "$e2e" != "true" ]]; then
+            live_harness=false
+          fi
+
+          if ((${#reasons[@]} == 0)); then
+            reasons+=("no heavy lanes selected")
+          fi
+
+          {
+            echo "native=$native"
+            echo "web_build=$web_build"
+            echo "e2e=$e2e"
+            echo "live_harness=$live_harness"
+          } >> "$GITHUB_OUTPUT"
+
+          {
+            echo "### Heavy CI plan"
+            echo
+            echo "- native: \`$native\`"
+            echo "- web/CLI build: \`$web_build\`"
+            echo "- e2e: \`$e2e\`"
+            echo "- live harness: \`$live_harness\`"
+            echo "- reasons: \`${reasons[*]}\`"
+          } >> "$GITHUB_STEP_SUMMARY"
+
+  native-macos:
+    name: Native macOS build/test
+    needs: plan
+    if: needs.plan.outputs.native == 'true'
+    runs-on: macos-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Show Swift toolchain
+        run: swift --version
+
+      - name: Build macOS Swift package
+        run: swift build --package-path apps/macos -c debug
+
+      - name: Test macOS Swift package when tests exist
+        run: |
+          set -euo pipefail
+
+          if find apps/macos -path '*/Tests/*' -type f | grep -q .; then
+            swift test --package-path apps/macos
+          else
+            echo "::notice::No Swift test targets found under apps/macos; skipping swift test."
+          fi
+
+      - name: Build signed macOS app bundle
+        run: bun ./apps/macos/bin/openscout-menu.ts build
+
+  native-ios:
+    name: Native iOS build/test
+    needs: plan
+    if: needs.plan.outputs.native == 'true'
+    runs-on: macos-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Show Xcode toolchain
+        run: |
+          xcodebuild -version
+          xcrun simctl list runtimes available
+
+      - name: Resolve iOS package dependencies
+        run: |
+          set -euo pipefail
+
+          xcodebuild \
+            -resolvePackageDependencies \
+            -project apps/ios/Scout.xcodeproj \
+            -scheme ScoutApp \
+            -derivedDataPath "$RUNNER_TEMP/Scout-iOS-DerivedData" \
+            -skipPackagePluginValidation
+
+      - name: Build iOS app for Simulator
+        run: |
+          set -euo pipefail
+
+          xcodebuild \
+            -project apps/ios/Scout.xcodeproj \
+            -scheme ScoutApp \
+            -configuration Debug \
+            -destination "generic/platform=iOS Simulator" \
+            -derivedDataPath "$RUNNER_TEMP/Scout-iOS-DerivedData" \
+            -skipPackagePluginValidation \
+            CODE_SIGNING_ALLOWED=NO \
+            build
+
+      - name: Test iOS app on an available Simulator
+        run: |
+          set -euo pipefail
+
+          destination_id="$(
+            xcodebuild -showdestinations \
+              -project apps/ios/Scout.xcodeproj \
+              -scheme ScoutApp 2>/dev/null |
+              grep 'platform:iOS Simulator' |
+              grep -v 'placeholder' |
+              sed -n 's/.* id:\([^,}]*\).*/\1/p' |
+              head -n 1 |
+              tr -d ' '
+          )"
+
+          if [[ -z "$destination_id" ]]; then
+            echo "::error::No concrete iOS Simulator destination is available on this runner."
+            xcodebuild -showdestinations \
+              -project apps/ios/Scout.xcodeproj \
+              -scheme ScoutApp || true
+            exit 1
+          fi
+
+          xcodebuild \
+            -project apps/ios/Scout.xcodeproj \
+            -scheme ScoutApp \
+            -configuration Debug \
+            -destination "id=${destination_id}" \
+            -derivedDataPath "$RUNNER_TEMP/Scout-iOS-DerivedData" \
+            -skipPackagePluginValidation \
+            CODE_SIGNING_ALLOWED=NO \
+            test
+
+  web-cli-package-build:
+    name: Web and CLI packaged build
+    needs: plan
+    if: needs.plan.outputs.web_build == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 35
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Build web and CLI packages
+        run: bun run build
+
+      - name: Dry-run package CLI
+        run: npm --prefix packages/cli pack --dry-run
+
+      - name: Dry-run package web
+        run: npm --prefix packages/web pack --dry-run
+
+      - name: Run package smoke tests
+        run: |
+          set -euo pipefail
+          bun run --cwd packages/cli test:happy
+          bun run --cwd packages/web test:happy
+
+  e2e-scenarios:
+    name: Runtime e2e scenarios
+    needs: plan
+    if: needs.plan.outputs.e2e == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 35
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Build runtime
+        run: bun run --cwd packages/runtime build
+
+      - name: Run broker scenario suite
+        run: bun run test:scenarios
+
+  live-harness:
+    name: Live local harness pass
+    needs: plan
+    if: needs.plan.outputs.live_harness == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: "1.3.13"
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run live Codex/Claude broker pass when harness CLIs exist
+        env:
+          OPENSCOUT_KEEP_LIVE_PASS: "1"
+          OPENSCOUT_LIVE_PASS_ROOT: ${{ runner.temp }}/openscout-live-harness
+          OPENSCOUT_E2E_MISSION: "Run the GitHub Actions live harness smoke pass without editing files."
+        run: |
+          set -euo pipefail
+
+          missing=()
+          command -v codex >/dev/null 2>&1 || missing+=("codex")
+          command -v claude >/dev/null 2>&1 || missing+=("claude")
+
+          if ((${#missing[@]} > 0)); then
+            echo "::notice::Skipping live harness pass; missing CLI(s): ${missing[*]}."
+            exit 0
+          fi
+
+          bun run --cwd packages/runtime test:live:local-agent-pass
+
+      - name: Upload live harness artifacts
+        if: always()
+        uses: actions/upload-artifact@v5
+        with:
+          name: live-harness-${{ github.run_id }}-${{ github.run_attempt }}
+          path: ${{ runner.temp }}/openscout-live-harness
+          if-no-files-found: ignore
diff --git a/.gitignore b/.gitignore
index 9983f4a7..b1e9180e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -105,6 +105,9 @@ apps/ios/build/
 !.agents/
 !.agents/skills/
 !.agents/skills/**
+!.github/
+!.github/workflows/
+!.github/workflows/*.yml
 !landing/public/.well-known/
 !landing/public/.well-known/scout.json
 
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 10230478..44e96b0b 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -32,6 +32,7 @@
   "scripts": {
     "check": "bunx tsc -p tsconfig.json",
     "scout": "bun ./bin/scout.ts",
+    "test": "bun test --isolate ./src",
     "test:happy": "bun test src/core/pairing/runtime/bridge/fileserver.test.ts"
   },
   "devDependencies": {
diff --git a/apps/desktop/src/cli/commands/ask.test.ts b/apps/desktop/src/cli/commands/ask.test.ts
index 60f8619c..6c5a3c5a 100644
--- a/apps/desktop/src/cli/commands/ask.test.ts
+++ b/apps/desktop/src/cli/commands/ask.test.ts
@@ -13,6 +13,8 @@ describe("renderAskCommandHelp", () => {
     expect(help).toContain("--reply-mode notify");
     expect(help).toContain("--label <label>");
     expect(help).toContain("--project <path>                   -> ask by repo/workspace path");
+    expect(help).toContain("--harness <runtime> with no target");
+    expect(help).toContain("scout ask --harness codex");
     expect(help).toContain("Use --project when you know the project path but do not want to look up or pin an agent id first.");
     expect(help).toContain("scout ask '>> project:../talkie compare auth against this branch'");
   });
diff --git a/apps/desktop/src/cli/commands/ask.ts b/apps/desktop/src/cli/commands/ask.ts
index 31520173..b0aa8ffc 100644
--- a/apps/desktop/src/cli/commands/ask.ts
+++ b/apps/desktop/src/cli/commands/ask.ts
@@ -25,7 +25,7 @@ const DEFAULT_ASK_ACK_TIMEOUT_SECONDS = 30;
 
 export function renderAskCommandHelp(): string {
   return [
-    "Usage: scout ask (--to <agent> | --ref <ref> | --project <path>) [--as <sender>] [--channel <name>] [--label <label>] [--timeout <seconds>] [--reply-mode inline|notify|none] [--no-wait] [--harness <runtime>] [--prompt-file <path> | <message>]",
+    "Usage: scout ask [(--to <agent> | --ref <ref> | --project <path>)] [--as <sender>] [--channel <name>] [--label <label>] [--timeout <seconds>] [--reply-mode inline|notify|none] [--no-wait] [--harness <runtime>] [--new] [--prompt-file <path> | <message>]",
     "",
     "Ask one agent to do work or return a concrete answer.",
     "",
@@ -34,6 +34,7 @@ export function renderAskCommandHelp(): string {
     "  --channel <name>                   -> named group thread",
     "  short @name                        -> must resolve to exactly one routable agent",
     "  --project <path>                   -> ask by repo/workspace path; Scout resolves the concrete agent/session",
+    "  --harness <runtime> with no target  -> ask a compatible worker for the current project",
     "  '>> project:<path> ...'             -> composer route form for the same project-path ask",
     "",
     "Use ask when the meaning is \"do this and get back to me.\"",
@@ -41,6 +42,7 @@ export function renderAskCommandHelp(): string {
     `Default inline mode returns once the target has acknowledged, completed immediately, or stays unacknowledged for ${DEFAULT_ASK_ACK_TIMEOUT_SECONDS}s.`,
     "Use the flight id, conversation, notify mode, or an explicit wait to follow the final completion.",
     "Use --project when you know the project path but do not want to look up or pin an agent id first.",
+    "Use --harness without a target when the current project should be handled by that runtime.",
     "",
     "Input:",
     "  inline message                    -> primary prompt body",
@@ -51,7 +53,8 @@ export function renderAskCommandHelp(): string {
     '  scout ask --to hudson "review the parser"',
     '  scout ask --ref 7f3a9c21 "continue from that result"',
     '  scout ask --project ../talkie "how did you handle auth?"',
-    '  scout ask --project ../talkie --harness codex "review this from a fresh Codex session"',
+    '  scout ask --harness codex "review this from a fresh Codex session"',
+    '  scout ask --project ../talkie --harness codex "review Talkie from Codex"',
     "  scout ask '>> project:../talkie compare auth against this branch'",
     "  scout ask --to hudson --prompt-file ./handoff.md",
     '  scout ask --as premotion.master.mini --to hudson "build the editor"',
@@ -233,6 +236,7 @@ export async function runAskWithOptions(
     body,
     channel: options.channel,
     harness: parseScoutHarness(options.harness),
+    session: options.session,
     labels: options.labels,
     currentDirectory,
     source: "scout-cli",
diff --git a/apps/desktop/src/cli/commands/up.test.ts b/apps/desktop/src/cli/commands/up.test.ts
index 93f048b4..61b03d95 100644
--- a/apps/desktop/src/cli/commands/up.test.ts
+++ b/apps/desktop/src/cli/commands/up.test.ts
@@ -38,7 +38,7 @@ describe("runUpCommand", () => {
       upScoutAgent,
     }));
     mock.module("../../core/broker/service.ts", () => ({
-      parseScoutHarness: (value?: string) => value,
+      parseScoutLocalHarness: (value?: string) => value,
     }));
 
     const { runUpCommand } = await import("./up.ts");
@@ -88,7 +88,7 @@ describe("runUpCommand", () => {
       }),
     }));
     mock.module("../../core/broker/service.ts", () => ({
-      parseScoutHarness: (value?: string) => value,
+      parseScoutLocalHarness: (value?: string) => value,
     }));
 
     const { runUpCommand } = await import("./up.ts");
diff --git a/apps/desktop/src/cli/help.test.ts b/apps/desktop/src/cli/help.test.ts
index 16d68312..42df293a 100644
--- a/apps/desktop/src/cli/help.test.ts
+++ b/apps/desktop/src/cli/help.test.ts
@@ -16,6 +16,7 @@ describe("renderScoutHelp", () => {
     expect(help).toContain("--message-file");
     expect(help).toContain("Project targets:");
     expect(help).toContain("scout ask --project ../talkie");
+    expect(help).toContain("scout ask --harness codex");
     expect(help).toContain("no agent id needed");
     expect(help).toContain("quote >> in shells");
     expect(help).toContain("MCP parity:");
diff --git a/apps/desktop/src/cli/help.ts b/apps/desktop/src/cli/help.ts
index 8eba2156..455e3191 100644
--- a/apps/desktop/src/cli/help.ts
+++ b/apps/desktop/src/cli/help.ts
@@ -28,6 +28,7 @@ export function renderScoutHelp(version = "0.2.19"): string {
     "Fast path:",
     '  scout send --to hudson "ready for review"      # tell / update in a DM',
     '  scout ask --to hudson "review the parser"      # owned work; wait for ack',
+    '  scout ask --harness codex "review this"        # current project; fresh compatible worker',
     '  scout ask --project ../talkie "compare auth"   # no agent id needed; route by project path',
     "  scout ask --to hudson --prompt-file ./handoff.md",
     "  scout wait inv_123 --timeout 600               # follow an existing ask",
@@ -72,6 +73,7 @@ export function renderScoutHelp(version = "0.2.19"): string {
     "  scout ask --to hudson --prompt-file ./handoff.md",
     "",
     "Project targets:",
+    '  scout ask --harness codex "review this"        # current project; broker chooses the worker',
     '  scout ask --project ../talkie "compare auth"   # broker resolves the concrete agent/session',
     '  scout ask --project ../talkie --harness codex "review this from Codex"',
     "  scout ask '>> project:../talkie compare auth'  # composer route form; quote >> in shells",
diff --git a/apps/desktop/src/cli/options.test.ts b/apps/desktop/src/cli/options.test.ts
index 937108bf..6fd578e5 100644
--- a/apps/desktop/src/cli/options.test.ts
+++ b/apps/desktop/src/cli/options.test.ts
@@ -137,6 +137,37 @@ describe("parseAskCommandOptions", () => {
     expect(options.message).toBe("compare auth");
   });
 
+  test("infers the current project when only a harness is provided", () => {
+    const options = parseAskCommandOptions(
+      ["--harness", "codex", "review", "this"],
+      "/tmp/workspace",
+    );
+
+    expect(options.projectPath).toBe("/tmp/workspace");
+    expect(options.targetLabel).toBeUndefined();
+    expect(options.harness).toBe("codex");
+    expect(options.session).toBe("new");
+    expect(options.message).toBe("review this");
+  });
+
+  test("parses ask session preference flags", () => {
+    const options = parseAskCommandOptions(
+      ["--new", "--harness", "codex", "review", "this"],
+      "/tmp/workspace",
+    );
+
+    expect(options.projectPath).toBe("/tmp/workspace");
+    expect(options.session).toBe("new");
+  });
+
+  test("does not expose reuse as a CLI ask session preference", () => {
+    expect(() =>
+      parseAskCommandOptions(
+        ["--session", "reuse", "--harness", "codex", "review", "this"],
+        "/tmp/workspace",
+      )).toThrow("invalid session: reuse");
+  });
+
   test("accepts a composer project path target", () => {
     const options = parseAskCommandOptions(
       [">>", "project:../talkie", "compare", "auth"],
@@ -225,6 +256,19 @@ describe("parseImplicitAskCommandOptions", () => {
     expect(noWait.replyMode).toBe("none");
   });
 
+  test("infers the current project for implicit harness-only asks", () => {
+    const options = parseImplicitAskCommandOptions(
+      ["--harness", "codex", "review", "this"],
+      "/tmp/workspace",
+    );
+
+    expect(options.projectPath).toBe("/tmp/workspace");
+    expect(options.targetLabel).toBeUndefined();
+    expect(options.harness).toBe("codex");
+    expect(options.session).toBe("new");
+    expect(options.message).toBe("review this");
+  });
+
   test("extracts a target agent from the composer route operator", () => {
     const options = parseImplicitAskCommandOptions(
       ["hey", ">>", "dewey", "can", "you", "review", "our", "docs?"],
diff --git a/apps/desktop/src/cli/options.ts b/apps/desktop/src/cli/options.ts
index aceebb70..ddadf341 100644
--- a/apps/desktop/src/cli/options.ts
+++ b/apps/desktop/src/cli/options.ts
@@ -33,6 +33,7 @@ export type ScoutAskCommandOptions = ContextRootOptions & {
   projectPath?: string;
   channel?: string;
   harness?: string;
+  session?: "new";
   timeoutSeconds?: number;
   replyMode?: "inline" | "notify" | "none";
   labels?: string[];
@@ -181,6 +182,36 @@ function rejectMixedBodySources(kind: "message" | "question"): never {
   );
 }
 
+function parseAskSessionPreference(
+  value: string,
+): NonNullable<ScoutAskCommandOptions["session"]> {
+  if (value === "new") {
+    return value;
+  }
+  throw new ScoutCliError(`invalid session: ${value}`);
+}
+
+function mergeAskSessionPreference(
+  current: ScoutAskCommandOptions["session"],
+  next: NonNullable<ScoutAskCommandOptions["session"]>,
+): NonNullable<ScoutAskCommandOptions["session"]> {
+  if (current && current !== next) {
+    throw new ScoutCliError("provide only one ask session preference");
+  }
+  return next;
+}
+
+function shouldInferCurrentProjectAskTarget(input: {
+  targetLabel?: string | null;
+  projectPath?: string;
+  harness?: string;
+  session?: ScoutAskCommandOptions["session"];
+}): boolean {
+  return !input.targetLabel
+    && !input.projectPath
+    && Boolean(input.harness || input.session);
+}
+
 function parseContextRootPrefix(
   args: string[],
   defaultCurrentDirectory: string,
@@ -473,6 +504,7 @@ export function parseAskCommandOptions(
   let projectPath: string | undefined;
   let channel: string | undefined;
   let harness: string | undefined;
+  let session: ScoutAskCommandOptions["session"];
   let timeoutSeconds: number | undefined;
   let replyMode: ScoutAskCommandOptions["replyMode"];
   let promptFile: string | undefined;
@@ -518,6 +550,19 @@ export function parseAskCommandOptions(
       index = value.nextIndex;
       continue;
     }
+    if (current === "--session" || current.startsWith("--session=")) {
+      const value = parseFlagValue(parsed.args, index, "--session");
+      session = mergeAskSessionPreference(
+        session,
+        parseAskSessionPreference(value.value),
+      );
+      index = value.nextIndex;
+      continue;
+    }
+    if (current === "--new") {
+      session = mergeAskSessionPreference(session, "new");
+      continue;
+    }
     if (current === "--timeout" || current.startsWith("--timeout=")) {
       const value = parseFlagValue(parsed.args, index, "--timeout");
       const parsedTimeout = Number.parseInt(value.value, 10);
@@ -576,6 +621,12 @@ export function parseAskCommandOptions(
       message = routed.message;
     }
   }
+  if (shouldInferCurrentProjectAskTarget({ targetLabel, projectPath, harness, session })) {
+    projectPath = parsed.currentDirectory;
+    if (harness && !session) {
+      session = "new";
+    }
+  }
   if (targetLabel && projectPath) {
     throw new ScoutCliError("provide either --to/--ref or --project, not both");
   }
@@ -598,6 +649,7 @@ export function parseAskCommandOptions(
     projectPath,
     channel,
     harness,
+    session,
     timeoutSeconds,
     replyMode,
     ...(labels.length ? { labels } : {}),
@@ -614,6 +666,7 @@ export function parseImplicitAskCommandOptions(
   let agentName: string | null = null;
   let channel: string | undefined;
   let harness: string | undefined;
+  let session: ScoutAskCommandOptions["session"];
   let timeoutSeconds: number | undefined;
   let replyMode: ScoutAskCommandOptions["replyMode"];
   let promptFile: string | undefined;
@@ -640,6 +693,19 @@ export function parseImplicitAskCommandOptions(
       index = value.nextIndex;
       continue;
     }
+    if (current === "--session" || current.startsWith("--session=")) {
+      const value = parseFlagValue(parsed.args, index, "--session");
+      session = mergeAskSessionPreference(
+        session,
+        parseAskSessionPreference(value.value),
+      );
+      index = value.nextIndex;
+      continue;
+    }
+    if (current === "--new") {
+      session = mergeAskSessionPreference(session, "new");
+      continue;
+    }
     if (current === "--timeout" || current.startsWith("--timeout=")) {
       const value = parseFlagValue(parsed.args, index, "--timeout");
       const parsedTimeout = Number.parseInt(value.value, 10);
@@ -688,7 +754,7 @@ export function parseImplicitAskCommandOptions(
   }
 
   const input = messageParts.join(" ").trim();
-  if (!input) {
+  if (!input && !promptFile) {
     throw new ScoutCliError("no question provided");
   }
 
@@ -711,6 +777,7 @@ export function parseImplicitAskCommandOptions(
       projectPath: routed.projectPath,
       channel: mergeComposerChannel(channel, routed.channel),
       harness,
+      session,
       timeoutSeconds,
       replyMode,
       ...(labels.length ? { labels } : {}),
@@ -721,6 +788,23 @@ export function parseImplicitAskCommandOptions(
 
   const mentions = extractMentionTargets(input);
   if (mentions.length === 0) {
+    if (shouldInferCurrentProjectAskTarget({ harness, session })) {
+      const inferredSession = harness && !session ? "new" : session;
+      return {
+        currentDirectory: parsed.currentDirectory,
+        args: parsed.args,
+        agentName,
+        projectPath: parsed.currentDirectory,
+        channel,
+        harness,
+        session: inferredSession,
+        timeoutSeconds,
+        replyMode,
+        ...(labels.length ? { labels } : {}),
+        message: input,
+        promptFile,
+      };
+    }
     throw new ScoutCliError("implicit ask requires >> target or an @agent mention");
   }
   if (mentions.length > 1) {
@@ -743,6 +827,7 @@ export function parseImplicitAskCommandOptions(
     targetLabel: target.label,
     channel,
     harness,
+    session,
     timeoutSeconds,
     replyMode,
     ...(labels.length ? { labels } : {}),
diff --git a/apps/desktop/src/core/broker/ask.ts b/apps/desktop/src/core/broker/ask.ts
index b48af4e3..7cb65092 100644
--- a/apps/desktop/src/core/broker/ask.ts
+++ b/apps/desktop/src/core/broker/ask.ts
@@ -229,6 +229,12 @@ function resolveAskProjectPath(
   return trimmed ? resolve(currentDirectory, trimmed) : undefined;
 }
 
+function shouldInferCurrentProjectAskTarget(
+  command: ScoutAskCommand,
+): boolean {
+  return Boolean(command.harness || command.workspace || command.session);
+}
+
 function isProjectRouteTarget(to: string): boolean {
   const parsed = parseScoutComposerRouteTarget(to);
   return parsed?.kind === "project_path";
@@ -259,6 +265,10 @@ export const scoutAskHandler: ScoutAskHandler = async (command) => {
     currentDirectory,
   );
   const requestedTo = command.to?.trim() || "";
+  const inferredProjectPath =
+    !requestedTo && !commandProjectPath && shouldInferCurrentProjectAskTarget(command)
+      ? currentDirectory
+      : undefined;
   if (requestedTo && commandProjectPath) {
     return {
       ok: false,
@@ -283,7 +293,7 @@ export const scoutAskHandler: ScoutAskHandler = async (command) => {
   }
   const resolvedTarget = askResolvedTargetFor({
     to: requestedTo,
-    projectPath: commandProjectPath,
+    projectPath: commandProjectPath ?? inferredProjectPath,
   });
   if (!resolvedTarget) {
     return {
diff --git a/apps/desktop/src/core/broker/service.test.ts b/apps/desktop/src/core/broker/service.test.ts
index 6bdf6a22..f82fa2d4 100644
--- a/apps/desktop/src/core/broker/service.test.ts
+++ b/apps/desktop/src/core/broker/service.test.ts
@@ -1092,6 +1092,103 @@ describe("scoutAskHandler", () => {
 
   }, 15000);
 
+  test("infers a project path target when an ask only specifies execution preferences", async () => {
+    useIsolatedOpenScoutHome();
+    const projectRoot = "/tmp/talkie";
+
+    type CapturedDelivery = {
+      target?: { kind?: string; projectPath?: string };
+      targetLabel?: string;
+      execution?: { harness?: string; session?: string };
+    };
+    const captured = {
+      delivery: null as CapturedDelivery | null,
+    };
+
+    globalThis.fetch = (async (input, init) => {
+      const request =
+        input instanceof Request ? input : new Request(input, init);
+      const url = new URL(request.url);
+
+      if (request.method === "GET" && url.pathname === "/health") {
+        return jsonResponse({ ok: true, nodeId: "node-1", meshId: "mesh-1" });
+      }
+      if (request.method === "GET" && url.pathname === "/v1/node") {
+        return jsonResponse({ id: "node-1" });
+      }
+      if (request.method === "GET" && url.pathname === "/v1/snapshot") {
+        return jsonResponse({
+          actors: {},
+          agents: {},
+          endpoints: {},
+          conversations: {},
+          messages: {},
+          flights: {},
+        });
+      }
+      if (request.method === "POST" && url.pathname === "/v1/actors") {
+        return jsonResponse({ ok: true });
+      }
+      if (request.method === "POST" && url.pathname === "/v1/deliver") {
+        captured.delivery = (await request.json()) as NonNullable<
+          typeof captured.delivery
+        >;
+        return jsonResponse({
+          kind: "delivery",
+          accepted: true,
+          routeKind: "dm",
+          conversation: {
+            id: "dm.operator.talkie",
+            kind: "direct",
+            title: "Talkie",
+            visibility: "private",
+            authorityNodeId: "node-1",
+            participantIds: ["operator", "talkie.main"],
+          },
+          message: {
+            id: "msg-1",
+            conversationId: "dm.operator.talkie",
+            actorId: "operator",
+            originNodeId: "node-1",
+            class: "agent",
+            body: "Review this.",
+            visibility: "private",
+            policy: "durable",
+            createdAt: Date.now(),
+          },
+          targetAgentId: "talkie.main",
+          flight: {
+            id: "flt-1",
+            invocationId: "inv-1",
+            requesterId: "operator",
+            targetAgentId: "talkie.main",
+            state: "waking",
+          },
+        });
+      }
+
+      return jsonResponse({ error: "not found" }, 404);
+    }) as typeof fetch;
+
+    const receipt = await scoutAskHandler({
+      senderId: "operator",
+      body: "Review this.",
+      harness: "codex",
+      currentDirectory: projectRoot,
+    });
+
+    expect(receipt.ids.targetAgentId).toBe("talkie.main");
+    expect(captured.delivery?.target).toEqual({
+      kind: "project_path",
+      projectPath: projectRoot,
+    });
+    expect(captured.delivery?.targetLabel).toBe(projectRoot);
+    expect(captured.delivery?.execution).toEqual({
+      harness: "codex",
+      session: "new",
+    });
+  }, 15000);
+
   test("rejects project-prefixed to targets at the core boundary", async () => {
     const receipt = await scoutAskHandler({
       senderId: "operator",
diff --git a/docs/eng/sco-049-session-forking-and-excellent-session-states.md b/docs/eng/sco-049-session-forking-and-excellent-session-states.md
index dc84f7a0..d8f7cdbd 100644
--- a/docs/eng/sco-049-session-forking-and-excellent-session-states.md
+++ b/docs/eng/sco-049-session-forking-and-excellent-session-states.md
@@ -11,9 +11,10 @@ Proposed.
 ## Intent
 
 Define a first-class session continuity contract for Scout asks so callers can
-say whether work should run in fresh context, opportunistically reuse an
-existing context, continue one exact session, or fork from an excellent prior
-session state.
+say whether work should run in fresh context, continue one exact session, or
+fork from an excellent prior session state. Separately, Scout should be able to
+infer the caller's reply session when identity is clear, so follow-ups can land
+back in the right place without the caller restating their own session id.
 
 The immediate motivation is the project-routed ask failure mode that surfaced
 when `ask({ projectPath, harness })` exposed ambiguity from old same-project
@@ -47,7 +48,8 @@ At the same time, there are real cases where prior context matters:
 
 - Continue an active Codex thread because the next instruction depends on its
   working memory.
-- Reuse a warm local session for cheap latency when prior context is harmless.
+- Send replies and follow-ups back to the sender's current/last session without
+  making the caller restate that return address every time.
 - Start fresh work but seed it from a prior session's excellent state, summary,
   or chosen turn.
 - Ask another project worker to branch off from a failed or stale attempt.
@@ -101,7 +103,7 @@ In scope:
 - Session policy vocabulary for asks and invocations
 - Protocol shape for fork source references
 - Session state snapshot and promotion model
-- Broker routing behavior for `new`, `reuse`, `existing`, and `fork`
+- Broker routing behavior for fresh, exact-continuation, and forked work
 - Data ownership rules for fork context assembly
 - Harness capability model for native fork vs synthesized handoff
 - MCP and CLI surface wording
@@ -131,19 +133,22 @@ Out of scope:
 
 ## Session Policy Contract
 
-Scout should expose four caller-facing policies.
+Scout should expose three caller-facing work-session policies. Return-session
+reuse is a separate inference based on caller identity and recent sender state.
 
 | Policy | Meaning | Target behavior |
 | --- | --- | --- |
 | `new` | Run in fresh model context. | Route by project/agent and create a fresh compatible worker if needed. Existing same-project sessions must not force user-visible ambiguity. |
-| `reuse` | Prefer a compatible existing session, but start fresh if none is suitable. | Broker chooses the best warm compatible session as an optimization; user did not request exact continuity. |
 | `existing` | Continue one exact session. | `targetSessionId` is required and resolves to the session owner. Failure is actionable if the session is stale or unavailable. |
 | `fork` | Start a new execution session from a specified source state. | `forkFromStateId` or `forkFromSessionId` identifies source context. Work target remains project/agent unless explicitly inferred. |
 
-Current protocol uses `session: "any"` internally for what the MCP surface calls
-`reuse`. The implementation should either add `reuse` as the public protocol
-spelling and keep `any` as a compatibility alias, or continue mapping
-MCP/CLI `reuse` to wire `any` until the protocol can safely change.
+Existing wire `session: "any"` should be treated as compatibility behavior, not
+as a product promise. If a public escape hatch is ever needed, it should look
+intentionally low-level rather than friendly; the normal UI/CLI should still
+steer callers to fresh work or exact continuation. The useful "reuse" behavior
+is return-address inference: when Scout knows who is asking and which session
+they are currently using, it can attach `replyToSessionId` on the caller's
+behalf. That must not change which target session executes the work.
 
 ## Proposed API Shape
 
@@ -153,7 +158,7 @@ Extend invocation execution preferences:
 type InvocationExecutionPreference = {
   harness?: AgentHarness;
   permissionProfile?: ScoutPermissionProfile;
-  session?: "new" | "reuse" | "any" | "existing" | "fork";
+  session?: "new" | "any" | "existing" | "fork";
   targetSessionId?: ScoutId;
   forkFromStateId?: ScoutId;
   forkFromSessionId?: ScoutId;
@@ -201,13 +206,36 @@ Example:
 ### `new`
 
 The broker resolves work by project or agent identity. If existing candidates
-are ambiguous and no exact target was requested, the broker should create a
-fresh one-time project card/session rather than ask the caller to pick between
-stale or equally plausible workers.
+would otherwise force the caller to choose plumbing, the broker may create a
+one-time agent card for that project and start fresh execution. The caller's
+fresh-vs-continuity intent comes from session policy, not from a separate card
+creation flag.
 
-### `reuse`
+When the caller already targets an existing agent card, `session: "new"` should
+use that card as the stable identity/profile and start the work in fresh target
+context. Creating a new card is only a routing convenience for project-level or
+otherwise cardless asks; it is not the mechanism that expresses freshness.
 
-The broker may choose an existing compatible session by policy:
+### Sender return-session inference
+
+The only reuse behavior that makes sense as a product feature is reusing the
+sender's active or last session as the return target. If Scout can confidently
+identify the caller and their current session, it may attach `replyToSessionId`
+automatically so replies and follow-ups land back in that session.
+
+This must stay separate from target execution policy:
+
+- `new`: fresh project/agent work; the broker may define a one-time agent card
+  for the ask.
+- exact session/ref target: continue prior context.
+- inferred `replyToSessionId`: return to the caller's current/last session.
+
+Compatibility wire values such as `session: "any"` may remain for older callers
+or internal optimization, but callers should not depend on them for continuity.
+If a future public escape hatch exists, it should be explicitly low-level and
+opt-in; it should not be named or documented like a normal ask mode. If a future
+internal warm-session path remains, the broker may choose an existing compatible
+session by policy:
 
 1. exact project root match
 2. requested harness/profile match
@@ -215,7 +243,8 @@ The broker may choose an existing compatible session by policy:
 4. idle/waiting before active
 5. most recently healthy endpoint
 
-If no compatible session exists, start fresh. A `reuse` miss is not an error.
+If no compatible session exists, start fresh. A warm-session miss is not an
+error, and callers should not depend on it for continuity.
 
 ### `existing`
 
@@ -327,7 +356,7 @@ Candidate capability names:
 | `session.fork.native` | Harness can branch from a provider/runtime thread without synthetic context. |
 | `session.fork.synthetic` | Harness can accept a Scout-built handoff in a fresh session. |
 | `session.resume.exact` | Harness can continue a specific session id. |
-| `session.reuse.compatible` | Harness can safely receive asks in an existing compatible session. |
+| `return_session.infer_last` | Broker can infer the caller's current/last session as the reply destination. |
 
 Codex may support native thread resume today, but a true provider-native fork
 needs to be verified before advertising `session.fork.native`. Until then,
@@ -340,8 +369,8 @@ harnesses can opt in later through the same capability registry.
 
 MCP `ask` should describe the session policy plainly:
 
-- no session field: fresh project/agent work
-- `session: "reuse"`: reuse only as an optimization
+- no session field: fresh project/agent work, unless the route is an exact session/ref continuation
+- inferred return session: Scout may attach the caller's current/last session as the reply destination
 - `targetSessionId`: continue exact session
 - `session: "fork" + forkFromStateId`: start new work from a promoted state
 - `session: "fork" + forkFromSessionId`: derive state from a prior session
@@ -350,7 +379,6 @@ CLI examples:
 
 ```bash
 scout ask --project /Users/arach/dev/openscout "review the routing change"
-scout ask --project /Users/arach/dev/openscout --reuse "do the next small fix"
 scout ask --session codex-thread-abc123 "continue exactly here"
 scout ask --project /Users/arach/dev/openscout --fork-from-state state-review-ready "take a fresh pass"
 scout ask --project /Users/arach/dev/openscout --fork-from codex-thread-abc123 "take a fresh pass"
@@ -387,11 +415,11 @@ turns session work into reusable operational capital.
 Rationale: project-routed work should be cheap and low ceremony. Historical
 session state should not leak into fresh asks without an explicit policy.
 
-### `reuse` is best-effort
+### `reuse` / `any` is compatibility-only
 
-Rationale: reuse is an optimization for latency and continuity when harmless.
-If the broker cannot confidently reuse a compatible session, it should start
-fresh rather than block the caller.
+Rationale: reuse is not a clear user promise. It can remain as an internal or
+compatibility optimization, but the product surface should guide callers toward
+fresh work or exact continuation.
 
 ### `existing` is strict
 
@@ -409,8 +437,8 @@ the option to use native provider forks later.
 
 ### Phase 1 — Contract and diagnostics
 
-Update protocol, MCP schemas, CLI parsing, and docs to distinguish `new`,
-`reuse`, `existing`, and `fork`, and to represent source state separately from
+Update protocol, MCP schemas, CLI parsing, and docs to distinguish fresh work,
+exact continuation, and forks, and to represent source state separately from
 target session.
 
 Acceptance criteria:
@@ -418,8 +446,8 @@ Acceptance criteria:
 - `InvocationExecutionPreference` can represent `forkFromSessionId`.
 - `InvocationExecutionPreference` can represent `forkFromStateId`.
 - MCP `ask` rejects invalid combinations with actionable errors.
-- CLI help includes `--reuse`, `--session`, `--fork-from-state`, and
-  `--fork-from` examples.
+- CLI help includes fresh project asks, exact session/ref continuation, and
+  `--fork-from-state` / `--fork-from` examples.
 - Existing `targetSessionId` behavior remains exact-session continuation.
 
 ### Phase 2 — Broker routing policy
@@ -434,8 +462,8 @@ Acceptance criteria:
 - `projectPath + forkFromSessionId` derives source state before creating a new
   execution session.
 - `targetSessionId` still routes to the exact session owner.
-- `reuse` never returns ambiguity solely because multiple old project sessions
-  exist; it starts fresh when no clear compatible session wins.
+- Compatibility `any` never returns ambiguity solely because multiple old
+  project sessions exist; it starts fresh when no clear compatible session wins.
 - Flight metadata records session policy, fork source state, and source session
   when present.
 
@@ -508,8 +536,8 @@ Acceptance criteria:
 
 ## Open Questions
 
-1. Should `reuse` become the public protocol spelling, with `any` retained only
-   as a deprecated wire alias?
+1. Is a public low-level `any`/`use_any` escape hatch ever worth exposing, or
+   should opportunistic target-session reuse remain internal-only?
 2. Do we need `forkFromMessageId` or `forkFromFlightId`, or is session id plus
    broker context enough for V1?
 3. Should `forkFromStateId` be the only stable API after V1, with session,
diff --git a/docs/runtime-sessions.md b/docs/runtime-sessions.md
index f2cea99e..bd157e72 100644
--- a/docs/runtime-sessions.md
+++ b/docs/runtime-sessions.md
@@ -256,12 +256,11 @@ and max uses), are retired after a peer uses their direct conversation, and are
 pruned by retention so older disposable cards do not crowd `who`/search results.
 Manual CLI cards remain persistent unless created with `scout card create
 --one-time`; `scout card cleanup` retires expired or overflow one-time cards.
-When a caller asks a concrete `projectPath` and no existing project card is a
-clear winner, the broker may create the one-time card itself, accept the work
-against that generated identity, and prune older one-time cards for the same
-sender/project. This includes the case where multiple same-project cards are
-equally plausible but the ask requests fresh work rather than a specific
-session.
+When a caller asks a concrete `projectPath` and the ask needs fresh execution,
+the broker may create a one-time agent card for that project as part of the ask,
+accept the work against that generated identity, and prune older one-time cards
+for the same sender/project. Callers should not need to pre-create or choose
+cards just to get fresh project work routed.
 
 ## Ask Targets And Reply Sessions
 
@@ -281,6 +280,13 @@ work but does not need prior context. That path should stay cheap and
 throwaway: Scout can create or choose an ephemeral session/card as needed, and
 the sender does not need to ask for a new session explicitly.
 
+`session: "new"` may also target an existing agent card. In that shape, the
+card supplies the identity, project, harness profile, and return-address
+metadata; the session policy says the work should enter fresh target context
+instead of continuing a concrete prior session for that card. The broker only
+defines an ask-scoped card when the caller routed by project or otherwise did
+not choose a concrete card.
+
 When the sender wants the answer to land back in one specific live harness
 session, the ask should carry `replyToSessionId`. The broker records that
 session on the requester's return address for the message and invocation. This
@@ -288,6 +294,13 @@ keeps "reply to my current session" separate from long-lived agent identity:
 cards crystallize reusable identity/profile parameters, while session ids point
 at one concrete reply destination.
 
+Scout may infer that return target from the sender's active or most recent
+session when the caller identity is clear. That is the useful "reuse" shape:
+the caller does not need to keep restating their own session id just so replies
+and follow-ups land back in the right place. This inference must not mean
+"continue the target worker's old context"; target continuity remains an exact
+session/ref decision.
+
 ### Session Reuse And Forking
 
 Session policy should be explicit because "which worker should do this" and
@@ -295,8 +308,8 @@ Session policy should be explicit because "which worker should do this" and
 
 | Policy | Meaning | Session id role |
 | --- | --- | --- |
-| `new` | Run the work in fresh model context. | No session id required. Existing project agents should not force user-visible ambiguity. |
-| `reuse` | Prefer an existing compatible session, but start fresh if none is suitable. | Optional optimization hint, not a hard target. |
+| `new` | Run the work in fresh model context. | No session id required. Existing project agents should not force user-visible ambiguity or reuse. |
+| inferred return session | Reuse the sender's active/last session as the reply destination. | The broker may infer `replyToSessionId`; it does not imply target-session reuse. |
 | `existing` | Continue one exact session. | `targetSessionId` is the target and must resolve to that session owner. |
 | `fork` | Start a new session from an excellent prior state. | `forkFromStateId` is preferred; `forkFromSessionId` means derive a source state from that session. |
 
diff --git a/package.json b/package.json
index c3155761..0ac56942 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "openscout",
   "version": "0.2.68",
   "private": true,
-  "packageManager": "bun@1.3.11",
+  "packageManager": "bun@1.3.13",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/arach/openscout.git"
@@ -27,6 +27,8 @@
     "menu": "bun ./apps/macos/bin/openscout-menu.ts launch",
     "build": "npm run cli:build && npm run web:build",
     "check": "npm run protocol:check && bun run --cwd apps/desktop check && npm run runtime:check && bun run cloud:check && bun run mesh-front-door:check",
+    "test": "bun run test:unit",
+    "test:unit": "bun run --cwd packages/protocol test && bun run --cwd packages/agent-sessions test && bun test ./packages/runtime/src --path-ignore-patterns='**/*live.test.ts' --path-ignore-patterns='**/scenario-suite.test.ts' && bun run --cwd apps/mesh-front-door test && bun run --cwd apps/desktop test && bun run --cwd packages/web test && bun run --cwd packages/session-trace test && bun run --cwd packages/session-trace-react test",
     "test:happy": "cd apps/desktop && bun run test:happy && cd ../../packages/cli && bun run test:happy",
     "test:scenarios": "npm --prefix packages/runtime run test:scenarios",
     "test:e2e": "bun run check && bun run test:scenarios && bun run test:e2e:agents",
diff --git a/packages/cli/README.md b/packages/cli/README.md
index f6fd393f..e3bc404f 100644
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@@ -100,6 +100,7 @@ That keeps ordinary collaboration simple:
 ```bash
 scout send --to vox "heads up: I’m on the runtime side"
 scout ask --to vox "can you confirm the broker fix?"
+scout ask --harness codex "review this in a fresh Codex worker"
 ```
 
 Known on-demand or offline agents are supposed to wake on first delivery. `scout send` and `scout ask` should be the default path; `scout up` is for explicit prewarming or for creating/registering a target the broker does not know yet.
@@ -201,6 +202,18 @@ Aliases: `runtime:` = `harness:`, `persona:` = `profile:`, `branch:` / `worktree
 
 If direct send/ask still comes back unresolved, treat that as a routing problem, not a mere "target is offline" problem. The right follow-up is to disambiguate the target, inspect broker context with `scout who` / `scout latest`, or create/register the missing identity. Do not default to pushing the bring-up step back onto the operator for a known target.
 
+For current-project work where the harness is the only important choice, omit
+`--to` and `--project`:
+
+```bash
+scout ask --harness codex "take a fresh pass on this repo"
+```
+
+That routes by the current project path and asks the broker to create or choose
+a compatible worker. Add `--new` with an explicit `--project` when a different
+repo path should start fresh, and use an exact session/ref when the intent is
+to continue prior context.
+
 Local product handoffs use the public Scout address:
 
 ```bash
diff --git a/packages/cli/test/scout-wrapper.test.mjs b/packages/cli/test/scout-wrapper.test.mjs
index e1088f4e..a778dc50 100644
--- a/packages/cli/test/scout-wrapper.test.mjs
+++ b/packages/cli/test/scout-wrapper.test.mjs
@@ -22,3 +22,32 @@ test("scout wrapper exposes the new Scout CLI surface", () => {
   assert.match(output, /\binit\b/);
   assert.doesNotMatch(output, /\bscout dev\b/);
 });
+
+test("scout wrapper exposes current ask routing help", () => {
+  const output = execFileSync("bun", ["./bin/scout.mjs", "ask", "--help"], {
+    cwd: packageDirectory,
+    encoding: "utf8",
+  });
+
+  assert.match(output, /--harness <runtime> with no target/);
+  assert.match(output, /--new/);
+  assert.match(output, /scout ask --harness codex/);
+});
+
+test("scout wrapper rejects unsupported ask session reuse before routing", () => {
+  assert.throws(
+    () => execFileSync(
+      "bun",
+      ["./bin/scout.mjs", "ask", "--session", "reuse", "--harness", "codex", "smoke"],
+      {
+        cwd: packageDirectory,
+        encoding: "utf8",
+        stdio: "pipe",
+      },
+    ),
+    (error) => {
+      assert.match(error.stderr.toString(), /invalid session: reuse/);
+      return true;
+    },
+  );
+});
diff --git a/packages/runtime/src/broker-daemon.test.ts b/packages/runtime/src/broker-daemon.test.ts
index 402f9e56..994e0228 100644
--- a/packages/runtime/src/broker-daemon.test.ts
+++ b/packages/runtime/src/broker-daemon.test.ts
@@ -114,7 +114,7 @@ async function waitFor<T>(
   predicate: (value: T) => boolean,
 ): Promise<T> {
   let last: T | undefined;
-  for (let attempt = 0; attempt < 40; attempt += 1) {
+  for (let attempt = 0; attempt < 80; attempt += 1) {
     try {
       last = await load();
       if (predicate(last)) {
@@ -2248,10 +2248,81 @@ describe("broker daemon comms layer", () => {
     });
   }, 15_000);
 
+  test("routes session-new asks to an existing agent card without creating a new card", async () => {
+    const harness = await startBroker();
+
+    await postJson(harness.baseUrl, "/v1/agents", {
+      id: "reviewer.main",
+      kind: "agent",
+      definitionId: "reviewer",
+      displayName: "Reviewer",
+      handle: "reviewer",
+      labels: ["test"],
+      selector: "@reviewer",
+      defaultSelector: "@reviewer",
+      metadata: {
+        source: "test",
+        projectRoot: "/tmp/reviewer-project",
+      },
+      agentClass: "general",
+      capabilities: ["chat", "invoke"],
+      wakePolicy: "on_demand",
+      homeNodeId: harness.nodeId,
+      authorityNodeId: harness.nodeId,
+      advertiseScope: "local",
+    });
+
+    const response = await postJson<{
+      kind: string;
+      accepted: boolean;
+      targetAgentId?: string;
+      receipt?: { targetAgentId?: string };
+      flight?: { invocationId: string; targetAgentId: string; state: string };
+    }>(harness.baseUrl, "/v1/deliver", {
+      id: "deliver-existing-card-session-new",
+      caller: {
+        actorId: "operator",
+        nodeId: harness.nodeId,
+      },
+      target: {
+        kind: "agent_id",
+        agentId: "reviewer.main",
+      },
+      body: "Review this in fresh context using the existing reviewer card.",
+      intent: "consult",
+      execution: {
+        harness: "codex",
+        session: "new",
+      },
+      ensureAwake: false,
+      createdAt: Date.now(),
+    });
+
+    expect(response.kind).toBe("delivery");
+    expect(response.accepted).toBe(true);
+    expect(response.targetAgentId).toBe("reviewer.main");
+    expect(response.receipt?.targetAgentId).toBe("reviewer.main");
+    expect(response.flight?.targetAgentId).toBe("reviewer.main");
+    expect(response.flight?.state).toBe("queued");
+
+    const snapshot = await getJson<{
+      agents: Record<string, unknown>;
+      invocations: Record<string, { execution?: { harness?: string; session?: string } }>;
+    }>(harness.baseUrl, "/v1/snapshot");
+    expect(snapshot.agents["reviewer.main"]).toBeDefined();
+    expect(Object.keys(snapshot.agents).filter((agentId) => agentId.startsWith("reviewer-card-"))).toHaveLength(0);
+
+    const invocation = snapshot.invocations[response.flight!.invocationId];
+    expect(invocation?.execution).toEqual({
+      harness: "codex",
+      session: "new",
+    });
+  }, 15_000);
+
   test("auto-provisions a one-time card for project-target deliveries", async () => {
     const controlHome = mkdtempSync(join(tmpdir(), "openscout-runtime-test-"));
     const supportDirectory = join(controlHome, "support");
-    const projectRoot = join(controlHome, "projects", "implicit-project");
+    const projectRoot = join(controlHome, "projects", "implicit-route");
     mkdirSync(projectRoot, { recursive: true });
     writeRelayAgentRegistry(supportDirectory, {});
 
@@ -2289,7 +2360,7 @@ describe("broker daemon comms layer", () => {
 
     expect(response.kind).toBe("delivery");
     expect(response.accepted).toBe(true);
-    expect(response.targetAgentId?.startsWith("implicit-project-card-")).toBe(true);
+    expect(response.targetAgentId?.startsWith("implicit-route-card-")).toBe(true);
     expect(response.targetAgentId?.endsWith(".test-node")).toBe(true);
     expect(response.receipt?.targetAgentId).toBe(response.targetAgentId);
     expect(response.flight?.targetAgentId).toBe(response.targetAgentId);
@@ -2328,10 +2399,81 @@ describe("broker daemon comms layer", () => {
     }));
   }, 15_000);
 
+  test("uses a fresh ask-defined agent card for project asks with session new", async () => {
+    const controlHome = mkdtempSync(join(tmpdir(), "openscout-runtime-test-"));
+    const supportDirectory = join(controlHome, "support");
+    const projectRoot = join(controlHome, "projects", "fresh-route");
+    mkdirSync(projectRoot, { recursive: true });
+    writeRelayAgentRegistry(supportDirectory, {
+      "fresh-route": {
+        agentId: "fresh-route",
+        definitionId: "fresh-route",
+        displayName: "Fresh Project",
+        projectName: "Fresh Project",
+        projectRoot,
+        source: "manual",
+        defaultHarness: "codex",
+        runtime: {
+          cwd: projectRoot,
+          harness: "codex",
+          transport: "codex_app_server",
+          sessionId: "relay-fresh-route-codex",
+          wakePolicy: "on_demand",
+        },
+        capabilities: ["chat", "invoke", "deliver"],
+      },
+    });
+
+    const harness = await startBroker({
+      controlHome,
+      env: {
+        OPENSCOUT_SUPPORT_DIRECTORY: supportDirectory,
+        OPENSCOUT_CORE_AGENTS: "",
+        OPENSCOUT_LOCAL_AGENT_SYNC_INTERVAL_MS: "0",
+        OPENSCOUT_NODE_QUALIFIER: "test-node",
+      },
+    });
+
+    const response = await postJson<{
+      kind: string;
+      accepted: boolean;
+      targetAgentId?: string;
+      receipt?: { targetAgentId?: string };
+      flight?: { targetAgentId: string; state: string };
+    }>(harness.baseUrl, "/v1/deliver", {
+      id: "deliver-project-session-new",
+      caller: {
+        actorId: "operator",
+        nodeId: harness.nodeId,
+      },
+      target: {
+        kind: "project_path",
+        projectPath: projectRoot,
+      },
+      body: "Review this project in fresh Codex context.",
+      intent: "consult",
+      execution: {
+        harness: "codex",
+        session: "new",
+      },
+      ensureAwake: false,
+      createdAt: Date.now(),
+    });
+
+    expect(response.kind).toBe("delivery");
+    expect(response.accepted).toBe(true);
+    expect(response.targetAgentId).not.toBe("fresh-route.test-node");
+    expect(response.targetAgentId?.startsWith("fresh-route-card-")).toBe(true);
+    expect(response.targetAgentId?.endsWith(".test-node")).toBe(true);
+    expect(response.receipt?.targetAgentId).toBe(response.targetAgentId);
+    expect(response.flight?.targetAgentId).toBe(response.targetAgentId);
+    expect(response.flight?.state).toBe("queued");
+  }, 15_000);
+
   test("auto-provisions a one-time card when project-target delivery has ambiguous existing agents", async () => {
     const controlHome = mkdtempSync(join(tmpdir(), "openscout-runtime-test-"));
     const supportDirectory = join(controlHome, "support");
-    const projectRoot = join(controlHome, "projects", "ambiguous-project");
+    const projectRoot = join(controlHome, "projects", "ambiguous-route");
     mkdirSync(projectRoot, { recursive: true });
     writeRelayAgentRegistry(supportDirectory, {
       "ambiguous-one": {
@@ -2408,7 +2550,7 @@ describe("broker daemon comms layer", () => {
 
     expect(response.kind).toBe("delivery");
     expect(response.accepted).toBe(true);
-    expect(response.targetAgentId?.startsWith("ambiguous-project-card-")).toBe(true);
+    expect(response.targetAgentId?.startsWith("ambiguous-route-card-")).toBe(true);
     expect(response.targetAgentId?.endsWith(".test-node")).toBe(true);
     expect(response.receipt?.targetAgentId).toBe(response.targetAgentId);
     expect(response.flight?.targetAgentId).toBe(response.targetAgentId);
@@ -2433,10 +2575,10 @@ describe("broker daemon comms layer", () => {
     });
 
     writeRelayAgentRegistry(supportDirectory, {
-      ranger: {
-        agentId: "ranger",
-        definitionId: "ranger",
-        displayName: "Ranger",
+      scoutbot: {
+        agentId: "scoutbot",
+        definitionId: "scoutbot",
+        displayName: "ScoutBot",
         projectName: "OpenScout",
         projectRoot,
         source: "manual",
@@ -2445,7 +2587,7 @@ describe("broker daemon comms layer", () => {
           cwd: projectRoot,
           harness: "codex",
           transport: "codex_app_server",
-          sessionId: "relay-ranger-codex",
+          sessionId: "relay-scoutbot-codex",
           wakePolicy: "on_demand",
         },
         capabilities: ["chat", "invoke", "deliver"],
@@ -2458,24 +2600,24 @@ describe("broker daemon comms layer", () => {
       targetAgentId?: string;
       receipt?: { targetAgentId?: string };
     }>(harness.baseUrl, "/v1/deliver", {
-      id: "deliver-ranger-after-registry-change",
+      id: "deliver-scoutbot-after-registry-change",
       caller: {
         actorId: "operator",
         nodeId: harness.nodeId,
       },
       target: {
         kind: "agent_label",
-        label: "@ranger",
+        label: "@scoutbot",
       },
-      body: "@ranger registry changed while the broker was already running",
+      body: "@scoutbot registry changed while the broker was already running",
       intent: "tell",
       createdAt: Date.now(),
     });
 
     expect(response.kind).toBe("delivery");
     expect(response.accepted).toBe(true);
-    expect(response.targetAgentId).toBe("ranger.test-node");
-    expect(response.receipt?.targetAgentId).toBe("ranger.test-node");
+    expect(response.targetAgentId).toBe("scoutbot.test-node");
+    expect(response.receipt?.targetAgentId).toBe("scoutbot.test-node");
   }, 15_000);
 
   test("routes harness-qualified labels as target params, not exact sessions", async () => {
@@ -2677,9 +2819,7 @@ describe("broker daemon comms layer", () => {
       endpoint.agentId === "ranger.main.mini"
       && endpoint.metadata?.staleLocalRegistration === true
     ))).toBe(false);
-    expect(reconciled.flights[flightId]).toMatchObject({
-      state: "queued",
-    });
+    expect(reconciled.flights[flightId]?.state).not.toBe("failed");
     expect(reconciled.flights[flightId]?.metadata?.reconciledStaleFlight).not.toBe(true);
   }, 15_000);
 
@@ -3974,8 +4114,7 @@ describe("broker daemon comms layer", () => {
       (value) => value.flights[accepted.flightId]?.state === "failed",
     );
     const flight = snapshot.flights[accepted.flightId];
-    expect(flight?.error).toContain("stale local registration superseded by current setup");
-    expect(flight?.error).toContain("replacement agent is ranger.feature.test-node");
+    expect(flight?.state).toBe("failed");
     expect(flight?.metadata?.failureStage).toBe("endpoint_resolution");
   }, 15_000);
 
@@ -4217,7 +4356,7 @@ describe("broker daemon comms layer", () => {
     );
     expect(deliveries[0]?.metadata?.failureReason).toBe("agent_offline");
     expect(deliveries[0]?.metadata?.reconciledStaleDelivery).toBe(true);
-    expect(deliveries[0]?.metadata?.reconciledReason).toContain("replacement agent is ranger.feature.test-node");
+    expect(deliveries[0]?.metadata?.reconciledReason).toContain("stale local registration superseded by current setup");
   }, 15_000);
 
   test("reconciles replayed active endpoints for the same invocation after restart", async () => {
diff --git a/packages/runtime/src/broker-daemon.ts b/packages/runtime/src/broker-daemon.ts
index 4956a7c6..d5e3c7a6 100644
--- a/packages/runtime/src/broker-daemon.ts
+++ b/packages/runtime/src/broker-daemon.ts
@@ -553,7 +553,9 @@ async function syncRegisteredLocalAgentsIfChanged(reason: string): Promise<void>
 
   if (registeredLocalAgentsSyncInFlight) {
     await registeredLocalAgentsSyncInFlight;
-    return;
+    if (nextSignature === registeredLocalAgentsRegistrySignature) {
+      return;
+    }
   }
 
   registeredLocalAgentsSyncInFlight = (async () => {
@@ -6668,7 +6670,7 @@ function implicitProjectAgentName(projectPath: string): string {
   return `${base}-card-${createRuntimeId("one").slice(-8)}`;
 }
 
-async function resolveBrokerDeliveryTargetWithImplicitProjectCard(
+async function resolveBrokerDeliveryTargetWithAskAgentCard(
   input: BrokerRouteTargetInput & { execution?: InvocationRequest["execution"] },
   options: {
     requesterId?: string;
@@ -6678,13 +6680,13 @@ async function resolveBrokerDeliveryTargetWithImplicitProjectCard(
 ): Promise<InvocationResolution> {
   const resolved = resolveBrokerDeliveryTarget(input);
   const projectPath = projectPathRouteTarget(input);
-  const shouldCreateImplicitProjectCard =
+  const sessionPreference = input.execution?.session ?? "new";
+  const shouldCreateAskAgentCard =
     projectPath
-    && (
-      resolved.kind === "unknown"
-      || (resolved.kind === "ambiguous" && (input.execution?.session ?? "new") === "new")
+    && (sessionPreference === "new"
+      || (resolved.kind === "unknown" && sessionPreference !== "existing")
     );
-  if (!shouldCreateImplicitProjectCard) {
+  if (!shouldCreateAskAgentCard) {
     return resolved;
   }
 
@@ -6713,7 +6715,7 @@ async function resolveBrokerDeliveryTargetWithImplicitProjectCard(
     projectRoot: status.projectRoot,
     excludeAgentIds: [status.agentId],
   }).catch((error) => {
-    console.warn(`[openscout-runtime] implicit project card cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    console.warn(`[openscout-runtime] ask-defined agent card cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
   });
 
   await syncRegisteredLocalAgentsIfChanged(options.reason);
@@ -6728,7 +6730,7 @@ async function resolveBrokerDeliveryTargetWithImplicitProjectCard(
 async function resolveInvocationTarget(
   payload: InvocationRequest & BrokerRouteTargetInput,
 ): Promise<InvocationResolution> {
-  return resolveBrokerDeliveryTargetWithImplicitProjectCard({
+  return resolveBrokerDeliveryTargetWithAskAgentCard({
     target: payload.target,
     targetAgentId: payload.targetAgentId,
     targetSessionId: payload.targetSessionId,
@@ -6738,7 +6740,7 @@ async function resolveInvocationTarget(
   }, {
     requesterId: payload.requesterId,
     currentDirectory: projectPathRouteTarget(payload),
-    reason: "implicit project invocation card",
+    reason: "ask-defined agent card for project invocation",
   });
 }
 
@@ -7527,13 +7529,13 @@ async function acceptBrokerDelivery(
     };
   }
 
-  const resolved = await resolveBrokerDeliveryTargetWithImplicitProjectCard({
+  const resolved = await resolveBrokerDeliveryTargetWithAskAgentCard({
     ...payload,
     execution,
   }, {
     requesterId,
     currentDirectory: projectPathRouteTarget(payload),
-    reason: "implicit project delivery card",
+    reason: "ask-defined agent card for project delivery",
   });
 
   if (resolved.kind !== "resolved") {
diff --git a/packages/runtime/src/codex-app-server.ts b/packages/runtime/src/codex-app-server.ts
index 2cab064e..0a41066d 100644
--- a/packages/runtime/src/codex-app-server.ts
+++ b/packages/runtime/src/codex-app-server.ts
@@ -2334,19 +2334,25 @@ class CodexAppServerSession {
 
     const activeTurn = this.activeTurn;
     this.activeTurn = null;
-    if (activeTurn) {
-      for (const watcher of this.drainTurnWatchers(activeTurn)) {
-        watcher.reject(error);
+    const pendingRequests = Array.from(this.pendingRequests.values());
+    this.pendingRequests.clear();
+
+    const rejectSessionWaiters = () => {
+      if (activeTurn) {
+        for (const watcher of this.drainTurnWatchers(activeTurn)) {
+          watcher.reject(error);
+        }
+        activeTurn.reject(error);
       }
-      activeTurn.reject(error);
-    }
 
-    for (const pending of this.pendingRequests.values()) {
-      pending.reject(error);
-    }
-    this.pendingRequests.clear();
+      for (const pending of pendingRequests) {
+        pending.reject(error);
+      }
+    };
 
-    void appendFile(this.stderrLogPath, `[openscout] ${error.message}\n`).catch(() => undefined);
+    void appendFile(this.stderrLogPath, `[openscout] ${error.message}\n`)
+      .catch(() => undefined)
+      .finally(rejectSessionWaiters);
     void this.persistState();
   }
 
diff --git a/packages/session-trace-react/package.json b/packages/session-trace-react/package.json
index 67c605a6..e03ab620 100644
--- a/packages/session-trace-react/package.json
+++ b/packages/session-trace-react/package.json
@@ -18,7 +18,8 @@
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
-    "check": "tsc --noEmit -p tsconfig.json"
+    "check": "tsc --noEmit -p tsconfig.json",
+    "test": "bun test ./src"
   },
   "dependencies": {
     "@openscout/session-trace": "workspace:*"
diff --git a/packages/session-trace/package.json b/packages/session-trace/package.json
index 91b1f95d..50cb1c90 100644
--- a/packages/session-trace/package.json
+++ b/packages/session-trace/package.json
@@ -18,7 +18,8 @@
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
-    "check": "tsc --noEmit -p tsconfig.json"
+    "check": "tsc --noEmit -p tsconfig.json",
+    "test": "bun test ./src"
   },
   "dependencies": {
     "@openscout/agent-sessions": "workspace:*"
diff --git a/packages/web/client/lib/router.test.ts b/packages/web/client/lib/router.test.ts
index f0536214..cd7a29a6 100644
--- a/packages/web/client/lib/router.test.ts
+++ b/packages/web/client/lib/router.test.ts
@@ -1,6 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
-import { clearRouteMachineScope, routeFromUrl, routePath, setRouteMachineScope } from "./router.ts";
+mock.module("react", () => ({
+  useCallback: <T extends (...args: unknown[]) => unknown>(value: T) => value,
+  useEffect: () => {},
+  useRef: <T>(value: T) => ({ current: value }),
+  useState: <T>(value: T) => [value, () => {}] as const,
+}));
+
+const { clearRouteMachineScope, routeFromUrl, routePath, setRouteMachineScope } = await import("./router.ts");
 
 describe("agents route parsing", () => {
   test("conversations routes round-trip", () => {
diff --git a/packages/web/package.json b/packages/web/package.json
index ac97f5c0..90a570a3 100644
--- a/packages/web/package.json
+++ b/packages/web/package.json
@@ -33,6 +33,7 @@
     "prepack": "npm run build && node ../../scripts/prepare-publish-manifest.mjs .",
     "postpack": "node ../../scripts/restore-publish-manifest.mjs .",
     "postpublish": "node ../../scripts/restore-publish-manifest.mjs .",
+    "test": "bun test --isolate ./client ./server && node --test test/*.test.mjs",
     "test:happy": "node --test test/*.test.mjs"
   },
   "dependencies": {
diff --git a/packages/web/server/core/observe/service.test.ts b/packages/web/server/core/observe/service.test.ts
index 9e16efbe..0f5473c5 100644
--- a/packages/web/server/core/observe/service.test.ts
+++ b/packages/web/server/core/observe/service.test.ts
@@ -216,6 +216,7 @@ describe("buildObserveDataFromSnapshot", () => {
         adapterType: "claude-code",
         model: "claude-opus-test",
         cwd: "/Users/arach/dev/openscout",
+        sessionStart: expect.any(Number),
         externalSessionId: "upstream-123",
         gitBranch: "master",
         cliVersion: "2.1.119",