@stigmer/cli 3.12.8 → 3.13.0

package/src/local/status.ts

@@ -12,7 +12,7 @@ import { join } from "node:path";
 import { load as loadConfig } from "../config/config.js";
 import { configPath } from "../config/paths.js";
 import { CommandResult } from "../output/command-result.js";
-import { SERVER_PORT, TEMPORAL_UI_PORT, WEB_CONSOLE_PORT } from "./constants.js";
+import { SERVER_PORT, TEMPORAL_UI_PORT } from "./constants.js";
 import { resolveApiKey, resolveProvider } from "./llm-config.js";
 import { tcpConnects } from "./net/tcp.js";
 import { dataDir } from "./paths.js";
@@ -144,7 +144,9 @@ function addWebUiSection(result: CommandResult, health: HealthState): void {
   if (!temporalRunning && !webRunning) return;
 
   const section = result.addSection("Web UI");
-  if (webRunning) section.field("Console", `http://localhost:${WEB_CONSOLE_PORT}`);
+  // The console shares the server's unified port (DD-012) — same origin as
+  // the API, served by the server itself.
+  if (webRunning) section.field("Console", `http://localhost:${SERVER_PORT}`);
   if (temporalRunning) section.field("Temporal", `http://localhost:${TEMPORAL_UI_PORT}`);
 }
 

package/src/local/webconsole/index.ts

@@ -1,13 +1,30 @@
-// Embedded web-console availability.
+// Web-console availability against the server's unified port.
 //
-// The Go CLI embeds the console's static assets via go:embed and serves them on
-// :8234. There is no TS equivalent bundled in T05, so the daemon detects the
-// console as unavailable and skips it cleanly (recording a "stopped" state),
-// exactly as the Go daemon does when built without assets. Real serving — and
-// the asset-bundling decision behind it — is deferred to T06.
+// Since DD-012 (oss sub-project console-serving) the SERVER serves the
+// console: the static export ships inside @stigmer/server-slim and the
+// unified port's lane 4 serves it, synthesizing /config.json in-process.
+// The CLI therefore PROBES rather than serves — /config.json answers 200
+// exactly when a console export is bundled with the running server (a
+// dev-tree server without the export falls through to the RPC adapter's
+// 404), so the daemon's component state reports what a browser would
+// actually find. The Go-era embedded console (go:embed on :8234) and the
+// T05/T06 stub this file used to be are both retired by that design.
 
-/** Whether an embedded web console is available to serve. Always false until
- * T06 wires asset bundling + an HTTP handler. */
-export function isWebConsoleAvailable(): boolean {
-  return false;
+import { SERVER_PORT } from "../constants.js";
+
+/** Keep the daemon's settle path snappy: a hung probe must not stall `stigmer up`. */
+const PROBE_TIMEOUT_MS = 3000;
+
+/** Whether the running server serves a bundled web console. */
+export async function isWebConsoleAvailable(
+  serverPort: number = SERVER_PORT,
+): Promise<boolean> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${serverPort}/config.json`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
 }

package/src/resources/connect/oauth.test.ts

@@ -127,6 +127,6 @@ describe("runOAuthFlow", () => {
       sleep: noopSleep,
       log: () => {},
     });
-    expect(openBrowser).toHaveBeenCalledWith("http://localhost:8234/acme/mcp-servers/github");
+    expect(openBrowser).toHaveBeenCalledWith("http://localhost:7234/acme/mcp-servers/github");
   });
 });

package/src/resources/run/agent-exec.test.ts

@@ -11,6 +11,7 @@ import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import {
   LocalPathSourceSchema,
   WorkspaceEntrySchema,
@@ -48,6 +49,7 @@ function makePrepared(overrides: Partial<PreparedRun> = {}): PreparedRun {
     mode: "",
     serviceTier: "",
     thinking: "",
+    harness: "",
     ...overrides,
   };
 }
@@ -127,4 +129,27 @@ describe("executeResolvedAgent", () => {
     expect(sent[0]?.spec?.sessionSpec).toBeUndefined();
     expect(sent[0]?.spec?.agentId).toBe("agt_1");
   });
+
+  it("threads the resolved harness onto the wire and surfaces it in the header (oss#293)", async () => {
+    // The revert-detection seam: if the prepared→create threading is ever
+    // dropped, this wire assertion fails — not just a flag-parsing test.
+    const { client, creates } = fakeBackend();
+
+    await executeResolvedAgent({
+      agent: makeAgent(),
+      prepared: makePrepared({ harness: "cursor" }),
+      org: "acme",
+      downloadDir: "",
+      outputMode: "inline",
+      client,
+    });
+
+    const sent = creates();
+    expect(sent).toHaveLength(1);
+    expect(sent[0]?.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
+    // D2 visibility: a cursor session must announce itself before streaming —
+    // whether the flag or the account preference selected it.
+    expect(stderrLines.join("")).toContain("Harness:");
+    expect(stderrLines.join("")).toContain("Cursor");
+  });
 });

package/src/resources/run/agent-exec.ts

@@ -45,6 +45,7 @@ export async function executeResolvedAgent(input: ResolvedAgentExecInput): Promi
     serviceTier: prepared.serviceTier,
     thinking: prepared.thinking,
     autoApproveAll: prepared.autoApproveAll,
+    harness: prepared.harness,
   });
 
   // The backend owns the canonical session id: it creates the session and
@@ -56,6 +57,7 @@ export async function executeResolvedAgent(input: ResolvedAgentExecInput): Promi
     sessionId,
     model: prepared.model,
     mode: prepared.mode,
+    harness: prepared.harness,
     workspaces: workspaceNames(prepared.workspaceEntries),
   };
 

package/src/resources/run/create.test.ts

@@ -6,6 +6,7 @@
 import { describe, expect, it } from "vitest";
 import { InteractionMode, ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { create } from "@bufbuild/protobuf";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import {
   LocalPathSourceSchema,
   WorkspaceEntrySchema,
@@ -43,6 +44,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: true,
+      harness: "",
     });
 
     expect(exec.kind).toBe("AgentExecution");
@@ -72,6 +74,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.message).toBe("hi");
     expect(exec.spec?.executionConfig).toBeUndefined();
@@ -92,6 +95,7 @@ describe("createAgentExecution", () => {
       serviceTier: "fast",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.FAST);
   });
@@ -113,6 +117,7 @@ describe("createAgentExecution", () => {
       serviceTier: "standard",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.STANDARD);
   });
@@ -132,6 +137,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "enabled",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
   });
@@ -153,6 +159,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "disabled",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.DISABLED);
   });
@@ -172,6 +179,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.sessionId).toBe("ses_1");
     expect(exec.spec?.executionConfig?.interactionMode).toBe(InteractionMode.UNSPECIFIED);
@@ -199,6 +207,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
 
     expect(exec.spec?.sessionId).toBe("");
@@ -206,9 +215,16 @@ describe("createAgentExecution", () => {
     // Subject stays empty so the server defaults its sentinel and the async
     // title activity generates a real one.
     expect(exec.spec?.sessionSpec?.subject).toBe("");
+    // No harness opinion: the field stays UNSPECIFIED so the server default
+    // (native) applies — a workspace-only run is byte-identical to before
+    // the --harness flag existed.
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.UNSPECIFIED);
   });
 
-  it("omits session_spec when there are no workspace entries", async () => {
+  it("omits session_spec when there are no workspace entries and no harness (wire-shape regression pin)", async () => {
+    // The pre---harness wire shape for a plain run: NO embedded session_spec
+    // at all. If this pin fails, plain runs have started carrying a spec they
+    // never carried before — a silent contract change, not a feature.
     const { fn } = fakeController();
     const exec = await createAgentExecution(fn, {
       agentId: "agt_1",
@@ -223,9 +239,84 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.sessionSpec).toBeUndefined();
   });
+
+  it("stamps cursor harness on a session_spec created just for it (oss#293)", async () => {
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "cursor",
+    });
+    // Harness alone justifies the embedded spec: the server clones it onto
+    // the auto-created session (the one-call bootstrap contract).
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
+    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([]);
+  });
+
+  it("stamps an explicit native harness rather than leaving it unspecified", async () => {
+    // "native" may be a deliberate per-run escape from the account's
+    // default_harness preference — it must survive on the wire so it beats
+    // any future change to the server-side default (D3).
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "native",
+    });
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.NATIVE);
+  });
+
+  it("carries harness and workspace entries together on one session_spec", async () => {
+    const entry = create(WorkspaceEntrySchema, {
+      name: "repo",
+      source: create(WorkspaceSourceSchema, {
+        source: { case: "localPath", value: create(LocalPathSourceSchema, { path: "/home/user/repo" }) },
+      }),
+    });
+
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [entry],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "cursor",
+    });
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
+    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([entry]);
+  });
 });
 
 describe("createWorkflowExecution", () => {

package/src/resources/run/create.ts

@@ -18,7 +18,8 @@ import {
   ExecutionConfigSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import type { ExecutionValue } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
-import { SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { type SessionSpec, SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import {
   type WorkflowExecution,
@@ -29,7 +30,7 @@ import { WorkflowExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/
 import { ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 import type { RuntimeEnv } from "./env.js";
-import type { RunMode, ServiceTierFlag, ThinkingFlag } from "./prepare.js";
+import type { HarnessFlag, RunMode, ServiceTierFlag, ThinkingFlag } from "./prepare.js";
 
 const API_VERSION = "agentic.stigmer.ai/v1";
 
@@ -60,6 +61,7 @@ export interface CreateAgentExecutionInput {
   readonly serviceTier: ServiceTierFlag;
   readonly thinking: ThinkingFlag;
   readonly autoApproveAll: boolean;
+  readonly harness: HarnessFlag;
 }
 
 /** Create an agent execution. Mirrors Go's createAgentExecution. */
@@ -81,10 +83,7 @@ export async function createAgentExecution(
       agentId: input.agentId ?? "",
       // Subject is left empty: the server defaults its sentinel and the async
       // title activity replaces it, same as any auto-created session.
-      sessionSpec:
-        input.workspaceEntries.length > 0
-          ? create(SessionSpecSchema, { workspaceEntries: [...input.workspaceEntries] })
-          : undefined,
+      sessionSpec: buildSessionSpec(input.workspaceEntries, input.harness),
       executionConfig: buildExecutionConfig(input.model, input.mode, input.serviceTier, input.thinking),
     }),
   });
@@ -121,6 +120,26 @@ export async function createWorkflowExecution(
   return controller(WorkflowExecutionCommandController).create(execution);
 }
 
+// Build the embedded session spec for the one-call bootstrap
+// (stigmer/stigmer#249), or undefined when there is nothing to carry — the
+// pre-existing wire shape for a plain run must stay byte-identical. A resolved
+// harness is stamped explicitly, including "native": the value may be a
+// deliberate per-run escape from the account's default_harness preference, so
+// it must survive any future change to the server-side default. Empty means
+// "no opinion" and stays off the wire (server defaults to native). The server
+// clones this spec onto the auto-created session and then clears it from the
+// persisted execution — the Session resource stays the single source of truth.
+function buildSessionSpec(
+  workspaceEntries: readonly WorkspaceEntry[],
+  harness: HarnessFlag,
+): SessionSpec | undefined {
+  if (workspaceEntries.length === 0 && harness === "") return undefined;
+  const spec = create(SessionSpecSchema, { workspaceEntries: [...workspaceEntries] });
+  if (harness === "cursor") spec.harness = Harness.CURSOR;
+  else if (harness === "native") spec.harness = Harness.NATIVE;
+  return spec;
+}
+
 // Build ExecutionConfig, or undefined when no flag is set so the backend
 // applies its defaults. Mirrors Go's buildExecutionConfig (only "plan" maps to a
 // non-default InteractionMode; "agent"/"" leave it unspecified). An explicit

package/src/resources/run/header.test.ts

@@ -31,6 +31,24 @@ describe("renderSessionHeader", () => {
     expect(agent.text()).not.toContain("Mode:");
   });
 
+  it("surfaces the cursor harness but not native/default (oss#293 D2 visibility)", () => {
+    // A cursor session may have been selected by the account preference, not
+    // a flag — the header is the CLI's only pre-stream channel to say so.
+    const cursor = capture();
+    renderSessionHeader(cursor.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "cursor", workspaces: [] });
+    expect(cursor.text()).toContain("Harness:");
+    expect(cursor.text()).toContain("Cursor");
+
+    // Native (explicit or defaulted) stays implicit, like agent mode.
+    const native = capture();
+    renderSessionHeader(native.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "native", workspaces: [] });
+    expect(native.text()).not.toContain("Harness:");
+
+    const unset = capture();
+    renderSessionHeader(unset.out, { agentName: "", sessionId: "s", model: "", mode: "", workspaces: [] });
+    expect(unset.text()).not.toContain("Harness:");
+  });
+
   it("indents extra workspaces under the first", () => {
     const { out, text } = capture();
     renderSessionHeader(out, {

package/src/resources/run/header.ts

@@ -11,7 +11,7 @@
 
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import { shouldColorize, styler } from "../../output/style.js";
-import type { RunMode } from "./prepare.js";
+import type { HarnessFlag, RunMode } from "./prepare.js";
 
 export interface SessionHeaderInfo {
   readonly agentName: string;
@@ -20,6 +20,14 @@ export interface SessionHeaderInfo {
   readonly subject?: string;
   readonly model: string;
   readonly mode: RunMode;
+  /**
+   * Resolved harness for the session. Surfaced only when it is "cursor":
+   * a harness switch changes the toolset, conversation-state model, and
+   * billing tier, and it may come from the account preference rather than
+   * a flag — a cursor session must never start silently (the CLI
+   * counterpart of the web composer's harness selector).
+   */
+  readonly harness?: HarnessFlag;
   readonly workspaces: readonly string[];
 }
 
@@ -39,6 +47,8 @@ export function renderSessionHeader(out: { write(chunk: string): unknown; isTTY?
   if (info.sessionId !== "") lines.push(row(s, "Session", info.sessionId));
   if ((info.subject ?? "") !== "") lines.push(row(s, "Subject", info.subject ?? ""));
   if (info.model !== "") lines.push(row(s, "Model", info.model));
+  // Only "cursor" is surfaced; native/"" is the default and stays implicit.
+  if (info.harness === "cursor") lines.push(row(s, "Harness", "Cursor"));
   // Only "plan" is surfaced; "agent"/"" is the default and stays implicit.
   if (info.mode === "plan") lines.push(row(s, "Mode", "Plan (read-only)"));
   if (info.workspaces.length > 0) {