@skyhook-io/radar-app 1.8.13 → 1.9.1

package/src/components/applications/ApplicationsView.tsx

@@ -639,13 +639,14 @@ function AppDetailRoute({
         history={historyQuery.data}
         historyLoading={historyQuery.isLoading}
         historyItems={historyItems}
-        historyRuntimeLoading={historyTimelineQuery.isFetching}
+        historyRuntimeLoading={historyTimelineQuery.isLoading}
         historyRuntimeError={historyTimelineQuery.isError}
         historyMode={timelineSource.capabilities.mode}
         historyRange={historyRange}
         historyRangeOptions={historyRangeOptions}
         historyCoverageRecordCount={historyTimelineQuery.coverage?.length ?? 0}
         historyRuntimeLimited={historyRuntimeLimited}
+        historyRingTruncated={historyTimelineQuery.truncated ?? false}
         onHistoryRangeChange={setRetainedHistoryRange}
         onOpenTimeline={openApplicationTimeline}
         onOpenSource={openSource}

package/src/components/diagnose/AISettings.tsx

@@ -5,12 +5,16 @@
 // Settings tabs' layout — this renders only the controls (no card, no heading).
 import { useState } from "react";
 import { Trash2 } from "lucide-react";
-import { clearHistory, type AgentInfo } from "../../api/diagnose";
+import {
+  clearHistory,
+  type AgentInfo,
+  type ExecutionProfile,
+} from "../../api/diagnose";
 import { AgentControls } from "./parts";
 
 export interface AIDraft {
   agent: string;
-  isolated: boolean;
+  profile: ExecutionProfile;
   model: string;
   effort: string;
 }
@@ -120,17 +124,27 @@ export function AISettingsSection({
         // The agent, its model, and how it runs are all fixed by the host — none
         // of the local BYO-agent knobs apply, so there's nothing to configure.
         <p className="text-xs leading-snug text-theme-text-tertiary">
-          {agentLabel} manages the model and how it runs — there&apos;s nothing to
-          configure here.
+          {agentLabel} manages the model and how it runs — there&apos;s nothing
+          to configure here.
         </p>
       ) : (
         <AgentControls
           agents={agents}
           selectedAgent={draft.agent}
           // Model + effort are agent-specific; reset them when the agent changes.
-          onSelectAgent={(a) => onChange({ agent: a, model: "", effort: "" })}
-          isolated={draft.isolated}
-          onSetIsolated={(v) => onChange({ isolated: v })}
+          onSelectAgent={(a) => {
+            const nextProfile = agents.find(
+              (agent) => agent.name === a,
+            )?.profiles?.[0];
+            onChange({
+              agent: a,
+              profile: nextProfile ?? draft.profile,
+              model: "",
+              effort: "",
+            });
+          }}
+          profile={draft.profile}
+          onSetProfile={(v) => onChange({ profile: v })}
           model={draft.model}
           onSetModel={(v) => onChange({ model: v })}
           effort={draft.effort}

package/src/components/diagnose/DiagnoseContext.tsx

@@ -22,7 +22,11 @@ import {
   recordConsent,
   DiagnoseError,
 } from "../../api/diagnose";
-import { type RunSummary, type AgentInfo } from "../../api/diagnose";
+import {
+  type RunSummary,
+  type AgentInfo,
+  type ExecutionProfile,
+} from "../../api/diagnose";
 
 export interface Target {
   kind: string;
@@ -38,8 +42,8 @@ interface DiagnoseCtx {
   agents: AgentInfo[]; // supported agents detected on PATH (for the picker)
   selectedAgent: string; // name of the chosen backend ("claude"/"codex")
   setSelectedAgent: (name: string) => void;
-  isolated: boolean; // run the agent without the user's own CLI config
-  setIsolated: (v: boolean) => void;
+  profile: ExecutionProfile;
+  setProfile: (v: ExecutionProfile) => void;
   model: string; // optional model override ("" = the agent's own default)
   setModel: (v: string) => void;
   effort: string; // optional Codex reasoning effort ("" = default)
@@ -108,15 +112,10 @@ const WIDTH_KEY = "radar-ai-panel-width";
 // Consent is machine-scoped and lives server-side (~/.radar): it gates a
 // machine-scoped action (spawn this machine's agent CLI, persist transcripts to
 // this machine's disk), so one acknowledgment covers this panel AND the
-// `radar diagnose` CLI. Cursor gets its own surface — its trust model is
-// materially different (the user's global MCP servers can't be excluded), so
-// approving Claude/Codex never bypasses Cursor's distinct disclosure.
-type ConsentSurface = "standard" | "cursor";
-function consentSurfaceFor(agent: string): ConsentSurface {
-  return agent === "cursor-agent" ? "cursor" : "standard";
-}
+// `radar diagnose` CLI. The execution profile selects the disclosure because
+// it determines the actual access available to the agent process.
 const AGENT_KEY = "radar-ai-agent";
-const ISOLATED_KEY = "radar-ai-isolated";
+const PROFILE_KEY = "radar-ai-profile";
 const MODEL_KEY = "radar-ai-model";
 const EFFORT_KEY = "radar-ai-effort";
 // Push (reflow the app left) only while the app keeps at least this much width to
@@ -140,7 +139,9 @@ export function agentLabelFor(name: string, fallbackLabel?: string): string {
 // openDiagnoseSettings opens the Settings dialog (App.tsx listens for this DOM
 // event) — the canonical home for AI-diagnosis config.
 export function openDiagnoseSettings() {
-  window.dispatchEvent(new CustomEvent("radar:open-settings"));
+  window.dispatchEvent(
+    new CustomEvent("radar:open-settings", { detail: { section: "ai" } }),
+  );
 }
 
 function readStored(key: string): string | null {
@@ -161,14 +162,12 @@ function writeStored(key: string, value: string) {
 export function DiagnoseProvider({ children }: { children: ReactNode }) {
   const [available, setAvailable] = useState(false);
   const [agents, setAgents] = useState<AgentInfo[]>([]);
-  const [consented, setConsented] = useState<
-    Record<ConsentSurface, boolean>
-  >({ standard: false, cursor: false });
+  const [consented, setConsented] = useState<Record<string, boolean>>({});
   const [selectedAgent, setSelectedAgentState] = useState<string>(
     () => readStored(AGENT_KEY) || "",
   );
-  const [isolated, setIsolatedState] = useState<boolean>(
-    () => readStored(ISOLATED_KEY) !== "0", // default isolated
+  const [profile, setProfileState] = useState<ExecutionProfile>(
+    () => (readStored(PROFILE_KEY) as ExecutionProfile) || "safeguarded",
   );
   const [model, setModelState] = useState<string>(
     () => readStored(MODEL_KEY) || "",
@@ -205,12 +204,15 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     fetchAgents()
       .then((r) => {
         if (!live) return;
-        setAvailable(r.enabled);
-        setConsented({
-          standard: !!r.consented?.standard,
-          cursor: !!r.consented?.cursor,
-        });
-        const supported = r.agents.filter((a) => a.supported);
+        setConsented(r.consented ?? {});
+        const supported = r.agents.filter(
+          (a) =>
+            a.supported &&
+            (a.hosted ||
+              (!!a.profiles?.length &&
+                a.profiles.every((p) => !!a.consentSurfaces?.[p]))),
+        );
+        setAvailable(r.enabled && supported.length > 0);
         setAgents(supported);
         // Keep the stored pick only if it's still installed; else default to the
         // first supported agent (matches the server's default selection).
@@ -220,6 +222,13 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
             ? stored
             : (supported[0]?.name ?? "");
         setSelectedAgentState(next);
+        const profiles = supported.find((a) => a.name === next)?.profiles ?? [];
+        const storedProfile =
+          (readStored(PROFILE_KEY) as ExecutionProfile) || "safeguarded";
+        if (!profiles.includes(storedProfile) && profiles[0]) {
+          setProfileState(profiles[0]);
+          writeStored(PROFILE_KEY, profiles[0]);
+        }
         // Model/effort are agent-specific; if the stored agent is gone, its values
         // don't apply to the fallback agent (e.g. a Codex slug under Claude) — drop them.
         if (next !== stored) {
@@ -247,23 +256,35 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     (name: string) => {
       setSelectedAgentState(name);
       writeStored(AGENT_KEY, name);
+      const nextProfile = agents.find((agent) => agent.name === name)?.profiles?.[0];
+      if (nextProfile) {
+        setProfileState(nextProfile);
+        writeStored(PROFILE_KEY, nextProfile);
+      }
       // Model + effort are agent-specific (Claude aliases vs Codex slugs); reset
       // to the new agent's default rather than carry an invalid value across.
       setModel("");
       setEffort("");
     },
-    [setModel, setEffort],
+    [agents, setModel, setEffort],
   );
-  const setIsolated = useCallback((v: boolean) => {
-    setIsolatedState(v);
-    writeStored(ISOLATED_KEY, v ? "1" : "0");
+  const setProfile = useCallback((v: ExecutionProfile) => {
+    setProfileState(v);
+    writeStored(PROFILE_KEY, v);
   }, []);
 
-  const agentLabel = agentLabelFor(
-    selectedAgent,
-    agents.find((a) => a.name === selectedAgent)?.label,
-  );
-  const hosted = !!agents.find((a) => a.name === selectedAgent)?.hosted;
+  const selectedAgentInfo = agents.find((a) => a.name === selectedAgent);
+  const effectiveProfile =
+    selectedAgentInfo?.profiles?.includes(profile)
+      ? profile
+      : (selectedAgentInfo?.profiles?.[0] ?? profile);
+  const agentLabel = agentLabelFor(selectedAgent, selectedAgentInfo?.label);
+  const hosted = !!selectedAgentInfo?.hosted;
+  // Hosted Radar uses its existing per-user disclosure surface and supplies its
+  // own copy. Local agents use the execution profile as the consent contract.
+  const consentSurface = hosted
+    ? "standard"
+    : (selectedAgentInfo?.consentSurfaces?.[effectiveProfile] ?? "");
 
   useEffect(() => {
     const onResize = () => setViewportW(window.innerWidth);
@@ -314,10 +335,6 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     return () => clearInterval(t);
   }, [open, available, hasRunning, refreshRuns]);
 
-  // Keep the live selected agent reachable from the [] -dep callbacks below
-  // (consent is agent-specific, so they must read the CURRENT pick, not a closure).
-  const selectedAgentRef = useRef(selectedAgent);
-  selectedAgentRef.current = selectedAgent;
   const consentedRef = useRef(consented);
   consentedRef.current = consented;
 
@@ -329,7 +346,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     const seq = ++startSeqRef.current;
     createRun(t, {
       agent: selectedAgent || undefined,
-      isolated,
+      profile: hosted ? undefined : effectiveProfile,
       model: model || undefined,
       effort: effort || undefined,
     })
@@ -351,17 +368,26 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
       });
   };
 
-  const openInvestigation = useCallback((t: Target) => {
-    setStartError(null);
-    setOpen(true);
-    if (!consentedRef.current[consentSurfaceFor(selectedAgentRef.current)]) {
-      setPendingTarget(t);
+  const openInvestigation = useCallback(
+    (t: Target) => {
+      setStartError(null);
+      setOpen(true);
+      if (!hosted && !consentSurface) {
+        setPendingTarget(null);
+        setStartError("Radar can’t run this agent with a verified execution profile.");
+        setView("investigation");
+        return;
+      }
+      if (!consentedRef.current[consentSurface]) {
+        setPendingTarget(t);
+        setView("investigation");
+        return;
+      }
       setView("investigation");
-      return;
-    }
-    setView("investigation");
-    startRunRef.current(t);
-  }, []);
+      startRunRef.current(t);
+    },
+    [consentSurface, hosted],
+  );
   const openRun = useCallback((id: string) => {
     setStartError(null);
     setActiveRunId(id);
@@ -401,15 +427,18 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
   const consentBusyRef = useRef(false);
   const approveConsent = useCallback(() => {
     if (consentBusyRef.current) return;
+    if (!consentSurface) {
+      setStartError("Radar can’t record consent for this agent.");
+      return;
+    }
     consentBusyRef.current = true;
     setStartError(null);
-    const surface = consentSurfaceFor(selectedAgentRef.current);
     const t = pendingTarget;
     // The server ENFORCES consent at start, so the acknowledgment must land
     // before the run request — awaiting also makes it durable for the CLI.
-    recordConsent(surface)
+    recordConsent(consentSurface)
       .then(() => {
-        setConsented((prev) => ({ ...prev, [surface]: true }));
+        setConsented((prev) => ({ ...prev, [consentSurface]: true }));
         // Cleared only on success: a failed write keeps the consent card up
         // (needsConsent = !!pendingTarget) so "try again" works in place.
         setPendingTarget(null);
@@ -421,7 +450,7 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
       .finally(() => {
         consentBusyRef.current = false;
       });
-  }, [pendingTarget]);
+  }, [consentSurface, pendingTarget]);
   const cancelConsent = useCallback(() => {
     setPendingTarget(null);
     setOpen(false);
@@ -440,8 +469,8 @@ export function DiagnoseProvider({ children }: { children: ReactNode }) {
     agents,
     selectedAgent,
     setSelectedAgent,
-    isolated,
-    setIsolated,
+    profile: effectiveProfile,
+    setProfile,
     model,
     setModel,
     effort,

package/src/components/diagnose/DiagnoseSurface.tsx

@@ -28,25 +28,29 @@ import { InvestigationView } from "./InvestigationView";
 import { RecentList } from "./Home";
 import { ConsentCard } from "./parts";
 import { buildLaunchCommand, launchAgentLabel, openInTerminal } from "./launch";
-import { type RunSummary } from "../../api/diagnose";
+import { type RunSummary, type ExecutionProfile } from "../../api/diagnose";
 
 function capWord(s: string): string {
   return s ? s[0].toUpperCase() + s.slice(1) : s;
 }
 
 // buildConfigLine renders the active AI config as the header subtitle. Codex shows
-// its isolation mode + effective reasoning effort (Default → medium); a model
+// its execution profile + effective reasoning effort (Default → medium); a model
 // override is shown for either agent. Reflects a run's recorded settings, or the
 // current defaults on Home.
 function buildConfigLine(cfg: {
   agent?: string;
-  isolated?: boolean;
+  profile?: ExecutionProfile;
   model?: string;
   effort?: string;
 }): string {
   const parts = [agentLabelFor(cfg.agent ?? "")];
+  if (cfg.profile) {
+    parts.push(
+      cfg.profile === "full-local" ? "Your agent setup" : "Radar safeguards",
+    );
+  }
   if (cfg.agent === "codex") {
-    parts.push(cfg.isolated === false ? "My setup" : "Isolated");
     parts.push(`${capWord(cfg.effort || "medium")} effort`);
   }
   if (cfg.model) parts.push(capWord(cfg.model));
@@ -139,7 +143,8 @@ export function DiagnoseSurface({ topInset = 0 }: { topInset?: number }) {
   const d = useDiagnose();
   // Injected settings action: undefined = Radar's own Settings dialog;
   // null = hide the gear + links.
-  const { consentCopy, onOpenSettings: hostOpenSettings } = useDiagnoseCustomization();
+  const { consentCopy, onOpenSettings: hostOpenSettings } =
+    useDiagnoseCustomization();
   const openSettings =
     hostOpenSettings === undefined ? openDiagnoseSettings : hostOpenSettings;
   const {
@@ -180,12 +185,12 @@ export function DiagnoseSurface({ topInset = 0 }: { topInset?: number }) {
     ? agentLabelFor(activeRun.agent)
     : d.agentLabel;
   // Header subtitle: the config a focused run actually used (it records agent /
-  // isolation / model / effort), or the current defaults on Home. Codex shows mode
+  // profile / model / effort), or the current defaults on Home. Codex shows mode
   // + reasoning effort; model is shown only when overridden. Clicking opens Settings.
   const configLine = buildConfigLine(
     activeRun ?? {
       agent: d.selectedAgent,
-      isolated: d.isolated,
+      profile: d.hosted ? undefined : d.profile,
       model: d.model,
       effort: d.effort,
     },
@@ -208,7 +213,7 @@ export function DiagnoseSurface({ topInset = 0 }: { topInset?: number }) {
         <ConsentCard
           agentName={d.agentLabel}
           agent={d.selectedAgent}
-          isolated={d.isolated}
+          profile={d.profile}
           copy={consentCopy}
           onOpenSettings={openSettings ?? undefined}
           onApprove={d.approveConsent}

package/src/components/diagnose/parts.test.tsx

@@ -0,0 +1,125 @@
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+import { AgentControls, ConsentCard } from "./parts";
+import type { AgentInfo, ExecutionProfile } from "../../api/diagnose";
+
+const noop = vi.fn();
+
+function renderAgent(
+  agent: string,
+  profiles: ExecutionProfile[],
+  profile: ExecutionProfile,
+) {
+  const agents: AgentInfo[] = [
+    {
+      name: agent,
+      label: agent,
+      path: agent,
+      version: "",
+      present: true,
+      supported: true,
+      profiles,
+    },
+  ];
+  return renderToStaticMarkup(
+    <AgentControls
+      agents={agents}
+      selectedAgent={agent}
+      onSelectAgent={noop}
+      profile={profile}
+      onSetProfile={noop}
+      model=""
+      onSetModel={noop}
+      effort=""
+      onSetEffort={noop}
+    />,
+  );
+}
+
+describe("AgentControls execution profile explanation", () => {
+  it("shows Cursor's fixed full-local warning even when the stored profile is stale", () => {
+    const html = renderAgent("cursor-agent", ["full-local"], "safeguarded");
+    expect(html).toContain("must use this agent");
+    expect(html).toContain("normal setup");
+    expect(html).toContain("always loads your global MCP servers");
+    expect(html).toContain("still enables the agent CLI");
+    expect(html).toContain("does not constrain external MCP servers");
+    expect(html).not.toContain("always runs this agent with safeguards");
+  });
+
+  it("discloses the Claude configuration that Radar cannot exclude", () => {
+    const html = renderAgent(
+      "claude",
+      ["safeguarded", "full-local"],
+      "safeguarded",
+    );
+    expect(html).toContain("built-in tools are disabled");
+    expect(html).toContain("settings, hooks, and CLAUDE.md instructions still apply");
+    expect(html).toContain("Your claude setup");
+    expect(html).not.toContain("other agent configuration is excluded");
+  });
+
+  it("explains that Claude full-local inherits the user's permissions", () => {
+    const html = renderAgent(
+      "claude",
+      ["safeguarded", "full-local"],
+      "full-local",
+    );
+    expect(html).toContain("permissions from your setup");
+    expect(html).toContain("Radar does not override them");
+    expect(html).not.toContain("Radar still enables the agent CLI");
+  });
+
+  it("does not describe an unknown safeguarded agent as Codex", () => {
+    const html = renderAgent("future-agent", ["safeguarded"], "safeguarded");
+    expect(html).toContain("documented restrictions");
+    expect(html).not.toContain("Codex");
+    expect(html).not.toContain("built-in tools are disabled");
+  });
+
+  it("labels the selectable full-local profile as the user's agent setup", () => {
+    const html = renderAgent(
+      "codex",
+      ["safeguarded", "full-local"],
+      "safeguarded",
+    );
+    expect(html).toContain("Your codex setup");
+    expect(html).not.toContain("Full local setup");
+  });
+});
+
+describe("ConsentCard execution profile treatment", () => {
+  it("uses warning chrome and explicit consequences for the user's agent setup", () => {
+    const html = renderToStaticMarkup(
+      <ConsentCard
+        agentName="Cursor Agent"
+        agent="cursor-agent"
+        profile="full-local"
+        onApprove={noop}
+        onCancel={noop}
+      />,
+    );
+    expect(html).toContain("Run using your Cursor Agent setup?");
+    expect(html).toContain("Continue with my agent setup");
+    expect(html).toContain("border-amber-500/40");
+    expect(html).toContain("text-amber-500");
+    expect(html).toContain("Radar cannot constrain");
+    expect(html).toContain("always loads your global MCP servers");
+    expect(html).not.toContain("text-accent");
+  });
+
+  it("does not claim Radar enables a sandbox for Claude's normal setup", () => {
+    const html = renderToStaticMarkup(
+      <ConsentCard
+        agentName="Claude Code"
+        agent="claude"
+        profile="full-local"
+        onApprove={noop}
+        onCancel={noop}
+      />,
+    );
+    expect(html).toContain("permissions from your setup");
+    expect(html).toContain("Radar does not override them");
+    expect(html).not.toContain("Radar still enables the agent CLI");
+  });
+});