@khorsheed/dsh-local-agent-dsh-headless 0.1.0-rc.6

package/lib/index.js

@@ -0,0 +1,507 @@
+import { LIVE_SERVER_NAME, LIVE_WIRE_ERROR_INTERNAL, LIVE_WIRE_ERROR_METHOD_NOT_FOUND } from "./wire.js";
+import z from "@deepseek-ai/schemastery";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { StringDecoder } from "node:string_decoder";
+//#region lib/types/agent-loader.js
+/**
+* Agent loading and turn aggregation shared by the one-shot runner and the
+* serve loop: both drive a direct Agent over the core registry with the same
+* model selection, the same scoped installModelSelection setup, the same
+* preset join, and the same caller-supplied session identity, differing only
+* in process lifetime.
+* @module @khorsheed/dsh-local-agent-dsh-headless/agent-loader
+*/
+/**
+* Aggregate the last assistant text and turn outcome in one owned interval.
+* @param events - the agent session's full event log.
+* @param firstSeq - the session seq at which this driver's interval opened.
+*/
+function summarizeTurn(events, firstSeq) {
+	let started = false;
+	let text = "";
+	let reason;
+	for (const event of events) {
+		if (event.seq < firstSeq) continue;
+		if (event.type === "turn/start") {
+			started = true;
+			continue;
+		}
+		if (!started) continue;
+		if (event.type === "assistant/message") {
+			const joined = event.data.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+			if (joined !== "") text = joined;
+		}
+		if (event.type === "turn/end") reason = event.data.reason;
+	}
+	return {
+		text,
+		reason
+	};
+}
+/**
+* Apply a `--model` request onto the instance's default selection.
+*
+* The request is spelled `provider/model` — the same shape
+* `effectiveSettings.model` reports the configured model in — and splits at
+* the FIRST slash, so a provider-qualified id survives a model id that
+* contains none. A request with no slash names the MODEL only and keeps the
+* default selection's provider, which is what a caller switching between two
+* models of the same route means.
+*
+* Everything else on the selection is carried through untouched (the
+* reasoning effort in particular): `--model` changes the model, not the rest
+* of the instance's configuration. An absent or blank request returns the
+* default selection unchanged — byte for byte the behavior before the flag
+* existed.
+* @param selection - the instance's default model selection.
+* @param request - the `--model` value, when the launch carried one.
+* @returns the selection this launch runs.
+*/
+function applyModelRequest(selection, request) {
+	const wanted = request?.trim();
+	if (wanted === void 0 || wanted === "") return selection;
+	const slash = wanted.indexOf("/");
+	if (slash <= 0 || slash === wanted.length - 1) return {
+		...selection,
+		model: wanted
+	};
+	return {
+		...selection,
+		provider: wanted.slice(0, slash),
+		model: wanted.slice(slash + 1)
+	};
+}
+/**
+* Join this agent to the sub-profile's preset, when the sub-profile composes
+* a roster.
+*
+* Without a roster this is a no-op and the agent reads the model-facing rows
+* off the global layer — byte for byte the behavior of every sub-dsh before
+* the roster layer existed, and the right answer for a rosterless
+* composition (`@deepseek-ai/dsh-agent-presets` README, "Composing a child
+* agent"). With one, the preset decides the tools, prompt sections and
+* skills of every session this process hosts, which is what makes the
+* scope's capability face a per-condition factor instead of an instance-wide
+* constant.
+*
+* A roster that REFUSES (unknown preset id, broken composition) is not
+* degraded past: mounting rejects, the agent creation rolls back, and the
+* launch fails naming the preset. A sub-dsh that silently ran the global
+* layer after being told to run preset X would attribute the round to a
+* capability face it never had.
+* @param ctx - plugin context (where the roster service is resolved).
+* @param agentCtx - the agent's scope context, which joins the standing mount.
+* @returns the preset id joined, or undefined when the composition has no roster.
+*/
+async function joinSubDshPreset(ctx, agentCtx) {
+	const roster = ctx.get("agentPresets");
+	if (roster?.mount === void 0) return void 0;
+	return (await roster.mount(agentCtx)).id;
+}
+/**
+* Create or resume the direct Agent for one caller-named session. The caller
+* resolved the core services first (both call sites bail out on a disposed
+* tree). The caller-supplied id is authoritative for both branches: the
+* parent provider generated one uuid and passes the same value on every round
+* of the same delegation, so resume finds exactly the sub-dsh session the
+* fresh round created.
+* @param ctx - plugin context carrying the Agent registry and default model.
+* @param identity - fresh (`sessionId`) or continuation (`resumeSessionId`).
+* @returns the owned agent handle (its disposer unwinds the agent's world).
+*/
+async function loadSubDshAgent(ctx, identity) {
+	const agents = ctx.get("agents");
+	if (agents === void 0) throw new Error("local-agent-dsh-headless: the agents service is not mounted");
+	const selection = await resolveSubDshSelection(ctx, identity.model, identity.effort);
+	const agentOptions = {
+		provider: selection.provider,
+		model: selection.model
+	};
+	const setup = async (agentCtx) => {
+		installModelSelection(agentCtx, {
+			current: selection,
+			assembled: void 0
+		});
+		await joinSubDshPreset(ctx, agentCtx);
+	};
+	if (identity.resumeSessionId !== void 0) return agents.resume({
+		resumeSessionId: SessionId(identity.resumeSessionId),
+		agentOptions,
+		setup
+	});
+	return agents.create({
+		sessionId: SessionId(identity.sessionId ?? `session-${randomUUID()}`),
+		meta: { cwd: process.cwd() },
+		agentOptions,
+		setup
+	});
+}
+/** Validate the actual sub-instance's configuration without creating a session or generating. */
+async function resolveSubDshSelection(ctx, model, effort, validateModel = false) {
+	const defaults = ctx.get("agentDefaultModel");
+	if (defaults === void 0) throw new Error("local-agent-dsh-headless: agentDefaultModel is not mounted");
+	const selection = applyModelRequest(defaults.currentSelection(), model);
+	if (effort === void 0 && !validateModel) return selection;
+	let timer;
+	try {
+		const info = await Promise.race([ctx.get("llm")?.resolveModelInfo(selection.provider, selection.model, AbortSignal.timeout(5e3)), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Sub-DSH model validation timed out")), 5e3);
+			timer.unref();
+		})]);
+		if (info === void 0) throw new Error("The sub-DSH adapter cannot resolve the requested model");
+		if (effort === void 0) return selection;
+		const native = info.reasoning?.efforts.find((option) => String(option.id) === effort);
+		if (native === void 0) throw new Error("The sub-DSH model does not advertise the requested reasoning effort");
+		return {
+			...selection,
+			reasoningEffort: native.id
+		};
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region lib/types/serve.js
+/**
+* Serve mode: the resident sub-dsh loop behind the family-internal live-driver
+* wire (see `./wire.ts`). Where the one-shot runner drives a single task and
+* exits, serve mode keeps the tree alive on stdin: each `turn/start` request
+* feeds one followup into the caller-named session's Agent, every session
+* event streams back as a `session/event` notification while it happens, and
+* `session/idle` closes the turn after the log flush. `turn/interrupt`
+* delivers the runtime-level graceful cancel (`Agent.cancel`) that the
+* process boundary cannot express — the process survives and the session
+* stays continuable, which is the live driver's reason to exist.
+* @module @khorsheed/dsh-local-agent-dsh-headless/serve
+*/
+/** Flatten an unknown thrown value for a wire error or stderr line. */
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Run the resident loop until stdin closes or a `shutdown` request arrives.
+* @param ctx - plugin context carrying the loader settle, core services, and
+*   the session/event feed.
+* @param io - process-facing effects.
+*/
+async function runServe(ctx, io, model, effort) {
+	await ctx.get("loader")?.await();
+	const agents = ctx.get("agents");
+	const sessions = ctx.get("sessions");
+	if (agents === void 0 || sessions === void 0 || ctx.get("agentDefaultModel") === void 0) {
+		io.stderr.write("dsh: serve mode requires the agents, sessions, and agentDefaultModel services\n");
+		io.exit(1);
+		return;
+	}
+	/** Loaded agents by caller session id; one member per process in practice. */
+	const managed = /* @__PURE__ */ new Map();
+	/** Per-session turn serialization: one in-flight turn per session, FIFO. */
+	const queues = /* @__PURE__ */ new Map();
+	/**
+	* The in-flight round's parent-supplied turn number per session, set while
+	* a turn body runs and echoed on its notifications — the parent drops a
+	* cancelled round's late unwind instead of mis-settling the next round.
+	*/
+	const activeTurns = /* @__PURE__ */ new Map();
+	let shuttingDown = false;
+	let buffer = "";
+	const decoder = new StringDecoder("utf8");
+	const send = (message) => {
+		io.stdout.write(JSON.stringify(message) + "\n");
+	};
+	const respond = (id, result) => {
+		send({
+			jsonrpc: "2.0",
+			id,
+			result
+		});
+	};
+	const respondError = (id, message, code = LIVE_WIRE_ERROR_INTERNAL) => {
+		send({
+			jsonrpc: "2.0",
+			id,
+			error: {
+				code,
+				message
+			}
+		});
+	};
+	const notify = (method, params) => {
+		send({
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	};
+	ctx.on("session/event", (session, event) => {
+		if (shuttingDown || !managed.has(String(session.id))) return;
+		const id = String(session.id);
+		notify("session/event", {
+			sessionId: id,
+			turn: activeTurns.get(id) ?? null,
+			event
+		});
+	});
+	ctx.on("agent/assistant-stream", ({ agent, frame }) => {
+		const sessionId = String(agent.session.id);
+		const turn = activeTurns.get(sessionId);
+		if (shuttingDown || !managed.has(sessionId) || turn === void 0) return;
+		notify("session/assistant-stream", {
+			sessionId,
+			turn,
+			frame
+		});
+	}, { global: true });
+	const debug = process.env["DSH_SERVE_DEBUG"] === "1" ? (message) => {
+		io.stderr.write(`dsh-serve: ${message}\n`);
+	} : () => {};
+	const shutdown = async () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		debug("shutdown requested");
+		for (const handle of managed.values()) await handle.dispose().catch(() => {});
+		debug("managed agents disposed; requesting exit");
+		io.exit(0);
+		const stdin = io.stdin;
+		stdin.removeAllListeners?.("data");
+		stdin.removeAllListeners?.("end");
+		stdin.unref?.();
+		setTimeout(() => {
+			debug("exit fallback fired");
+			process.exit(0);
+		}, 2e3).unref();
+	};
+	/** Accept one turn: followup now, outcome later as `session/idle`. */
+	const startTurn = (sessionId, text, turn, agent) => {
+		const run = (queues.get(sessionId) ?? Promise.resolve()).then(async () => {
+			activeTurns.set(sessionId, turn);
+			let reason;
+			try {
+				const firstSeq = agent.session.seq;
+				agent.followup(createUserMessage({
+					content: [{
+						type: "text",
+						text
+					}],
+					source: { kind: "user" }
+				}));
+				await agent.whenIdle();
+				await sessions.flush(agent.session);
+				reason = summarizeTurn(agent.session.snapshotEvents(), firstSeq).reason ?? null;
+			} catch (error) {
+				reason = {
+					kind: "error",
+					error: {
+						message: messageOf(error),
+						code: "UNKNOWN"
+					}
+				};
+			}
+			const params = {
+				sessionId,
+				turn,
+				reason
+			};
+			try {
+				notify("session/idle", params);
+			} finally {
+				activeTurns.delete(sessionId);
+			}
+		});
+		queues.set(sessionId, run);
+	};
+	const handleRequest = async (id, method, params) => {
+		switch (method) {
+			case "initialize":
+				respond(id, {
+					serverInfo: { name: LIVE_SERVER_NAME },
+					protocolVersion: 1
+				});
+				return;
+			case "session/prepare":
+				try {
+					await resolveSubDshSelection(ctx, model, effort, true);
+					respond(id, { prepared: true });
+				} catch (error) {
+					respondError(id, messageOf(error));
+				}
+				return;
+			case "turn/start": {
+				const sessionId = params["sessionId"];
+				const text = params["text"];
+				const turn = params["turn"];
+				const resume = params["resume"] === true;
+				if (typeof sessionId !== "string" || sessionId === "" || typeof text !== "string" || typeof turn !== "number" || !Number.isSafeInteger(turn) || turn < 1) {
+					respondError(id, "turn/start requires a sessionId, a text, and a positive integer turn");
+					return;
+				}
+				let handle = managed.get(sessionId);
+				if (handle === void 0) {
+					try {
+						handle = await loadSubDshAgent(ctx, {
+							...resume ? { resumeSessionId: sessionId } : { sessionId },
+							...model === void 0 ? {} : { model },
+							...effort === void 0 ? {} : { effort }
+						});
+					} catch (error) {
+						respondError(id, messageOf(error));
+						return;
+					}
+					managed.set(sessionId, handle);
+				}
+				startTurn(sessionId, text, turn, handle.agent);
+				respond(id, { accepted: true });
+				return;
+			}
+			case "turn/interrupt": {
+				const sessionId = params["sessionId"];
+				if (typeof sessionId !== "string") {
+					respondError(id, "turn/interrupt requires a sessionId");
+					return;
+				}
+				const handle = managed.get(sessionId);
+				handle?.agent.cancel({ kind: "parent" });
+				respond(id, { interrupted: handle !== void 0 });
+				return;
+			}
+			case "shutdown":
+				respond(id, {});
+				shutdown();
+				return;
+			default: respondError(id, `unknown method: ${method}`, LIVE_WIRE_ERROR_METHOD_NOT_FOUND);
+		}
+	};
+	io.stdin.on("data", (chunk) => {
+		if (shuttingDown) return;
+		const text = typeof chunk === "string" ? chunk : decoder.write(chunk);
+		buffer += text;
+		let index = buffer.indexOf("\n");
+		while (index >= 0) {
+			const line = buffer.slice(0, index);
+			buffer = buffer.slice(index + 1);
+			index = buffer.indexOf("\n");
+			if (line.trim() === "") continue;
+			let message;
+			try {
+				message = JSON.parse(line);
+			} catch {
+				io.stderr.write("dsh: serve ignored a malformed wire line\n");
+				continue;
+			}
+			if ((typeof message.id === "number" || typeof message.id === "string") && typeof message.method === "string") {
+				const id = Number(message.id);
+				handleRequest(id, message.method, message.params ?? {}).catch((error) => {
+					respondError(id, messageOf(error));
+				});
+			}
+		}
+	});
+	io.stdin.on("end", () => {
+		shutdown();
+	});
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* @khorsheed/dsh-local-agent-dsh-headless — sub-dsh direct Agent driver with
+* two modes. One-shot (default): create one Agent through the core registry
+* on a caller-supplied session id (or resume one), drive the task to
+* quiescence, flush its Session, print the final assistant text, and exit.
+* Serve (`--serve`): stay resident and drive turns over the family-internal
+* live-driver wire (see `./serve.ts` / `./wire.ts`). The session id comes
+* from the invocation (`--session-id` / `--resume`) or the wire, never from
+* stdout — the parent provider generates one uuid and both sides use it, so
+* stdout carries no parseable session marker.
+*
+* @module @khorsheed/dsh-local-agent-dsh-headless
+*/
+/** Stable Cordis plugin name. */
+const name = "local-agent-dsh-headless-runner";
+/** Core services required before the one-shot turn can start. */
+const inject = [
+	"agentDefaultModel",
+	"agents",
+	"sessions"
+];
+const Config = z.object({
+	task: z.string(),
+	sessionId: z.string(),
+	resumeSessionId: z.string(),
+	serve: z.boolean().default(false),
+	model: z.string(),
+	effort: z.string()
+});
+/** The process streams the runner writes to; tests substitute captures. */
+const internals = {
+	stdin: process.stdin,
+	stdout: process.stdout,
+	stderr: process.stderr
+};
+/** Report an unexpected direct-driver failure and request a failing exit. */
+function fail(io, error) {
+	io.stderr.write(`dsh: ${error instanceof Error ? error.message : String(error)}\n`);
+	io.exit(1);
+}
+/**
+* Run one task through a fresh or resumed Agent and request process exit.
+* @param ctx - plugin context carrying the Agent, default model, Session, and launcher IO services.
+* @param config - validated one-shot config (task plus the caller session id).
+* @param io - process-facing effects.
+*/
+async function run(ctx, config, io) {
+	await ctx.get("loader")?.await();
+	const sessions = ctx.get("sessions");
+	if (ctx.get("agents") === void 0 || ctx.get("agentDefaultModel") === void 0 || sessions === void 0) return;
+	const agent = (await loadSubDshAgent(ctx, {
+		...config.sessionId === void 0 ? {} : { sessionId: config.sessionId },
+		...config.resumeSessionId === void 0 ? {} : { resumeSessionId: config.resumeSessionId },
+		...config.model === void 0 ? {} : { model: config.model },
+		...config.effort === void 0 ? {} : { effort: config.effort }
+	})).agent;
+	await agent.whenIdle();
+	const firstSeq = agent.session.seq;
+	agent.followup(createUserMessage({
+		content: [{
+			type: "text",
+			text: config.task ?? ""
+		}],
+		source: { kind: "user" }
+	}));
+	await agent.whenIdle();
+	await sessions.flush(agent.session);
+	const outcome = summarizeTurn(agent.session.snapshotEvents(), firstSeq);
+	io.stdout.write(outcome.text + "\n");
+	if (outcome.reason?.kind === "error") io.stderr.write(`dsh: ${outcome.reason.error.code}: ${outcome.reason.error.message}\n`);
+	io.exit(outcome.reason?.kind === "completed" ? 0 : 1);
+}
+/**
+* Mount the direct driver: one-shot by default, the resident serve loop when
+* the invocation passed `--serve`.
+* @param ctx - plugin context carrying core services and the launcher-provided exit request.
+* @param config - validated task/serve config.
+*/
+function apply(ctx, config) {
+	const exit = ctx.get("appExit");
+	if (exit === void 0) throw new Error("local-agent-dsh-headless-runner: the launcher must provide ctx.appExit before the tree mounts");
+	const io = {
+		stdin: internals.stdin,
+		stdout: internals.stdout,
+		stderr: internals.stderr,
+		exit
+	};
+	if (config.serve === true) {
+		runServe(ctx, io, config.model, config.effort).catch((error) => {
+			fail(io, error);
+		});
+		return;
+	}
+	if (config.task === void 0 || config.task.trim() === "") throw new Error("local-agent-dsh-headless-runner: a task is required unless serve mode is on");
+	run(ctx, config, io).catch((error) => {
+		fail(io, error);
+	});
+}
+//#endregion
+export { Config, apply, inject, internals, name };

package/lib/invariant.js

@@ -0,0 +1,36 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@khorsheed/dsh-local-agent-dsh-headless`.
+* @module @khorsheed/dsh-local-agent-dsh-headless/invariant
+*/
+const PACKAGE_NAME = "@khorsheed/dsh-local-agent-dsh-headless";
+/** Cordis companion plugin name. */
+const name = "local-agent-dsh-headless-invariant";
+/** Service required before the companion can register. */
+const inject = ["invariants"];
+/**
+* Composition guard: this bundle is sub-profile-only. Its patch rows
+* (persona override, `hmr` off, `tools` mode, the `ptc-runtime` insert, the
+* member-bridge MCP row) collide with or leak into any Host/web composition —
+* 2026-08-23 P0: reconciled into the prod web profile as a direct dependency
+* (reconcilePlugins auto-mounts every `dsh.bundle`-declaring direct dep), the
+* `code-runtime` insert (today's `ptc-runtime` row) hit the web-app row's duplicate entry id and the
+* whole instance failed to boot. The loader's duplicate-id failure is loud
+* but cryptic, and only fires when the ids collide; this invariant is the
+* CLEAR failure for the non-colliding case (e.g. an upstream row rename would
+* otherwise leak the persona override into real user sessions). The web
+* layer's `webStartup` service is the marker: in-box bundles mount before
+* dependency-managed ones, so it is already provided when this companion
+* applies.
+*/
+const install = (ctx, fail) => {
+	if (ctx.get("webStartup") !== void 0) fail("mounted into a web composition — this bundle is sub-profile-only. Remove it from the profile’s direct dependencies: the parent local-agent-dsh bundle installs it transitively, and the sub-profile symlink resolves from that closure");
+};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/startup.js

@@ -0,0 +1,74 @@
+import { Command } from "commander";
+import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
+//#region lib/types/startup.js
+/**
+* The sub-dsh one-shot app's command-line provider: it parses the task
+* positional, the caller-supplied `--session-id` (fresh delegation) and
+* `--resume` (continuation) flags, and `--help`, then publishes
+* {@link LOCAL_AGENT_DSH_HEADLESS_STARTUP_SERVICE}. The runner is an ordinary
+* consumer whose lazy config waits for that service. The session id is
+* caller-supplied — the parent provider generates one uuid and passes the same
+* value to `agents.create`/`agents.resume` on the sub-dsh side, so stdout
+* never carries a parseable session marker.
+* @module @khorsheed/dsh-local-agent-dsh-headless/startup
+*/
+/** Stable Cordis plugin name. */
+const name = "local-agent-dsh-headless-startup";
+/** Services required before the invocation can be resolved. */
+const inject = ["cmdlineArgs"];
+/** Service provided by this plugin and injected by the one-shot runner. */
+const LOCAL_AGENT_DSH_HEADLESS_STARTUP_SERVICE = "localAgentDshHeadlessStartup";
+/**
+* This app's command: the session flags, the task positional, and help text.
+* @returns a fresh program, so one process can parse more than once (tests).
+*/
+function headlessCommand() {
+	return new Command().name("dsh --profile headless-local-agent-dsh").description("Answer one task in a caller-named session, print the final assistant message, and exit.").helpOption("-h, --help", "show this help").option("--session-id <id>", "create a fresh session with exactly this id").option("--resume <id>", "continue the existing session with this id").option("--serve", "stay resident and drive turns over the stdio wire (no task)").option("--model <provider/model>", "run this model instead of the instance default (a bare id keeps the provider)").option("--effort <value>", "native reasoning effort for this launch").argument("[task...]", "the task text; multiple words are joined by spaces").addHelpText("after", `
+Examples:
+  dsh --profile headless-local-agent-dsh --session-id 6ba7... "run the tests"   create one session and answer
+  dsh --profile headless-local-agent-dsh --resume 6ba7... "run the rest"       continue the same session
+  dsh --profile headless-local-agent-dsh --serve                              resident live-driver mode (stdio wire)
+  dsh --profile headless-local-agent-dsh --model deepseek-official/deepseek-v4-pro --session-id 6ba7... "run the tests"
+`);
+}
+/**
+* Parse and provide the one-shot invocation as an ordinary Cordis service.
+* The command's action publishes the invocation; a missing or whitespace-only
+* task, or both session flags together, is a usage error, so on rejection (and
+* on `--help`) nothing is provided.
+* @param ctx - plugin context carrying the command line.
+*/
+function apply(ctx) {
+	const program = headlessCommand();
+	program.action(() => {
+		const task = program.args.join(" ");
+		const options = program.opts();
+		const effort = options.effort?.trim();
+		if (effort === "") program.error("error: --effort needs a native reasoning value");
+		const model = options.model?.trim();
+		if (model !== void 0 && model === "") program.error("error: --model needs a model identifier, for example deepseek-official/deepseek-v4-pro");
+		if (options.serve === true) {
+			if (options.sessionId !== void 0 || options.resume !== void 0) program.error("error: --serve drives sessions over the wire; --session-id/--resume do not apply");
+			if (task.trim() !== "") program.error("error: --serve takes no task; turns arrive over the wire");
+			ctx.provide(LOCAL_AGENT_DSH_HEADLESS_STARTUP_SERVICE, {
+				task: "",
+				serve: true,
+				...model === void 0 ? {} : { model },
+				...effort === void 0 ? {} : { effort }
+			});
+			return;
+		}
+		if (task.trim() === "") program.error("error: a task is required, for example: dsh --profile headless-local-agent-dsh --session-id <id> \"run the tests\"");
+		if (options.sessionId !== void 0 && options.resume !== void 0) program.error("error: --session-id and --resume are mutually exclusive");
+		ctx.provide(LOCAL_AGENT_DSH_HEADLESS_STARTUP_SERVICE, {
+			task,
+			...options.sessionId !== void 0 ? { sessionId: options.sessionId } : {},
+			...options.resume !== void 0 ? { resumeSessionId: options.resume } : {},
+			...model === void 0 ? {} : { model },
+			...effort === void 0 ? {} : { effort }
+		});
+	});
+	parseCmdline(ctx, program);
+}
+//#endregion
+export { LOCAL_AGENT_DSH_HEADLESS_STARTUP_SERVICE, apply, inject, name };