From 63b1b4c8b867aae9ec8619eeaa76b739dfe6e2fe Mon Sep 17 00:00:00 2001
From: Joshua <joshuaduffill@gmail.com>
Date: Mon, 20 Jul 2026 19:05:09 +0100
Subject: [PATCH] feat(web): launch delamain peers + workflows from the sidebar

Add a Launch surface to DelamainSidebar (spawn peer / run workflow) plus a
new gits.delamain.workflow.run RPC. Spawn reuses client.delamain.spawnPeer;
Run workflow shells `run-workflow <script> --repo <r> [--name] [--args-json]
--detach` via a new runWorkflow adapter method that validates argsJson is
parseable JSON server-side before shelling. Args JSON also gets client-side
validation with an inline error gating submit; mutation errors surface inline.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iKX4FLtG8KhduZfXevgjx
---
 .../OrchestrationEngineHarness.integration.ts |   1 +
 .../gits/Layers/DelamainCliAdapter.test.ts    |  81 +++++
 .../src/gits/Layers/DelamainCliAdapter.ts     |  34 ++
 .../src/gits/Services/DelamainAdapter.ts      |   5 +
 .../Layers/ProviderCommandReactor.test.ts     |   1 +
 apps/server/src/server.test.ts                |  43 +++
 apps/server/src/ws.ts                         |   7 +
 apps/web/src/components/DelamainSidebar.tsx   | 331 +++++++++++++++++-
 .../service.threadSubscriptions.test.ts       |   1 +
 packages/client-runtime/src/wsRpcClient.ts    |   3 +
 packages/contracts/src/gits.test.ts           |  45 +++
 packages/contracts/src/gits.ts                |  20 ++
 packages/contracts/src/rpc.ts                 |  10 +
 13 files changed, 573 insertions(+), 9 deletions(-)

diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts
index 8837d1d37d1..2abf34cde21 100644
--- a/apps/server/integration/OrchestrationEngineHarness.integration.ts
+++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts
@@ -358,6 +358,7 @@ export const makeOrchestrationIntegrationHarness = (
           workflowStatus: () =>
             Effect.die("delamain not available in integration harness") as never,
           workflowKill: () => Effect.die("delamain not available in integration harness") as never,
+          runWorkflow: () => Effect.die("delamain not available in integration harness") as never,
         }),
       ),
     );
diff --git a/apps/server/src/gits/Layers/DelamainCliAdapter.test.ts b/apps/server/src/gits/Layers/DelamainCliAdapter.test.ts
index 1dd7e64a7eb..7bd65f9624d 100644
--- a/apps/server/src/gits/Layers/DelamainCliAdapter.test.ts
+++ b/apps/server/src/gits/Layers/DelamainCliAdapter.test.ts
@@ -186,6 +186,87 @@ describe("DelamainCliAdapter", () => {
     }).pipe(Effect.provide(TestLayer)),
   );
 
+  it.effect(
+    "shells the pinned operator `run-workflow --detach` argv with argsJson passthrough",
+    () =>
+      Effect.gen(function* () {
+        runMock.mockImplementationOnce((input) => {
+          expect(input.command).toBe("delamain");
+          expect(input.args).toEqual([
+            "run-workflow",
+            "/srv/delamain/workflows/automode-goal.ts",
+            "--repo",
+            "/tmp/repo",
+            "--name",
+            "Nightly sweep",
+            "--args-json",
+            '{"title":"Ship it"}',
+            "--detach",
+          ]);
+          return Effect.succeed({
+            stdout: JSON.stringify({ workflow_id: "wf-launch", status: "running", workflow: {} }),
+            stderr: "",
+            code: ChildProcessSpawner.ExitCode(0),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+          });
+        });
+        const adapter = yield* DelamainAdapter;
+        const result = yield* adapter.runWorkflow({
+          script: "/srv/delamain/workflows/automode-goal.ts",
+          repo: "/tmp/repo",
+          name: "Nightly sweep",
+          argsJson: '{"title":"Ship it"}',
+        });
+        expect(result.workflowId).toBe("wf-launch");
+        expect(result.status).toBe("running");
+      }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("omits --name/--args-json when the operator leaves them unset", () =>
+    Effect.gen(function* () {
+      runMock.mockImplementationOnce((input) => {
+        expect(input.args).toEqual([
+          "run-workflow",
+          "/srv/delamain/workflows/automode-goal.ts",
+          "--repo",
+          "/tmp/repo",
+          "--detach",
+        ]);
+        return Effect.succeed({
+          stdout: JSON.stringify({ workflow_id: "wf-bare", status: "queued" }),
+          stderr: "",
+          code: ChildProcessSpawner.ExitCode(0),
+          timedOut: false,
+          stdoutTruncated: false,
+          stderrTruncated: false,
+        });
+      });
+      const adapter = yield* DelamainAdapter;
+      const result = yield* adapter.runWorkflow({
+        script: "/srv/delamain/workflows/automode-goal.ts",
+        repo: "/tmp/repo",
+      });
+      expect(result.workflowId).toBe("wf-bare");
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect("rejects unparseable argsJson before shelling the CLI", () =>
+    Effect.gen(function* () {
+      const adapter = yield* DelamainAdapter;
+      const error = yield* adapter
+        .runWorkflow({
+          script: "/srv/delamain/workflows/automode-goal.ts",
+          repo: "/tmp/repo",
+          argsJson: "{not json",
+        })
+        .pipe(Effect.flip);
+      expect(error.message).toBe("run-workflow argsJson is not valid JSON.");
+      expect(runMock).not.toHaveBeenCalled();
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
   it.effect("reads leaf ids from the nested workflow.agentPeerIds alias", () =>
     Effect.gen(function* () {
       runMock.mockImplementationOnce((input) => {
diff --git a/apps/server/src/gits/Layers/DelamainCliAdapter.ts b/apps/server/src/gits/Layers/DelamainCliAdapter.ts
index 82d1831cc9b..600694e5ab3 100644
--- a/apps/server/src/gits/Layers/DelamainCliAdapter.ts
+++ b/apps/server/src/gits/Layers/DelamainCliAdapter.ts
@@ -22,6 +22,7 @@ import {
   type DelamainSendMessageResult,
   type DelamainWorkflowStatus,
   type DelamainWorkflowKillResult,
+  type DelamainWorkflowRunResult,
   type PeerStatus,
 } from "@t3tools/contracts";
 
@@ -402,6 +403,17 @@ function runWorkflowArgs(input: Parameters<DelamainAdapterShape["runGoalWorkflow
   ];
 }
 
+// Operator launch (`gits.delamain.workflow.run`): name/argsJson are optional so a bare
+// `run-workflow <script> --repo <repo> --detach` is valid. --detach stays last (mirrors
+// runWorkflowArgs) so the CLI prints the detach JSON envelope.
+function workflowRunArgs(input: Parameters<DelamainAdapterShape["runWorkflow"]>[0]): string[] {
+  const args = ["run-workflow", input.script, "--repo", input.repo];
+  if (input.name) args.push("--name", input.name);
+  if (input.argsJson) args.push("--args-json", input.argsJson);
+  args.push("--detach");
+  return args;
+}
+
 function normalizeWorkflowKill(workflowId: string, value: unknown): DelamainWorkflowKillResult {
   const record = rawRecord(value);
   return {
@@ -571,6 +583,28 @@ export const makeDelamainCliAdapter = Effect.gen(function* () {
       runJson<unknown>(processRunner, "workflow.kill", ["workflow", "kill", input.workflowId]).pipe(
         Effect.map((value) => normalizeWorkflowKill(input.workflowId, value)),
       ),
+    runWorkflow: (input) =>
+      Effect.gen(function* () {
+        // Reject garbage before shelling — never pass an unparseable blob to the CLI.
+        if (input.argsJson != null) {
+          yield* Effect.try({
+            // @effect-diagnostics-next-line preferSchemaOverJson:off
+            try: () => JSON.parse(input.argsJson as string) as unknown,
+            catch: (cause) => toDelamainError("run-workflow argsJson is not valid JSON.", cause),
+          });
+        }
+        const value = yield* runJson<unknown>(
+          processRunner,
+          "run-workflow",
+          workflowRunArgs(input),
+        );
+        const record = rawRecord(value);
+        const workflowId = nullableString(record.workflow_id ?? record.workflowId);
+        if (workflowId === null) {
+          return yield* toDelamainError("Delamain run-workflow did not return a workflow_id.");
+        }
+        return { workflowId, status: rawStatus(record.status) } satisfies DelamainWorkflowRunResult;
+      }),
   };
 
   return adapter;
diff --git a/apps/server/src/gits/Services/DelamainAdapter.ts b/apps/server/src/gits/Services/DelamainAdapter.ts
index 990a68bc321..06ee44adc78 100644
--- a/apps/server/src/gits/Services/DelamainAdapter.ts
+++ b/apps/server/src/gits/Services/DelamainAdapter.ts
@@ -25,6 +25,8 @@ import type {
   DelamainWorkflowStatus,
   DelamainWorkflowKillInput,
   DelamainWorkflowKillResult,
+  DelamainWorkflowRunInput,
+  DelamainWorkflowRunResult,
 } from "@t3tools/contracts";
 
 export interface DelamainAdapterShape {
@@ -68,6 +70,9 @@ export interface DelamainAdapterShape {
   readonly workflowKill: (
     input: DelamainWorkflowKillInput,
   ) => Effect.Effect<DelamainWorkflowKillResult, DelamainAdapterError>;
+  readonly runWorkflow: (
+    input: DelamainWorkflowRunInput,
+  ) => Effect.Effect<DelamainWorkflowRunResult, DelamainAdapterError>;
 }
 
 export class DelamainAdapter extends Context.Service<DelamainAdapter, DelamainAdapterShape>()(
diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
index 2bb260f27fe..2435499f18a 100644
--- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
+++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts
@@ -335,6 +335,7 @@ describe("ProviderCommandReactor", () => {
       sendMessage: delamainDie,
       workflowStatus: delamainDie,
       workflowKill: delamainDie,
+      runWorkflow: delamainDie,
     };
 
     const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index 14fa7456dbb..3a391855499 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -4732,6 +4732,49 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
     }).pipe(Effect.provide(NodeHttpServer.layerTest)),
   );
 
+  it.effect("routes the Delamain run-workflow launch rpc through to the adapter", () =>
+    Effect.gen(function* () {
+      let launched: { script: string; repo: string; name: string | null | undefined } | null = null;
+      yield* buildAppUnderTest({
+        layers: {
+          delamainAdapter: {
+            runWorkflow: (input) =>
+              Effect.sync(() => {
+                launched = { script: input.script, repo: input.repo, name: input.name };
+                return { workflowId: "wf-launch", status: "running" };
+              }),
+          },
+          automodeSupervisor: {
+            getSnapshot: () =>
+              Effect.succeed({
+                ...defaultAutomodeSnapshot,
+                policy: { ...defaultAutomodeSnapshot.policy, killSwitchEnabled: false },
+              }),
+          },
+        },
+      });
+
+      const wsUrl = yield* getWsServerUrl("/ws");
+      const result = yield* Effect.scoped(
+        withWsRpcClient(wsUrl, (client) =>
+          client[WS_METHODS.gitsDelamainRunWorkflow]({
+            script: "/srv/delamain/workflows/automode-goal.ts",
+            repo: "/tmp/source-repo",
+            name: "Nightly sweep",
+          }),
+        ),
+      );
+
+      assert.equal(result.workflowId, "wf-launch");
+      assert.equal(result.status, "running");
+      assert.deepEqual(launched, {
+        script: "/srv/delamain/workflows/automode-goal.ts",
+        repo: "/tmp/source-repo",
+        name: "Nightly sweep",
+      });
+    }).pipe(Effect.provide(NodeHttpServer.layerTest)),
+  );
+
   it.effect("blocks manual Delamain peer actions when the kill switch is enabled", () =>
     Effect.gen(function* () {
       let spawnCalled = false;
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 0b017570058..c7e383ac07b 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -2091,6 +2091,13 @@ const makeWsRpcLayer = (
             withKillSwitchGuard(delamainAdapter.workflowKill(input)),
             { "rpc.aggregate": "gits" },
           ),
+        // Operator launch — kill-switch guarded like spawn (it dispatches peers).
+        [WS_METHODS.gitsDelamainRunWorkflow]: (input) =>
+          observeRpcEffect(
+            WS_METHODS.gitsDelamainRunWorkflow,
+            withKillSwitchGuard(delamainAdapter.runWorkflow(input)),
+            { "rpc.aggregate": "gits" },
+          ),
         [WS_METHODS.gitsDelamainReadInbox]: (input) =>
           observeRpcEffect(WS_METHODS.gitsDelamainReadInbox, delamainAdapter.readInbox(input), {
             "rpc.aggregate": "gits",
diff --git a/apps/web/src/components/DelamainSidebar.tsx b/apps/web/src/components/DelamainSidebar.tsx
index 63c7f7c1e5f..8137c423187 100644
--- a/apps/web/src/components/DelamainSidebar.tsx
+++ b/apps/web/src/components/DelamainSidebar.tsx
@@ -14,6 +14,15 @@ import {
   AlertDialogTitle,
 } from "./ui/alert-dialog";
 import { Menu, MenuItem, MenuPopup, MenuTrigger } from "./ui/menu";
+import {
+  Dialog,
+  DialogFooter,
+  DialogHeader,
+  DialogPanel,
+  DialogPopup,
+  DialogTitle,
+} from "./ui/dialog";
+import { Textarea } from "./ui/textarea";
 import {
   BotIcon,
   ChevronDownIcon,
@@ -24,7 +33,9 @@ import {
   GitMergeIcon,
   MoreHorizontalIcon,
   PanelRightCloseIcon,
+  PlusIcon,
   ScrollTextIcon,
+  WorkflowIcon,
   XCircleIcon,
 } from "lucide-react";
 import { cn } from "~/lib/utils";
@@ -371,6 +382,284 @@ function IntegrateDialog({
   );
 }
 
+// --- Launch dialog (spawn peer / run workflow) ---
+
+// ponytail: plain default path. A workflow-script registry (list + pick) is the upgrade
+// path when there is more than one script worth launching from the UI.
+const DEFAULT_WORKFLOW_SCRIPT = "/srv/gits/repos/delamain/workflows/automode-goal.ts";
+// spawnPeer's contract engine values are codex/cursor/unknown — only the two real engines
+// are operator-selectable here. ("pi" is not in the contract's DelamainEngine literals.)
+const SPAWN_ENGINES = ["codex", "cursor"] as const;
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error.";
+}
+
+function LaunchDialog({
+  open,
+  onOpenChange,
+  environmentId,
+  repo,
+}: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  environmentId: EnvironmentId;
+  repo: string;
+}) {
+  const queryClient = useQueryClient();
+  const [mode, set_mode] = useState<"spawn" | "workflow">("spawn");
+
+  // Spawn-peer form.
+  const [prompt, set_prompt] = useState("");
+  const [spawn_name, set_spawn_name] = useState("");
+  const [engine, set_engine] = useState<(typeof SPAWN_ENGINES)[number]>("codex");
+
+  // Run-workflow form.
+  const [script, set_script] = useState(DEFAULT_WORKFLOW_SCRIPT);
+  const [wf_name, set_wf_name] = useState("");
+  const [args_json, set_args_json] = useState("");
+
+  // Client-side JSON validation — inline error, blocks submit before we ever shell the CLI.
+  const args_json_error = useMemo(() => {
+    const trimmed = args_json.trim();
+    if (!trimmed) return null;
+    try {
+      JSON.parse(trimmed);
+      return null;
+    } catch (err) {
+      return errorMessage(err);
+    }
+  }, [args_json]);
+
+  const spawn_mutation = useMutation({
+    mutationFn: async () => {
+      const client = readGitsEnvironmentClient(environmentId);
+      if (!client) throw new Error("No environment client");
+      return client.delamain.spawnPeer({
+        repo,
+        prompt: prompt.trim(),
+        engine,
+        ...(spawn_name.trim() ? { name: spawn_name.trim() } : {}),
+      });
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({
+        queryKey: ["gits", "delamain", "peers", environmentId],
+      });
+    },
+  });
+
+  const workflow_mutation = useMutation({
+    mutationFn: async () => {
+      const client = readGitsEnvironmentClient(environmentId);
+      if (!client) throw new Error("No environment client");
+      const trimmedArgs = args_json.trim();
+      return client.delamain.workflow.run({
+        script: script.trim(),
+        repo,
+        ...(wf_name.trim() ? { name: wf_name.trim() } : {}),
+        ...(trimmedArgs ? { argsJson: trimmedArgs } : {}),
+      });
+    },
+  });
+
+  const pending = spawn_mutation.isPending || workflow_mutation.isPending;
+
+  const reset_and_close = useCallback(
+    (next: boolean) => {
+      if (!next && !pending) {
+        spawn_mutation.reset();
+        workflow_mutation.reset();
+        onOpenChange(false);
+      } else if (next) {
+        onOpenChange(true);
+      }
+    },
+    [pending, spawn_mutation, workflow_mutation, onOpenChange],
+  );
+
+  const can_spawn = prompt.trim().length > 0 && !pending;
+  const can_run = script.trim().length > 0 && args_json_error === null && !pending;
+
+  return (
+    <Dialog open={open} onOpenChange={reset_and_close}>
+      <DialogPopup className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>Launch</DialogTitle>
+        </DialogHeader>
+        <DialogPanel className="space-y-3">
+          {/* mode selector */}
+          <div className="flex gap-1.5">
+            <Button
+              size="sm"
+              variant={mode === "spawn" ? "default" : "outline"}
+              onClick={() => set_mode("spawn")}
+              type="button"
+            >
+              <BotIcon className="size-3.5" />
+              Spawn peer
+            </Button>
+            <Button
+              size="sm"
+              variant={mode === "workflow" ? "default" : "outline"}
+              onClick={() => set_mode("workflow")}
+              type="button"
+            >
+              <WorkflowIcon className="size-3.5" />
+              Run workflow
+            </Button>
+          </div>
+
+          {/* repo (read-only, prefilled from the active project) */}
+          <div className="grid gap-1">
+            <label className="text-[11px] font-medium text-muted-foreground/70">Repo</label>
+            <div className="truncate rounded-md border border-border/50 bg-muted/40 px-2 py-1.5 font-mono text-[11px] text-muted-foreground/70">
+              {repo}
+            </div>
+          </div>
+
+          {mode === "spawn" ? (
+            <>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">Prompt</label>
+                <Textarea
+                  value={prompt}
+                  onChange={(e) => set_prompt(e.currentTarget.value)}
+                  placeholder="What should the peer do?"
+                  className="min-h-20 text-xs"
+                  disabled={pending}
+                />
+              </div>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">
+                  Name (optional)
+                </label>
+                <Input
+                  value={spawn_name}
+                  onValueChange={set_spawn_name}
+                  placeholder="Peer name"
+                  size="sm"
+                  disabled={pending}
+                  className="text-[11px]"
+                />
+              </div>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">Engine</label>
+                <div className="flex gap-1.5">
+                  {SPAWN_ENGINES.map((eng) => (
+                    <Button
+                      key={eng}
+                      size="sm"
+                      variant={engine === eng ? "default" : "outline"}
+                      onClick={() => set_engine(eng)}
+                      type="button"
+                      disabled={pending}
+                    >
+                      {eng}
+                    </Button>
+                  ))}
+                </div>
+              </div>
+              {spawn_mutation.isError ? (
+                <p className="text-[11px] text-destructive/70">
+                  {errorMessage(spawn_mutation.error)}
+                </p>
+              ) : null}
+              {spawn_mutation.isSuccess ? (
+                <p className="text-[11px] text-emerald-500">
+                  Spawned peer <span className="font-mono">{spawn_mutation.data.id}</span>.
+                </p>
+              ) : null}
+            </>
+          ) : (
+            <>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">
+                  Workflow script
+                </label>
+                <Input
+                  value={script}
+                  onValueChange={set_script}
+                  placeholder="/path/to/workflow.ts"
+                  size="sm"
+                  disabled={pending}
+                  className="font-mono text-[11px]"
+                />
+              </div>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">
+                  Name (optional)
+                </label>
+                <Input
+                  value={wf_name}
+                  onValueChange={set_wf_name}
+                  placeholder="Run name"
+                  size="sm"
+                  disabled={pending}
+                  className="text-[11px]"
+                />
+              </div>
+              <div className="grid gap-1">
+                <label className="text-[11px] font-medium text-muted-foreground/70">
+                  Args JSON (optional)
+                </label>
+                <Textarea
+                  value={args_json}
+                  onChange={(e) => set_args_json(e.currentTarget.value)}
+                  placeholder='{"title":"…","prompt":"…"}'
+                  className="min-h-16 font-mono text-[11px]"
+                  aria-invalid={args_json_error !== null}
+                  disabled={pending}
+                />
+                {args_json_error ? (
+                  <p className="text-[11px] text-destructive/70">Invalid JSON: {args_json_error}</p>
+                ) : null}
+              </div>
+              {workflow_mutation.isError ? (
+                <p className="text-[11px] text-destructive/70">
+                  {errorMessage(workflow_mutation.error)}
+                </p>
+              ) : null}
+              {workflow_mutation.isSuccess ? (
+                <div className="space-y-0.5">
+                  <p className="text-[11px] text-emerald-500">
+                    Started workflow{" "}
+                    <span className="font-mono">{workflow_mutation.data.workflowId}</span>.
+                  </p>
+                  <p className="text-[10px] text-muted-foreground/50">
+                    It will appear as a mirrored thread shortly.
+                  </p>
+                </div>
+              ) : null}
+            </>
+          )}
+        </DialogPanel>
+        <DialogFooter>
+          {mode === "spawn" ? (
+            <Button
+              onClick={() => spawn_mutation.mutate()}
+              disabled={!can_spawn}
+              type="button"
+              size="sm"
+            >
+              {spawn_mutation.isPending ? "Spawning…" : "Spawn peer"}
+            </Button>
+          ) : (
+            <Button
+              onClick={() => workflow_mutation.mutate()}
+              disabled={!can_run}
+              type="button"
+              size="sm"
+            >
+              {workflow_mutation.isPending ? "Starting…" : "Run workflow"}
+            </Button>
+          )}
+        </DialogFooter>
+      </DialogPopup>
+    </Dialog>
+  );
+}
+
 // --- Active statuses ---
 
 // frozen is terminal server-side (DelamainCliAdapter) — no Kill button on frozen peers.
@@ -572,6 +861,7 @@ const DelamainSidebar = memo(function DelamainSidebar({
   const [kill_state, set_kill_state] = useState<{ peer: DelamainPeer } | null>(null);
   const [integrate_state, set_integrate_state] = useState<{ peer: DelamainPeer } | null>(null);
   const [show_all, set_show_all] = useState(false);
+  const [launch_open, set_launch_open] = useState(false);
 
   const peers_query_key = ["gits", "delamain", "peers", environmentId];
 
@@ -651,15 +941,29 @@ const DelamainSidebar = memo(function DelamainSidebar({
             {delamain_peers.length} peer{delamain_peers.length === 1 ? "" : "s"}
           </span>
         </div>
-        <Button
-          size="icon-xs"
-          variant="ghost"
-          onClick={onClose}
-          aria-label="Close delamain sidebar"
-          className="text-muted-foreground/50 hover:text-foreground/70"
-        >
-          <PanelRightCloseIcon className="size-3.5" />
-        </Button>
+        <div className="flex items-center gap-1">
+          {projectRepoRoot ? (
+            <Button
+              size="icon-xs"
+              variant="ghost"
+              onClick={() => set_launch_open(true)}
+              aria-label="Launch delamain peer or workflow"
+              title="Launch peer or workflow"
+              className="text-muted-foreground/50 hover:text-foreground/70"
+            >
+              <PlusIcon className="size-3.5" />
+            </Button>
+          ) : null}
+          <Button
+            size="icon-xs"
+            variant="ghost"
+            onClick={onClose}
+            aria-label="Close delamain sidebar"
+            className="text-muted-foreground/50 hover:text-foreground/70"
+          >
+            <PanelRightCloseIcon className="size-3.5" />
+          </Button>
+        </div>
       </div>
 
       <ScrollArea className="min-h-0 flex-1">
@@ -713,6 +1017,15 @@ const DelamainSidebar = memo(function DelamainSidebar({
         onIntegrate={(peerId) => integrate_mutation.mutate(peerId)}
         isPending={integrate_mutation.isPending}
       />
+
+      {projectRepoRoot ? (
+        <LaunchDialog
+          open={launch_open}
+          onOpenChange={set_launch_open}
+          environmentId={environmentId}
+          repo={projectRepoRoot}
+        />
+      ) : null}
     </div>
   );
 });
diff --git a/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts b/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
index 59378ac2c35..14d4e099c43 100644
--- a/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
+++ b/apps/web/src/environments/runtime/service.threadSubscriptions.test.ts
@@ -194,6 +194,7 @@ vi.mock("@t3tools/client-runtime", async (importOriginal) => {
         workflow: {
           status: vi.fn(),
           kill: vi.fn(),
+          run: vi.fn(),
         },
         messages: {
           inbox: vi.fn(),
diff --git a/packages/client-runtime/src/wsRpcClient.ts b/packages/client-runtime/src/wsRpcClient.ts
index 6bc574d6b84..ac10a276081 100644
--- a/packages/client-runtime/src/wsRpcClient.ts
+++ b/packages/client-runtime/src/wsRpcClient.ts
@@ -213,6 +213,7 @@ export interface WsRpcClient {
       readonly workflow: {
         readonly status: RpcUnaryMethod<typeof WS_METHODS.gitsDelamainWorkflowStatus>;
         readonly kill: RpcUnaryMethod<typeof WS_METHODS.gitsDelamainWorkflowKill>;
+        readonly run: RpcUnaryMethod<typeof WS_METHODS.gitsDelamainRunWorkflow>;
       };
       readonly messages: {
         readonly inbox: RpcUnaryMethod<typeof WS_METHODS.gitsDelamainReadInbox>;
@@ -500,6 +501,8 @@ export function createWsRpcClient(
             transport.request((client) => client[WS_METHODS.gitsDelamainWorkflowStatus](input)),
           kill: (input) =>
             transport.request((client) => client[WS_METHODS.gitsDelamainWorkflowKill](input)),
+          run: (input) =>
+            transport.request((client) => client[WS_METHODS.gitsDelamainRunWorkflow](input)),
         },
         messages: {
           inbox: (input) =>
diff --git a/packages/contracts/src/gits.test.ts b/packages/contracts/src/gits.test.ts
index 2d3db9d44f3..fcda8ac58c7 100644
--- a/packages/contracts/src/gits.test.ts
+++ b/packages/contracts/src/gits.test.ts
@@ -3,6 +3,8 @@ import { describe, expect, it } from "vitest";
 
 import {
   AutomodeGoal,
+  DelamainWorkflowRunInput,
+  DelamainWorkflowRunResult,
   GitsBuildInfo,
   GitsCapacitySnapshot,
   GitsMcpInventorySnapshot,
@@ -319,6 +321,49 @@ describe("AutomodeGoal", () => {
   });
 });
 
+describe("Delamain workflow launch contracts", () => {
+  const decodeInput = Schema.decodeUnknownSync(DelamainWorkflowRunInput);
+  const encodeInput = Schema.encodeSync(DelamainWorkflowRunInput);
+  const decodeResult = Schema.decodeUnknownSync(DelamainWorkflowRunResult);
+
+  it("round-trips a full launch input (script/repo/name/argsJson)", () => {
+    const input = {
+      script: "/srv/delamain/workflows/automode-goal.ts",
+      repo: "/home/test/project",
+      name: "Nightly sweep",
+      argsJson: '{"title":"Ship it"}',
+    };
+    expect(encodeInput(decodeInput(input))).toEqual(input);
+  });
+
+  it("accepts a bare input with name/argsJson omitted", () => {
+    const parsed = decodeInput({
+      script: "/srv/delamain/workflows/automode-goal.ts",
+      repo: "/home/test/project",
+    });
+    expect(parsed.name).toBeUndefined();
+    expect(parsed.argsJson).toBeUndefined();
+  });
+
+  it("accepts explicit null for name/argsJson", () => {
+    const parsed = decodeInput({
+      script: "/srv/delamain/workflows/automode-goal.ts",
+      repo: "/home/test/project",
+      name: null,
+      argsJson: null,
+    });
+    expect(parsed.name).toBeNull();
+    expect(parsed.argsJson).toBeNull();
+  });
+
+  it("decodes the launch result with an arbitrary status string", () => {
+    expect(decodeResult({ workflowId: "wf-launch", status: "running" })).toEqual({
+      workflowId: "wf-launch",
+      status: "running",
+    });
+  });
+});
+
 describe("Hermes Motoko contracts", () => {
   const baseProposal = {
     id: "proposal-1",
diff --git a/packages/contracts/src/gits.ts b/packages/contracts/src/gits.ts
index 6b925a690c5..8b64e18993b 100644
--- a/packages/contracts/src/gits.ts
+++ b/packages/contracts/src/gits.ts
@@ -657,6 +657,26 @@ export const DelamainRunWorkflowResult = Schema.Struct({
 });
 export type DelamainRunWorkflowResult = typeof DelamainRunWorkflowResult.Type;
 
+// Operator-initiated workflow launch from the GITS UI (`gits.delamain.workflow.run`):
+// shells `run-workflow <script> --repo <repo> [--name ..] [--args-json ..] --detach`.
+// name/argsJson are optional so a bare `run-workflow <script> --repo <repo> --detach`
+// stays valid; the adapter validates argsJson is parseable JSON before shelling.
+export const DelamainWorkflowRunInput = Schema.Struct({
+  script: PathString,
+  repo: PathString,
+  name: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
+  argsJson: Schema.optional(Schema.NullOr(SummaryString)),
+});
+export type DelamainWorkflowRunInput = typeof DelamainWorkflowRunInput.Type;
+
+// `run-workflow --detach` prints {workflow_id, status, workflow}; status stays a plain
+// string so unknown CLI states never fail decode.
+export const DelamainWorkflowRunResult = Schema.Struct({
+  workflowId: TrimmedNonEmptyString,
+  status: Schema.String,
+});
+export type DelamainWorkflowRunResult = typeof DelamainWorkflowRunResult.Type;
+
 export const DelamainSpawnPeerInput = Schema.Struct({
   repo: PathString,
   prompt: SummaryString,
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index 4554e868112..fd29091e063 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -47,6 +47,8 @@ import {
   DelamainWorkflowStatus,
   DelamainWorkflowKillInput,
   DelamainWorkflowKillResult,
+  DelamainWorkflowRunInput,
+  DelamainWorkflowRunResult,
   GitsCapacityError,
   GitsCapacitySnapshot,
   GitsCapacitySnapshotInput,
@@ -299,6 +301,7 @@ export const WS_METHODS = {
   gitsDelamainIntegratePeer: "gits.delamain.peers.integrate",
   gitsDelamainWorkflowStatus: "gits.delamain.workflow.status",
   gitsDelamainWorkflowKill: "gits.delamain.workflow.kill",
+  gitsDelamainRunWorkflow: "gits.delamain.workflow.run",
   gitsDelamainReadInbox: "gits.delamain.messages.inbox",
   gitsDelamainSendMessage: "gits.delamain.messages.send",
   gitsOpenGsdGetStatus: "gits.openGsd.status",
@@ -870,6 +873,12 @@ export const WsGitsDelamainWorkflowKillRpc = Rpc.make(WS_METHODS.gitsDelamainWor
   error: DelamainAdapterError,
 });
 
+export const WsGitsDelamainRunWorkflowRpc = Rpc.make(WS_METHODS.gitsDelamainRunWorkflow, {
+  payload: DelamainWorkflowRunInput,
+  success: DelamainWorkflowRunResult,
+  error: DelamainAdapterError,
+});
+
 export const WsGitsDelamainReadInboxRpc = Rpc.make(WS_METHODS.gitsDelamainReadInbox, {
   payload: DelamainReadInboxInput,
   success: DelamainInboxResult,
@@ -1268,6 +1277,7 @@ export const WsRpcGroup = RpcGroup.make(
   WsGitsDelamainIntegratePeerRpc,
   WsGitsDelamainWorkflowStatusRpc,
   WsGitsDelamainWorkflowKillRpc,
+  WsGitsDelamainRunWorkflowRpc,
   WsGitsDelamainReadInboxRpc,
   WsGitsDelamainSendMessageRpc,
   WsGitsOpenGsdGetStatusRpc,