feat(web): launch delamain peers + workflows from the sidebar

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,
         }),
       ),
     );

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) => {

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;

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>()(

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;

apps/server/src/server.test.ts

@@ -1983,11 +1983,11 @@
 
       // initialize → serverInfo
       const init = yield* postMcp({ jsonrpc: "2.0", id: 1, method: "initialize" });
       assert.equal((init.result?.serverInfo as { name: string }).name, "gits-visual-plan");
 
       // tools/list → the six visual-plan tools
       const list = yield* postMcp({ jsonrpc: "2.0", id: 2, method: "tools/list" });
       const toolNames = (list.result?.tools as Array<{ name: string }>).map((t) => t.name);
       assert.deepEqual([...toolNames].sort(), [
         "create-visual-plan",
         "export-visual-plan",
@@ -2004,7 +2004,7 @@
         method: "tools/call",
         params: { name: "get-plan-blocks", arguments: {} },
       });
       const text = (blocks.result?.content as Array<{ text: string }>)[0]?.text ?? "";
       assert.ok(text.includes("rich-text"), "catalog should list the rich-text block");
       assert.ok(text.includes("question-form"), "catalog should list the question-form block");
     }).pipe(Effect.provide(NodeHttpServer.layerTest)),
@@ -4732,6 +4732,49 @@
     }).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;

apps/server/src/ws.ts

@@ -304,7 +304,7 @@
 // there). NO snapshot frame — the client already has it; overlap between catch-up
 // and live is deduped by sequence on the client. Exported so the ordering + filter
 // seam is unit-testable without the full RPC layer.
 export function resumeThreadStream<E1, E2, R>(
   catchUpEvents: Stream.Stream<OrchestrationEvent, E1, R>,
   liveEvents: Stream.Stream<OrchestrationEvent, E2, R>,
   threadId: ThreadId,
@@ -2091,6 +2091,13 @@
             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",