feat: inbox for twig (#898)

### TL;DR

Added Autonomy features to Twig, including an Inbox with Signals and Setup tabs to help users monitor and configure their repositories.

### What changed?

- Added a new Inbox view with two tabs:
  - **Signals tab**: Displays AI-detected signals from repositories with details and evidence
  - **Setup tab**: Shows repository readiness status and allows users to create setup tasks
- Extended the PostHog API client with new methods for:
  - Fetching project autonomy settings
  - Getting repository readiness status
  - Retrieving signal reports and artifacts
  - Updating team settings
- Added UI components for displaying repository status, capability pills, and signal cards
- Implemented stores for caching readiness status and managing sidebar state
- Added navigation support for the new Inbox view
- Enhanced the sidebar menu to include an Inbox item with signal count
- Improved the Tooltip component to support complex content

### How to test?

1. Log in to Twig with a PostHog account that has Autonomy enabled
2. Look for the new "Inbox" item in the sidebar
3. Click on it to access the Signals and Setup tabs
4. In the Setup tab:
   - Evaluate repository readiness
   - Create setup tasks for repositories that need configuration
5. In the Signals tab:
   - View detected signals and their details
   - Examine evidence artifacts
   - Run signals with optional context

### Why make this change?

This change introduces Autonomy features to Twig, allowing users to:
- Discover and act on AI-detected signals from their repositories
- Easily identify repositories that need proper instrumentation
- Set up PostHog tracking, session replay, and error monitoring
- Get a clear overview of their project's readiness status

These features help users maximize the value they get from PostHog by ensuring proper setup and surfacing important insights automatically.

Author: k11kirky

apps/twig/src/api/posthogClient.ts

@@ -1,5 +1,11 @@
 import { logger } from "@renderer/lib/logger";
-import type { Task, TaskRun } from "@shared/types";
+import type {
+  RepoAutonomyStatus,
+  SignalReportArtefactsResponse,
+  SignalReportsResponse,
+  Task,
+  TaskRun,
+} from "@shared/types";
 import type { StoredLogEntry } from "@shared/types/session-events";
 import { buildApiFetcher } from "./fetcher";
 import { createApiClient, type Schemas } from "./generated";
@@ -61,7 +67,41 @@ export class PostHogAPIClient {
     return data as Schemas.Team;
   }
 
-  async getTasks(options?: { repository?: string; createdBy?: number }) {
+  async getProjectAutonomySettings(projectId: number): Promise<{
+    proactive_tasks_enabled?: boolean;
+  }> {
+    try {
+      const urlPath = `/api/environments/${projectId}/`;
+      const url = new URL(`${this.api.baseUrl}${urlPath}`);
+      const response = await this.api.fetcher.fetch({
+        method: "get",
+        url,
+        path: urlPath,
+      });
+      const data = (await response.json()) as {
+        proactive_tasks_enabled?: boolean;
+      };
+
+      return {
+        proactive_tasks_enabled:
+          typeof data.proactive_tasks_enabled === "boolean"
+            ? data.proactive_tasks_enabled
+            : false,
+      };
+    } catch (error) {
+      log.warn("Failed to resolve autonomy settings; defaulting to disabled", {
+        projectId,
+        error,
+      });
+      return { proactive_tasks_enabled: false };
+    }
+  }
+
+  async getTasks(options?: {
+    repository?: string;
+    createdBy?: number;
+    originProduct?: string;
+  }) {
     const teamId = await this.getTeamId();
     const params: Record<string, string | number> = {
       limit: 500,
@@ -75,6 +115,10 @@ export class PostHogAPIClient {
       params.created_by = options.createdBy;
     }
 
+    if (options?.originProduct) {
+      params.origin_product = options.originProduct;
+    }
+
     const data = await this.api.get(`/api/projects/{project_id}/tasks/`, {
       path: { project_id: teamId.toString() },
       query: params,
@@ -374,6 +418,52 @@ export class PostHogAPIClient {
     return data.results ?? [];
   }
 
+  async updateTeam(updates: {
+    session_recording_opt_in?: boolean;
+    autocapture_exceptions_opt_in?: boolean;
+  }): Promise<Schemas.Team> {
+    const teamId = await this.getTeamId();
+    const url = new URL(`${this.api.baseUrl}/api/projects/${teamId}/`);
+    const response = await this.api.fetcher.fetch({
+      method: "patch",
+      url,
+      path: `/api/projects/${teamId}/`,
+      overrides: {
+        body: JSON.stringify(updates),
+      },
+    });
+
+    if (!response.ok) {
+      const responseText = await response.text();
+      let detail = responseText;
+      try {
+        const parsed = JSON.parse(responseText) as
+          | { detail?: string }
+          | Record<string, unknown>;
+        if (
+          typeof parsed === "object" &&
+          parsed !== null &&
+          "detail" in parsed &&
+          typeof parsed.detail === "string"
+        ) {
+          detail = parsed.detail;
+        } else if (typeof parsed === "object" && parsed !== null) {
+          detail = Object.entries(parsed)
+            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+            .join(", ");
+        }
+      } catch {
+        // keep plain text fallback
+      }
+
+      throw new Error(
+        `Failed to update team: ${detail || response.statusText}`,
+      );
+    }
+
+    return await response.json();
+  }
+
   /**
    * Get details for multiple projects by their IDs.
    * Returns project info including organization details.
@@ -432,6 +522,99 @@ export class PostHogAPIClient {
     }));
   }
 
+  async getSignalReports(): Promise<SignalReportsResponse> {
+    const teamId = await this.getTeamId();
+    const url = new URL(
+      `${this.api.baseUrl}/api/projects/${teamId}/signal_reports/`,
+    );
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: `/api/projects/${teamId}/signal_reports/`,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch signal reports: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return {
+      results: data.results ?? data ?? [],
+      count: data.count ?? data.results?.length ?? data?.length ?? 0,
+    };
+  }
+
+  async getSignalReportArtefacts(
+    reportId: string,
+  ): Promise<SignalReportArtefactsResponse> {
+    const teamId = await this.getTeamId();
+    const url = new URL(
+      `${this.api.baseUrl}/api/projects/${teamId}/signal_reports/${reportId}/artefacts/`,
+    );
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: `/api/projects/${teamId}/signal_reports/${reportId}/artefacts/`,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch signal report artefacts: ${response.statusText}`,
+      );
+    }
+
+    const data = await response.json();
+    return {
+      results: data.results ?? data ?? [],
+      count: data.count ?? data.results?.length ?? data?.length ?? 0,
+    };
+  }
+
+  async getRepositoryReadiness(
+    repository: string,
+    options?: { refresh?: boolean; windowDays?: number },
+  ): Promise<RepoAutonomyStatus> {
+    const teamId = await this.getTeamId();
+    const url = new URL(
+      `${this.api.baseUrl}/api/projects/${teamId}/tasks/repository_readiness/`,
+    );
+    url.searchParams.set("repository", repository.toLowerCase());
+    if (options?.refresh) {
+      url.searchParams.set("refresh", "true");
+    }
+    if (typeof options?.windowDays === "number") {
+      url.searchParams.set("window_days", String(options.windowDays));
+    }
+
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: `/api/projects/${teamId}/tasks/repository_readiness/`,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch repository readiness: ${response.statusText}`,
+      );
+    }
+
+    const data = await response.json();
+    return {
+      repository: data.repository,
+      classification: data.classification,
+      excluded: data.excluded,
+      coreSuggestions: data.coreSuggestions,
+      replayInsights: data.replayInsights,
+      errorInsights: data.errorInsights,
+      overall: data.overall,
+      evidenceTaskCount: data.evidenceTaskCount ?? 0,
+      windowDays: data.windowDays,
+      generatedAt: data.generatedAt,
+      cacheAgeSeconds: data.cacheAgeSeconds,
+      scan: data.scan,
+    } as RepoAutonomyStatus;
+  }
+
   /**
    * Check if a feature flag is enabled for the current project.
    * Returns true if the flag exists and is active, false otherwise.

apps/twig/src/renderer/components/MainLayout.tsx

@@ -2,7 +2,9 @@ import { ConnectivityPrompt } from "@components/ConnectivityPrompt";
 import { HeaderRow } from "@components/HeaderRow";
 import { KeyboardShortcutsSheet } from "@components/KeyboardShortcutsSheet";
 import { UpdatePrompt } from "@components/UpdatePrompt";
+import { useAutonomy } from "@features/autonomy/hooks/useAutonomy";
 import { CommandMenu } from "@features/command/components/CommandMenu";
+import { InboxView } from "@features/inbox/components/InboxView";
 import { RightSidebar, RightSidebarContent } from "@features/right-sidebar";
 import { FolderSettingsView } from "@features/settings/components/FolderSettingsView";
 import { SettingsDialog } from "@features/settings/components/SettingsDialog";
@@ -21,7 +23,7 @@ import { useTaskDeepLink } from "../hooks/useTaskDeepLink";
 import { GlobalEventHandlers } from "./GlobalEventHandlers";
 
 export function MainLayout() {
-  const { view, hydrateTask } = useNavigationStore();
+  const { view, hydrateTask, navigateToTaskInput } = useNavigationStore();
   const [commandMenuOpen, setCommandMenuOpen] = useState(false);
   const {
     isOpen: shortcutsSheetOpen,
@@ -30,6 +32,7 @@ export function MainLayout() {
   } = useShortcutsSheetStore();
   const { data: tasks } = useTasks();
   const { showPrompt, isChecking, check, dismiss } = useConnectivity();
+  const inboxEnabled = useAutonomy();
 
   useIntegrations();
   useTaskDeepLink();
@@ -40,6 +43,12 @@ export function MainLayout() {
     }
   }, [tasks, hydrateTask]);
 
+  useEffect(() => {
+    if (view.type === "inbox" && !inboxEnabled) {
+      navigateToTaskInput();
+    }
+  }, [view.type, inboxEnabled, navigateToTaskInput]);
+
   const handleToggleCommandMenu = useCallback(() => {
     setCommandMenuOpen((prev) => !prev);
   }, []);
@@ -58,6 +67,10 @@ export function MainLayout() {
           )}
 
           {view.type === "folder-settings" && <FolderSettingsView />}
+
+          {view.type === "inbox" && inboxEnabled && <InboxView />}
+
+          {view.type === "inbox" && !inboxEnabled && <TaskInput />}
         </Box>
 
         {view.type === "task-detail" && view.data && (

apps/twig/src/renderer/components/ui/Tooltip.tsx

@@ -27,6 +27,9 @@ export function Tooltip({
   defaultOpen,
   onOpenChange,
 }: TooltipProps) {
+  const isSimpleContent =
+    typeof content === "string" || typeof content === "number";
+
   return (
     <TooltipPrimitive.Provider delayDuration={delayDuration}>
       <TooltipPrimitive.Root
@@ -51,7 +54,7 @@ export function Tooltip({
               borderRadius: "6px",
               fontSize: "12px",
               lineHeight: "1.4",
-              whiteSpace: "nowrap",
+              whiteSpace: isSimpleContent ? "nowrap" : "normal",
               border: "1px solid var(--gray-4)",
               boxShadow: "0 4px 12px rgba(0, 0, 0, 0.25)",
               zIndex: 9999,
@@ -60,7 +63,7 @@ export function Tooltip({
               willChange: "transform, opacity",
             }}
           >
-            <span>{content}</span>
+            {isSimpleContent ? <span>{content}</span> : content}
             {shortcut && (
               <KeyHint style={{ fontSize: "12px" }}>{shortcut}</KeyHint>
             )}

apps/twig/src/renderer/features/autonomy/hooks/useAutonomy.ts

@@ -0,0 +1,23 @@
+import { useAuthStore } from "@features/auth/stores/authStore";
+import { useAuthenticatedQuery } from "@hooks/useAuthenticatedQuery";
+
+interface AutonomySettings {
+  proactive_tasks_enabled?: boolean;
+}
+
+export function useAutonomy(): boolean {
+  const projectId = useAuthStore((state) => state.projectId);
+  const { data: autonomySettings } = useAuthenticatedQuery<AutonomySettings>(
+    ["inbox", "autonomy-settings", projectId],
+    (client) =>
+      projectId
+        ? client.getProjectAutonomySettings(projectId)
+        : Promise.resolve({}),
+    {
+      enabled: !!projectId,
+      staleTime: 30 * 1000,
+    },
+  );
+
+  return autonomySettings?.proactive_tasks_enabled === true;
+}