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/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/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..a577ac8f 100644
--- a/packages/runtime/src/broker-daemon.test.ts
+++ b/packages/runtime/src/broker-daemon.test.ts
@@ -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);
diff --git a/packages/runtime/src/broker-daemon.ts b/packages/runtime/src/broker-daemon.ts
index d40d730c..7866850f 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 () => {
@@ -6675,7 +6677,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;
@@ -6685,13 +6687,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;
   }
 
@@ -6720,7 +6722,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);
@@ -6735,7 +6737,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,
@@ -6745,7 +6747,7 @@ async function resolveInvocationTarget(
   }, {
     requesterId: payload.requesterId,
     currentDirectory: projectPathRouteTarget(payload),
-    reason: "implicit project invocation card",
+    reason: "ask-defined agent card for project invocation",
   });
 }
 
@@ -7534,13 +7536,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();
   }