@monster-orange/den 0.2.0 → 0.2.1

package/src/ui/mcp/tools.ts

@@ -85,15 +85,61 @@ function tail(r: StreamResult, n: number): string[] {
 }
 
 /** One line per stream: how it ended and its exit code. */
+/**
+ * Whether a streamed action failed: a non-zero exit, a detached service whose
+ * launcher exited non-zero, or a run that never finished (timeout).
+ */
+export function streamFailed(r: StreamResult): boolean {
+  if (r.ended === "timeout") return true;
+  if (r.exitCode !== undefined && r.exitCode !== 0) return true;
+  return r.events.some(
+    (e) =>
+      e.type === "service-exited" &&
+      typeof e.exitCode === "number" &&
+      e.exitCode !== 0,
+  );
+}
+
+/** An action that ran and failed: its output goes back with isError set. */
+export class ActionFailed extends Error {
+  constructor(readonly out: Record<string, unknown>) {
+    super("action failed");
+    this.name = "ActionFailed";
+  }
+}
+
+/**
+ * How the call ended, in words an agent reads about the service: a stream
+ * stopped at `ready` is "ready", at a launcher's exit "handed-off".
+ */
+function endedLabel(r: StreamResult): string {
+  if (r.ended !== "stopped") return r.ended;
+  const last = r.events.at(-1)?.type;
+  if (last === "ready") return "ready";
+  if (last === "service-exited") return "handed-off";
+  return r.ended;
+}
+
 function streamSummary(r: StreamResult, keep: number) {
   return {
-    ended: r.ended,
+    ended: endedLabel(r),
     ...(r.exitCode !== undefined ? { exitCode: r.exitCode } : {}),
     lines: r.lines.length,
     output: tail(r, keep),
   };
 }
 
+/** The action's result; thrown as ActionFailed when the stream failed. */
+function actionResult(
+  r: StreamResult,
+  keep: number,
+  head: Record<string, unknown> = {},
+): Record<string, unknown> {
+  const out = { ...head, ...streamSummary(r, keep) };
+  if (streamFailed(r)) throw new ActionFailed({ failed: true, ...out });
+  return out;
+}
+
 // ── Read tools ──────────────────────────────────────────────────────────────
 
 const read = (
@@ -354,7 +400,7 @@ function lifecycleTool(cmd: LifecycleCmd): DenTool {
         str(a.service),
         workspace,
       );
-      assertRunsLocally(entry);
+      assertRunsLocally(entry, cmd);
       const r = await api.stream(
         "/api/service/exec",
         {
@@ -368,16 +414,20 @@ function lifecycleTool(cmd: LifecycleCmd): DenTool {
           method: "GET",
           maxLines: 2000,
           timeoutMs: 180_000,
-          // A detached `up` keeps streaming the service's log; its launch
-          // script exiting is the hand-off.
-          stopOn: (e) => e.type === "service-exited",
+          // A detached start keeps streaming the service's log. It is done
+          // when the server says it is ready (health green, or still running
+          // with no check), or when its launch script exits (the hand-off).
+          stopOn: (e) => e.type === "ready" || e.type === "service-exited",
         },
       );
-      return {
+      const ready = r.events.find((e) => e.type === "ready");
+      return actionResult(r, 200, {
         service: `${entry.repo}/${entry.service}`,
         cmd,
-        ...streamSummary(r, 200),
-      };
+        ...(ready
+          ? { ready: true, healthChecked: ready.checked === true }
+          : {}),
+      });
     },
   };
 }
@@ -408,7 +458,7 @@ const ACTION_TOOLS: Record<McpAction, DenTool> = {
         maxLines: 5000,
         timeoutMs: 15 * 60_000,
       });
-      return streamSummary(r, 300);
+      return actionResult(r, 300);
     },
   },
   run_tests: {
@@ -453,7 +503,7 @@ const ACTION_TOOLS: Record<McpAction, DenTool> = {
         },
         { method: "GET", maxLines: 20_000, timeoutMs: 60 * 60_000 },
       );
-      return { pillar, env, ...streamSummary(r, 300) };
+      return actionResult(r, 300, { pillar, env });
     },
   },
 };
@@ -532,6 +582,28 @@ async function notFoundMessage(
  * that refused, how to start the web server, or (when it runs an older Den
  * than the tool needs) how to restart it.
  */
+/**
+ * Tell the web server a guard refused an action, so the activity trail shows
+ * the attempt (F2). Best effort: a report that fails changes nothing.
+ */
+async function reportRefusal(
+  ctx: ToolContext,
+  tool: string,
+  args: Args,
+  reason: string,
+): Promise<void> {
+  try {
+    await ctx.api.get("/api/activity", {}, "POST", {
+      tool,
+      ...(typeof args.repo === "string" ? { repo: args.repo } : {}),
+      ...(typeof args.service === "string" ? { service: args.service } : {}),
+      reason,
+    });
+  } catch {
+    /* the refusal is still returned to the agent */
+  }
+}
+
 export async function callTool(
   name: string,
   args: Args,
@@ -548,12 +620,19 @@ export async function callTool(
     const text = typeof out === "string" ? out : JSON.stringify(out, null, 2);
     return { text: redactSecrets(text), isError: false };
   } catch (e) {
+    if (e instanceof ActionFailed)
+      return {
+        text: redactSecrets(JSON.stringify(e.out, null, 2)),
+        isError: true,
+      };
     if (e instanceof DenHttpError && e.status === 404) {
       const text = await notFoundMessage(e, name, ctx).catch(
         (inner: Error) => `Error: ${inner.message}`,
       );
       return { text: redactSecrets(text), isError: true };
     }
+    if (e instanceof Refusal && tool.action)
+      await reportRefusal(ctx, name, args, e.message);
     const msg =
       e instanceof Refusal
         ? `Refused: ${e.message}`

package/src/ui/server/audit.ts

@@ -20,9 +20,13 @@ export interface AuditEntry {
   clientVersion?: string;
   mcpPid?: number | null;
   session?: string;
-  /** exec | run | sync */
+  /** exec | run | sync, or the MCP tool name for a refused non-lifecycle call */
   verb: string;
   detail: string;
+  /** Set when the action never ran: a guard or the server refused it. */
+  outcome?: "refused";
+  /** Why it was refused (first line). */
+  reason?: string;
 }
 
 type Sink = (line: string, actor: AgentActor | null) => void;
@@ -43,7 +47,12 @@ export function actorSuffix(actor: Actor): string {
 
 export function recordAction(
   actor: Actor,
-  action: { verb: string; detail: string },
+  action: {
+    verb: string;
+    detail: string;
+    outcome?: "refused";
+    reason?: string;
+  },
 ): AuditEntry {
   const entry: AuditEntry = {
     ts: new Date().toISOString(),
@@ -58,13 +67,70 @@ export function recordAction(
       : {}),
     verb: action.verb,
     detail: action.detail,
+    ...(action.outcome ? { outcome: action.outcome } : {}),
+    ...(action.reason ? { reason: clean(action.reason, 300) } : {}),
   };
   ring.push(entry);
   if (ring.length > RING_MAX) ring.shift();
-  sink?.(`▶ ${action.verb} ${action.detail}${actorSuffix(actor)}`, actor);
+  const mark = entry.outcome === "refused" ? "✗" : "▶";
+  const why = entry.reason ? ` — refused: ${entry.reason}` : "";
+  sink?.(
+    `${mark} ${action.verb} ${action.detail}${why}${actorSuffix(actor)}`,
+    actor,
+  );
   return entry;
 }
 
+/** One line, printable characters only, at most `max` long. */
+function clean(v: unknown, max: number): string {
+  const line = String(v ?? "").split(/[\r\n]/)[0];
+  return [...line]
+    .filter((c) => c.charCodeAt(0) >= 0x20 && c.charCodeAt(0) !== 0x7f)
+    .join("")
+    .slice(0, max);
+}
+
+const SAFE_PART = /^[A-Za-z0-9._-]{1,128}$/;
+const LIFECYCLE_TOOL = /^service_(up|down|restart)$/;
+
+/**
+ * An MCP guard refused an agent's call before it reached an action route.
+ * The agent's own report, so every field is sanitised: a lifecycle tool with
+ * a valid repo becomes an "exec" entry for that service (what the panel's
+ * activity list shows); anything else is recorded under the tool's name.
+ */
+export function recordAgentRefusal(
+  actor: Actor,
+  report: {
+    tool?: unknown;
+    repo?: unknown;
+    service?: unknown;
+    reason?: unknown;
+  },
+): AuditEntry {
+  const tool = clean(report.tool, 64).replace(/[^A-Za-z0-9_]/g, "") || "tool";
+  const repo = typeof report.repo === "string" ? report.repo : "";
+  const service = typeof report.service === "string" ? report.service : "";
+  const lifecycle = LIFECYCLE_TOOL.exec(tool);
+  const reason = clean(report.reason, 300) || "refused";
+  if (lifecycle && SAFE_PART.test(repo)) {
+    const address =
+      service && SAFE_PART.test(service) ? `${repo}/${service}` : repo;
+    return recordAction(actor, {
+      verb: "exec",
+      detail: `${address} ${lifecycle[1]} (local)`,
+      outcome: "refused",
+      reason,
+    });
+  }
+  return recordAction(actor, {
+    verb: tool,
+    detail: "",
+    outcome: "refused",
+    reason,
+  });
+}
+
 /** The most recent actions, oldest first. */
 export function recentActions(): AuditEntry[] {
   return ring.slice();

package/src/ui/server/index.ts

@@ -135,6 +135,7 @@ import {
   actorFromHeaders,
   actorSuffix,
   recordAction,
+  recordAgentRefusal,
   setAuditSink,
 } from "./audit.js";
 import { handleReadonlyRoutes } from "./readonly-routes.js";
@@ -409,6 +410,7 @@ import { parseChangelog } from "./changelog-parser.js";
 import { GitHubService } from "./github-service.js";
 import { EditorManager, SUPPORTED_LANGUAGES } from "./editor-manager.js";
 import { handleWorkspaceRoutes } from "./workspace-routes.js";
+import { isLifecycleExecCmd, streamLifecycleExec } from "./lifecycle-exec.js";
 import { readEdgeConfig, readWebPort } from "../../shared/edge/config.js";
 import {
   linksFor,
@@ -730,6 +732,25 @@ async function handleRequest(
     }
   }
 
+  // ── API: an agent's refused call (F2) ─────────────────────────────────────
+  // The MCP server's guards refuse some calls before they reach an action
+  // route; it reports them here so the activity trail shows failed attempts.
+  // Agents only (the audit header), and the entry is all it can write.
+  if (pathname === "/api/activity" && req.method === "POST") {
+    const actor = actorFromHeaders(req.headers);
+    if (!actor) return sendJson(res, { error: "agents only" }, 403);
+    const raw = await readBody(req).catch(() => "");
+    if (raw.length > 4096) return send400(res, "report too large");
+    let report: Record<string, unknown> = {};
+    try {
+      report = JSON.parse(raw || "{}") as Record<string, unknown>;
+    } catch {
+      return send400(res, "invalid JSON");
+    }
+    const entry = recordAgentRefusal(actor, report);
+    return sendJson(res, { recorded: true, ts: entry.ts });
+  }
+
   // ── API: stacks, edge, security plan (read-only; see readonly-routes.ts) ──
   if (await handleReadonlyRoutes(req, res, pathname, url)) return;
 
@@ -1361,7 +1382,15 @@ async function handleRequest(
     const emit = (obj: unknown): void => {
       res.write(`data: ${JSON.stringify(obj)}\n\n`);
     };
+    // Every fail here is before anything ran: a refusal or a lookup miss.
+    // Recorded, so failed attempts show in the activity trail (F2).
     const fail = (msg: string): void => {
+      recordAction(actorFromHeaders(req.headers), {
+        verb: "exec",
+        detail: `${repoName}/${svcName} ${cmdName} (${env})`,
+        outcome: "refused",
+        reason: msg,
+      });
       emit({ type: "error", text: msg });
       emit({ type: "done", exitCode: 1, duration: 0 });
       res.end();
@@ -1393,13 +1422,65 @@ async function handleRequest(
         `${repoName}/${svcName}`,
         servicePlacement(manifest, resolved.subsystem, env),
         (e) => isProductionEnv(e),
-        cmdName === "down" ? "stop" : "start",
+        cmdName,
       );
       if (refusal) return fail(refusal);
       if (manifest) {
         cmdDef =
           manifest.services?.[resolved.subsystem]?.commands?.[env]?.[cmdName];
       }
+      // Lifecycle commands run through the service runner, as the CLI's do:
+      // restart without a declared restart is down + up, up on a healthy
+      // service starts nothing, down honours workspace ownership.
+      if (env === "local" && isLifecycleExecCmd(cmdName)) {
+        if (cmdDef && isInteractiveServiceCommand(cmdDef))
+          return fail(
+            `"${cmdName}" requires an interactive terminal (HITL).\n` +
+              `Run in your terminal:\n  ${product().cli} ${cmdName} ${resolved.address}`,
+          );
+        const execId = shortRunId();
+        const execDesc = `${repoName}/${svcName} ${cmdName} (${env})`;
+        const execActor = actorFromHeaders(req.headers);
+        recordAction(execActor, {
+          verb: "exec",
+          detail: `${execDesc} [${execId}]`,
+        });
+        prewarmSudo();
+        void streamLifecycleExec(
+          {
+            resolved,
+            cmd: cmdName,
+            workspace: wsParam ?? undefined,
+            env: { E2E_ENVIRONMENT: env, ...getSudoEnv() },
+            emit: (e) => {
+              if (e.type === "line" && typeof e.text === "string")
+                mirrorLine(execId, e.text);
+              emit(e);
+            },
+            end: () => res.end(),
+            onClientClose: (fn) => res.on("close", fn),
+            onExit: (exitCode, duration) => {
+              serverLog(
+                `■ exec ${execDesc} · exit=${exitCode} · ${formatDuration(duration)} [${execId}]${actorSuffix(execActor)}`,
+                "lifecycle",
+                execActor ? actorLabel(execActor) : undefined,
+              );
+              recordInvocation({
+                command: "service.exec",
+                surface: "ux",
+                durationMs: duration,
+                exit: exitCode,
+                extra: { action: cmdName, env },
+              });
+            },
+          },
+          {
+            run: runServiceCommand,
+            health: (r) => checkServiceHealth(r, "local"),
+          },
+        );
+        return;
+      }
     }
 
     if (!cmdDef) {
@@ -1412,7 +1493,7 @@ async function handleRequest(
             `${repoName}/${svcName}`,
             servicePlacement(repo.manifest, svcName, env),
             (e) => isProductionEnv(e),
-            cmdName === "down" ? "stop" : "start",
+            cmdName,
           )
         : null;
       if (refusal) return fail(refusal);

package/src/ui/server/lifecycle-exec.ts

@@ -0,0 +1,188 @@
+/**
+ * `/api/service/exec` for the lifecycle commands (up, down, restart): run
+ * through the service runner, as the CLI does, instead of executing the
+ * manifest's command string directly. That gives the web UI and MCP the CLI's
+ * semantics:
+ *
+ *   - restart without a declared `restart` is down + up;
+ *   - up on a service that is already healthy starts nothing ("already up");
+ *   - up attaches to a running shared instance instead of starting a second;
+ *   - down honours workspace ownership (refcounted).
+ *
+ * Events are the route's existing SSE shapes: line, started, service-exited,
+ * error, done; plus `ready` once a detached start is up: its health check
+ * passes (`checked: true`), or, with no health check, its launcher is still
+ * running after a settle window (`checked: false`). A launcher that keeps
+ * running in the foreground (a dev server) never sends `service-exited`, so
+ * `ready` is how a caller knows the start worked.
+ */
+import type { ChildProcess } from "child_process";
+import type { ResolvedService } from "../../shared/types/index.js";
+import type {
+  RunCommandOptions,
+  RunCommandResult,
+} from "../../shared/environment-manager/service-runner.js";
+import type { ServiceHealthResult } from "../../shared/environment-manager/health.js";
+
+export const LIFECYCLE_EXEC_CMDS = ["up", "down", "restart"] as const;
+export type LifecycleExecCmd = (typeof LIFECYCLE_EXEC_CMDS)[number];
+
+export function isLifecycleExecCmd(c: string): c is LifecycleExecCmd {
+  return (LIFECYCLE_EXEC_CMDS as readonly string[]).includes(c);
+}
+
+export interface LifecycleExecDeps {
+  run: (o: RunCommandOptions) => RunCommandResult;
+  health: (r: ResolvedService) => Promise<ServiceHealthResult>;
+  /** Health poll interval after a detached start (default 1s). */
+  pollMs?: number;
+  /** Stop polling after this long (default 120s). */
+  readyTimeoutMs?: number;
+  /** With no health check: ready after this long still running (default 5s). */
+  settleMs?: number;
+  /**
+   * Restart: a green check counts only after the check went red (the old
+   * instance stopped) or this long has passed (default 5s).
+   */
+  restartMinMs?: number;
+}
+
+export interface LifecycleExecOptions {
+  resolved: ResolvedService;
+  cmd: LifecycleExecCmd;
+  workspace?: string;
+  env: NodeJS.ProcessEnv;
+  emit: (e: Record<string, unknown>) => void;
+  /** Called once, after the final `done` event. */
+  end: () => void;
+  /** Registers a callback for the client going away. */
+  onClientClose: (fn: () => void) => void;
+  /** Called with the exit code when the command completes. */
+  onExit?: (exitCode: number, durationMs: number) => void;
+}
+
+export async function streamLifecycleExec(
+  o: LifecycleExecOptions,
+  deps: LifecycleExecDeps,
+): Promise<void> {
+  const { resolved, cmd, emit } = o;
+  const start = Date.now();
+  let finished = false;
+  let clientGone = false;
+  const finish = (exitCode: number, explained = false): void => {
+    if (finished) return;
+    finished = true;
+    const duration = Date.now() - start;
+    o.onExit?.(exitCode, duration);
+    if (clientGone) return;
+    if (exitCode !== 0 && !explained)
+      emit({ type: "error", text: `Command failed (exit ${exitCode})` });
+    emit({ type: "done", exitCode, duration });
+    o.end();
+  };
+
+  let proc: ChildProcess | null = null;
+  let onServiceExitHook: (() => void) | undefined;
+  o.onClientClose(() => {
+    clientGone = true;
+    try {
+      proc?.kill();
+    } catch {
+      /* already exited */
+    }
+  });
+
+  // Up on a healthy service is a no-op: starting a second copy only fails on
+  // its port (and an agent waits out the detach window to learn that).
+  if (cmd === "up") {
+    const h = await deps.health(resolved).catch(() => null);
+    if (h?.health === "ok") {
+      emit({
+        type: "line",
+        text: `${resolved.address} is already up (healthy) — nothing to start`,
+      });
+      finish(0);
+      return;
+    }
+  }
+
+  const result = deps.run({
+    address: resolved.address,
+    command: cmd,
+    workspace: o.workspace,
+    runtime: "daemon",
+    env: o.env,
+    onLine: (text) => {
+      if (!clientGone) emit({ type: "line", text });
+    },
+    onClose: finish,
+    onServiceExit: (exitCode) => {
+      onServiceExitHook?.();
+      if (clientGone) return;
+      emit({
+        type: "service-exited",
+        exitCode,
+        repoName: resolved.repoName,
+        subsystem: resolved.subsystem,
+      });
+    },
+  });
+  proc = result.proc;
+
+  // Backstop: the route refuses an interactive command before calling this,
+  // so the runner should never hand back a TTY-bound process here.
+  if (result.interactive) {
+    try {
+      proc.kill();
+    } catch {
+      /* already exited */
+    }
+    emit({
+      type: "error",
+      text: `"${cmd}" requires an interactive terminal (HITL). Run it from your terminal.`,
+    });
+    finish(1, true);
+    return;
+  }
+  if (result.detachable) {
+    // The runner has already said where the log is.
+    emit({ type: "started", detached: true });
+    watchReady();
+  }
+
+  function watchReady(): void {
+    const pollMs = deps.pollMs ?? 1000;
+    const timeoutMs = deps.readyTimeoutMs ?? 120_000;
+    const settleMs = deps.settleMs ?? 5000;
+    const restartMinMs = deps.restartMinMs ?? 5000;
+    const t0 = Date.now();
+    let exited = false;
+    let sawDown = false;
+    const prevExit = onServiceExitHook;
+    onServiceExitHook = () => {
+      exited = true;
+      prevExit?.();
+    };
+    const tick = async (): Promise<void> => {
+      if (finished || clientGone || exited) return;
+      const elapsed = Date.now() - t0;
+      if (elapsed > timeoutMs) return;
+      const h = await deps.health(resolved).catch(() => null);
+      if (finished || clientGone || exited) return;
+      if (h?.health === "ok") {
+        if (cmd !== "restart" || sawDown || elapsed >= restartMinMs) {
+          emit({ type: "ready", checked: true });
+          return;
+        }
+      } else if (h?.health === "error") {
+        sawDown = true;
+      } else if (elapsed >= settleMs) {
+        // No health check to wait for: still running after the settle window.
+        emit({ type: "ready", checked: false });
+        return;
+      }
+      setTimeout(() => void tick(), pollMs);
+    };
+    setTimeout(() => void tick(), pollMs);
+  }
+}

package/src/ui/server/public/graph.css

@@ -906,6 +906,10 @@ path.dg-e.dim {
 .dg ol.act span:last-child {
   overflow-wrap: anywhere;
 }
+.dg ol.act .refused {
+  color: var(--red);
+  font-style: normal;
+}
 .dg-who {
   font-size: 11.5px;
   padding: 0 7px;

package/src/ui/server/public/panel.js

@@ -54,6 +54,9 @@ const repoEntry = (r) => entryOf(C.model(), r.repo);
 const anyHere = (r) => r.services.some(runsHere);
 const LIFECYCLE = ["up", "down", "restart"];
 
+/** Restart is the declared command, or down + up when both exist (as the CLI). */
+const canRestart = (s) => has(s, "restart") || (has(s, "up") && has(s, "down"));
+
 export const ACTIONS = [
   // ── service ──
   {
@@ -97,7 +100,7 @@ export const ACTIONS = [
     label: "Restart",
     for: ["service"],
     tier: "common",
-    when: (s) => runsHere(s) && has(s, "restart"),
+    when: (s) => runsHere(s) && canRestart(s),
     run: (s) => C.hooks.runCmd(s, "restart"),
   },
   {
@@ -133,7 +136,7 @@ export const ACTIONS = [
     label: "Restart",
     for: ["repo"],
     tier: "common",
-    when: (r) => runsHere(repoEntry(r)) && has(repoEntry(r), "restart"),
+    when: (r) => runsHere(repoEntry(r)) && canRestart(repoEntry(r)),
     run: (r) => C.hooks.runCmd(repoEntry(r), "restart"),
   },
   {
@@ -778,7 +781,7 @@ function activityList(x) {
     .then(({ entries = [] }) => {
       if (!live) return;
       el.innerHTML = entries.length
-        ? `<ol class="act">${entries.map((a) => `<li><time datetime="${esc(a.ts)}">${esc(hhmm(a.ts))}</time><span class="dg-who ${a.actor === "agent" ? "agent" : ""}">${esc(a.actor === "agent" ? "[agent]" + (a.client ? " " + a.client : "") : "you")}</span><span>${esc(a.verb)} ${esc(a.detail)}</span></li>`).join("")}</ol>`
+        ? `<ol class="act">${entries.map((a) => `<li><time datetime="${esc(a.ts)}">${esc(hhmm(a.ts))}</time><span class="dg-who ${a.actor === "agent" ? "agent" : ""}">${esc(a.actor === "agent" ? "[agent]" + (a.client ? " " + a.client : "") : "you")}</span><span>${esc(a.verb)} ${esc(a.detail)}${a.outcome === "refused" ? ` <em class="refused">refused: ${esc(a.reason || "")}</em>` : ""}</span></li>`).join("")}</ol>`
         : none(
             "No actions yet. Starts, restarts and syncs, yours and agents', show here.",
           );

package/src/ui/server/readonly-routes.ts

@@ -91,11 +91,20 @@ export function activityFor(
   entries: AuditEntry[],
   target: { address?: string; repo?: string },
 ): AuditEntry[] {
+  // A repo-level entry ("core down (local)") is an attempt on the repo
+  // without naming a service, as agents usually do: it shows for the repo
+  // and for each of its services.
+  const repoLevel = (e: AuditEntry, repo: string): boolean =>
+    e.verb === "exec" && e.detail.startsWith(repo + " ");
   const matches = (e: AuditEntry): boolean => {
     if (target.address)
-      return e.verb === "exec" && e.detail.startsWith(target.address + " ");
+      return (
+        (e.verb === "exec" && e.detail.startsWith(target.address + " ")) ||
+        repoLevel(e, target.address.split("/")[0])
+      );
     const repo = target.repo ?? "";
-    if (e.verb === "exec") return e.detail.startsWith(repo + "/");
+    if (e.verb === "exec")
+      return e.detail.startsWith(repo + "/") || repoLevel(e, repo);
     if (e.verb === "sync") return e.detail.split(" ").includes(`repo=${repo}`);
     return false;
   };

package/src/ui/server/workspace-routes.ts

@@ -1490,7 +1490,7 @@ export async function handleWorkspaceRoutes(
             "local",
           ),
           () => false,
-          cmd === "down" ? "stop" : "start",
+          cmd,
         );
         if (remote) {
           emit({ type: "line", text: `  ${remote}` });