From 2dfe52b46099dfd420e65338147e785ff262ca18 Mon Sep 17 00:00:00 2001
From: Arach Tchoupani <arach@tchoupani.com>
Date: Fri, 5 Jun 2026 14:01:52 -0400
Subject: [PATCH 1/2] =?UTF-8?q?=E2=9C=A8=20Infer=20current-project=20ask?=
 =?UTF-8?q?=20target=20from=20harness/--new?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When `scout ask` gets only execution preferences (--harness, --session new, or
--new) and no --to/--ref/--project, route to the current directory and request a
one-time fresh project agent. Adds --session new / --new flags and rejects
mixed/unsupported session preferences before routing.
---
 apps/desktop/src/cli/commands/ask.test.ts    |   2 +
 apps/desktop/src/cli/commands/ask.ts         |   8 +-
 apps/desktop/src/cli/help.test.ts            |   1 +
 apps/desktop/src/cli/help.ts                 |   2 +
 apps/desktop/src/cli/options.test.ts         |  44 +++++++
 apps/desktop/src/cli/options.ts              |  87 ++++++++++++-
 apps/desktop/src/core/broker/ask.ts          |  20 ++-
 apps/desktop/src/core/broker/service.test.ts | 122 +++++++++++++++++++
 apps/desktop/src/core/broker/service.ts      |   5 +
 packages/cli/test/scout-wrapper.test.mjs     |  29 +++++
 10 files changed, 316 insertions(+), 4 deletions(-)

diff --git a/apps/desktop/src/cli/commands/ask.test.ts b/apps/desktop/src/cli/commands/ask.test.ts
index 3bbf5024..eefa6f3b 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 d77c58c4..ff041fa8 100644
--- a/apps/desktop/src/cli/commands/ask.ts
+++ b/apps/desktop/src/cli/commands/ask.ts
@@ -26,7 +26,7 @@ const DEFAULT_ASK_DISPATCH_SETTLE_MS = 4_000;
 
 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.",
     "",
@@ -36,6 +36,7 @@ export function renderAskCommandHelp(): string {
     "  short @name                        -> agent card; starts fresh harness session",
     "  --to session:<id>                  -> continue one exact existing session",
     "  --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.\"",
@@ -44,6 +45,7 @@ export function renderAskCommandHelp(): string {
     "Use the flight id, conversation, notify mode, or an explicit wait to follow the final completion.",
     "Agent-card targets are fresh-session requests. Use a session id only when you intend to keep exact prior context.",
     "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",
@@ -54,7 +56,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"',
@@ -310,6 +313,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 209ea426..afa94209 100644
--- a/apps/desktop/src/cli/help.ts
+++ b/apps/desktop/src/cli/help.ts
@@ -34,6 +34,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",
@@ -80,6 +81,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 a8adfdf6..8df307d9 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 7d4a349b..d2d70802 100644
--- a/apps/desktop/src/cli/options.ts
+++ b/apps/desktop/src/cli/options.ts
@@ -34,6 +34,7 @@ export type ScoutAskCommandOptions = ContextRootOptions & {
   projectPath?: string;
   channel?: string;
   harness?: string;
+  session?: "new";
   timeoutSeconds?: number;
   replyMode?: "inline" | "notify" | "none";
   labels?: string[];
@@ -183,6 +184,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,
@@ -486,6 +517,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;
@@ -531,6 +563,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);
@@ -589,6 +634,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");
   }
@@ -611,6 +662,7 @@ export function parseAskCommandOptions(
     projectPath,
     channel,
     harness,
+    session,
     timeoutSeconds,
     replyMode,
     ...(labels.length ? { labels } : {}),
@@ -627,6 +679,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;
@@ -653,6 +706,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);
@@ -701,7 +767,7 @@ export function parseImplicitAskCommandOptions(
   }
 
   const input = messageParts.join(" ").trim();
-  if (!input) {
+  if (!input && !promptFile) {
     throw new ScoutCliError("no question provided");
   }
 
@@ -724,6 +790,7 @@ export function parseImplicitAskCommandOptions(
       projectPath: routed.projectPath,
       channel: mergeComposerChannel(channel, routed.channel),
       harness,
+      session,
       timeoutSeconds,
       replyMode,
       ...(labels.length ? { labels } : {}),
@@ -734,6 +801,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) {
@@ -756,6 +840,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 b2140f00..73c7abef 100644
--- a/apps/desktop/src/core/broker/ask.ts
+++ b/apps/desktop/src/core/broker/ask.ts
@@ -226,6 +226,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";
@@ -256,6 +262,17 @@ export const scoutAskHandler: ScoutAskHandler = async (command) => {
     currentDirectory,
   );
   const requestedTo = command.to?.trim() || "";
+  const inferredProjectPath =
+    !requestedTo && !commandProjectPath && shouldInferCurrentProjectAskTarget(command)
+      ? currentDirectory
+      : undefined;
+  const targetProjectPath = commandProjectPath ?? inferredProjectPath;
+  const projectAgent =
+    targetProjectPath
+    && !requestedTo
+    && (inferredProjectPath || command.session === "new")
+      ? { persistence: "one_time" as const }
+      : undefined;
   if (requestedTo && commandProjectPath) {
     return {
       ok: false,
@@ -280,7 +297,7 @@ export const scoutAskHandler: ScoutAskHandler = async (command) => {
   }
   const resolvedTarget = askResolvedTargetFor({
     to: requestedTo,
-    projectPath: commandProjectPath,
+    projectPath: targetProjectPath,
   });
   if (!resolvedTarget) {
     return {
@@ -314,6 +331,7 @@ export const scoutAskHandler: ScoutAskHandler = async (command) => {
     executionSession: executionSessionForAsk(command.session),
     workspace: command.workspace,
     senderContext,
+    projectAgent,
     currentDirectory,
     source: command.source ?? "scout-ask",
   });
diff --git a/apps/desktop/src/core/broker/service.test.ts b/apps/desktop/src/core/broker/service.test.ts
index 1be4c506..490a3a92 100644
--- a/apps/desktop/src/core/broker/service.test.ts
+++ b/apps/desktop/src/core/broker/service.test.ts
@@ -1092,6 +1092,128 @@ describe("scoutAskHandler", () => {
 
   }, 15000);
 
+  test("infers a one-time project 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 };
+      projectAgent?: { persistence?: 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",
+    });
+    expect(captured.delivery?.projectAgent).toEqual({
+      persistence: "one_time",
+    });
+
+    captured.delivery = null;
+    await scoutAskHandler({
+      senderId: "operator",
+      projectPath: projectRoot,
+      body: "Review this.",
+      session: "new",
+      currentDirectory: "/tmp",
+    });
+
+    const explicitProjectDelivery = captured.delivery as CapturedDelivery | null;
+    expect(explicitProjectDelivery?.target).toEqual({
+      kind: "project_path",
+      projectPath: projectRoot,
+    });
+    expect(explicitProjectDelivery?.execution).toEqual({
+      session: "new",
+    });
+    expect(explicitProjectDelivery?.projectAgent).toEqual({
+      persistence: "one_time",
+    });
+  }, 15000);
+
   test("rejects project-prefixed to targets at the core boundary", async () => {
     const receipt = await scoutAskHandler({
       senderId: "operator",
diff --git a/apps/desktop/src/core/broker/service.ts b/apps/desktop/src/core/broker/service.ts
index 37b5c91e..95683861 100644
--- a/apps/desktop/src/core/broker/service.ts
+++ b/apps/desktop/src/core/broker/service.ts
@@ -36,6 +36,7 @@ import {
   type ScoutInvocationLifecycle,
   type ScoutDeliverResponse,
   type ScoutDispatchRecord,
+  type ScoutProjectAgentSpec,
   type WakePolicy,
   type WorkItemRecord,
   type WorkItemState,
@@ -3810,6 +3811,7 @@ export async function deliverScoutAsk(input: {
   workspace?: ScoutAskWorkspace;
   senderContext?: ScoutAskSenderContext;
   labels?: string[];
+  projectAgent?: ScoutProjectAgentSpec;
   targetSessionId?: string;
   replyToSessionId?: string;
   currentDirectory?: string;
@@ -3884,6 +3886,7 @@ export async function deliverScoutAsk(input: {
       ...(targetSessionId ? { targetSessionId } : {}),
       session: input.executionSession ?? defaultAskExecutionSession(input.target),
     },
+    ...(input.projectAgent ? { projectAgent: input.projectAgent } : {}),
     ensureAwake: true,
     ...(labels ? { labels } : {}),
     messageMetadata: deliveryMetadata,
@@ -3936,6 +3939,7 @@ export async function askScoutQuestion(input: {
   workspace?: ScoutAskWorkspace;
   senderContext?: ScoutAskSenderContext;
   labels?: string[];
+  projectAgent?: ScoutProjectAgentSpec;
   targetSessionId?: string;
   replyToSessionId?: string;
   currentDirectory?: string;
@@ -3961,6 +3965,7 @@ export async function askScoutQuestion(input: {
     workspace: input.workspace,
     senderContext: input.senderContext,
     labels: input.labels,
+    projectAgent: input.projectAgent,
     targetSessionId: input.targetSessionId,
     replyToSessionId: input.replyToSessionId,
     currentDirectory: input.currentDirectory,
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;
+    },
+  );
+});

From f9fc8f1a927ab3d58e6d6bc79d93bb86340caef5 Mon Sep 17 00:00:00 2001
From: Arach Tchoupani <arach@tchoupani.com>
Date: Fri, 5 Jun 2026 14:01:52 -0400
Subject: [PATCH 2/2] =?UTF-8?q?=F0=9F=93=9D=20Document=20current-project?=
 =?UTF-8?q?=20ask=20routing?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cover `scout ask --harness codex` current-project routing and session: "new"
semantics in the CLI README and runtime-sessions notes.
---
 docs/runtime-sessions.md | 12 ++++++++++++
 packages/cli/README.md   | 13 +++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/docs/runtime-sessions.md b/docs/runtime-sessions.md
index d093ca68..b040ca1e 100644
--- a/docs/runtime-sessions.md
+++ b/docs/runtime-sessions.md
@@ -263,6 +263,12 @@ 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 CLI or MCP ask provides only execution preferences, such as
+`--harness codex` or `session: "new"`, Scout treats the current directory as the
+project target and requests a one-time project agent for that fresh work. This
+keeps "run this repo in a fresh compatible worker" cheap without forcing the
+caller to pre-create or choose a stable card.
+
 ## Ask Targets And Reply Sessions
 
 An ask has two different routes:
@@ -282,6 +288,12 @@ metadata; it does not mean "reuse whatever thread was last attached." Scout
 should consult stale session metadata only when the request names an exact
 `targetSessionId`/`session:<id>` and that session cannot be reached.
 
+`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. Scout defines a one-time
+project agent when the caller routed by project and explicitly asked for one.
+
 Use exact `agentId` or project routing when the sender knows who should own the
 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
diff --git a/packages/cli/README.md b/packages/cli/README.md
index de70c4b6..dfa2d2b0 100644
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@@ -109,6 +109,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.
@@ -210,6 +211,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