@yannelli/paseo-linear-plugin 1.1.0-beta.0 → 1.1.0-beta.1

package/client/live-header.tsx

@@ -10,6 +10,7 @@ import { eventTone, KIND_ICONS } from "./live-feed";
 import { type IssueProgress, MONO, ProgressBar } from "./live-issues";
 import { type LiveMap, NATIVE_DRIVER, type OwnerColors } from "./live-timeline";
 import { ProviderIcon } from "./provider-icon";
+import { ToolButton, ToolGroup } from "./tool-buttons";
 import { Button, StateIcon, type Theme } from "./ui";
 
 type AgentStatus = PluginAgentSnapshot["status"];
@@ -256,6 +257,34 @@ export function MapSource(props: { theme: Theme; live: LiveMap; mapping: Mapping
   );
 }
 
+/** Read the file data again, rebuild the map with the explore agent, or clear the saved map. */
+export function MapActions(props: { theme: Theme; live: LiveMap }) {
+  const { theme, live } = props;
+  const { explore, refresh, clear } = live;
+  const running = live.job?.status === "running";
+  const rebuild = useCallback(() => explore(true), [explore]);
+  return (
+    <ToolGroup theme={theme}>
+      <ToolButton theme={theme} icon="RefreshCw" label="Read files and links again" onPress={refresh} />
+      <ToolButton
+        theme={theme}
+        icon="Sparkles"
+        label={live.stored ? "Rebuild the map with the explore agent" : "Build the map with the explore agent"}
+        busy={live.starting || running}
+        onPress={rebuild}
+      />
+      <ToolButton
+        theme={theme}
+        icon="Eraser"
+        label="Clear the saved map and use the ticket text"
+        disabled={!live.stored || running}
+        busy={live.clearing}
+        onPress={clear}
+      />
+    </ToolGroup>
+  );
+}
+
 export function ViewToggle(props: {
   theme: Theme;
   value: LiveView;

package/client/live-panel.tsx

@@ -6,13 +6,13 @@ import { type LayoutChangeEvent, Text, View } from "react-native";
 import { deriveActivity } from "../shared/activity";
 import type { IssueDetail } from "../shared/linear";
 import { AGENT_LABELS } from "../shared/prompts";
-import { type LinearSettings, type LiveView, linearSettings, type MappingMode } from "../shared/settings";
+import { type GraphCamera, type LinearSettings, type LiveView, linearSettings, type MappingMode } from "../shared/settings";
 import { KeyScopeProvider } from "./key-scope";
 import { buildGraph, graphFiles } from "../shared/graph-model";
 import { AgentsList, cursorAgents, useLiveAgents } from "./live-agents";
 import { ActivityFeed } from "./live-feed";
 import { LiveGraph } from "./live-graph";
-import { LiveHeader, MapSource, ViewToggle } from "./live-header";
+import { LiveHeader, MapActions, MapSource, ViewToggle } from "./live-header";
 import { type FocusKey, IssueRail, issueProgress, SubIssues } from "./live-issues";
 import { MapLegend, RepoMap } from "./live-map";
 import {
@@ -33,6 +33,7 @@ interface AgentInfo {
   identifier: string | null;
   project: string | null;
   cwd: string;
+  workspaceId: string | null;
   status: AgentStatus;
   provider: string;
 }
@@ -41,11 +42,14 @@ const selectAgent = (agent: PluginAgentSnapshot): AgentInfo => ({
   identifier: agent.labels[AGENT_LABELS.issue] ?? null,
   project: agent.labels[AGENT_LABELS.project] ?? null,
   cwd: agent.cwd,
+  workspaceId: agent.workspaceId ?? null,
   status: agent.status,
   provider: agent.provider,
 });
 
-type LivePatch = Partial<Pick<LinearSettings["live"], "view" | "issuesCollapsed">>;
+export type LivePatch = Partial<
+  Pick<LinearSettings["live"], "view" | "issuesCollapsed" | "graphCamera" | "graphLocked">
+>;
 
 const STACK_WIDTH = 760;
 const COLUMN_WIDTH = 330;
@@ -103,6 +107,8 @@ export function LivePanel(props: PluginAgentPanelProps) {
         mapping={live?.mapping ?? "semantic"}
         view={live?.view ?? "map"}
         issuesCollapsed={live?.issuesCollapsed ?? false}
+        graphCamera={live?.graphCamera ?? "auto"}
+        graphLocked={live?.graphLocked ?? false}
         saveLive={saveLive}
         openAgent={props.navigation ? (id) => props.navigation?.openAgent({ agentId: id }) : undefined}
       />
@@ -119,6 +125,8 @@ interface BodyProps {
   mapping: MappingMode;
   view: LiveView;
   issuesCollapsed: boolean;
+  graphCamera: GraphCamera;
+  graphLocked: boolean;
   saveLive(patch: LivePatch): void;
   openAgent?: (agentId: string) => void;
 }
@@ -206,6 +214,7 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
     theme,
     agentId,
     cwd: agent.cwd,
+    workspaceId: agent.workspaceId,
     status: agent.status,
     provider: agent.provider,
     activity,
@@ -249,8 +258,16 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
     [view, graphInput, links.links],
   );
   const cursors = useMemo(
-    () => cursorAgents({ theme, provider: agent.provider, working, activity, children: agents.children }),
-    [theme, agent.provider, working, activity, agents.children],
+    () =>
+      cursorAgents({
+        theme,
+        provider: agent.provider,
+        working,
+        activity,
+        children: agents.children,
+        subagents: agents.subagents,
+      }),
+    [theme, agent.provider, working, activity, agents.children, agents.subagents],
   );
   const owners = useMemo(() => ownerColors(issue, colors.accent), [issue, colors.accent]);
   const progress = useMemo(() => issueProgress(issue, activity.todos), [issue, activity.todos]);
@@ -322,6 +339,7 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
       right={
         <View style={styles.tools}>
           {stacked || view === "graph" ? null : <MapLegend theme={theme} />}
+          <MapActions theme={theme} live={liveMap} />
           {toggle}
         </View>
       }
@@ -346,6 +364,9 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
             agents={cursors}
             focus={focus}
             onFocus={toggleFocus}
+            camera={props.graphCamera}
+            locked={props.graphLocked}
+            saveLive={saveLive}
             reduceMotion={reduceMotion}
           />
         ) : (
@@ -367,14 +388,14 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
     <Card theme={theme} title="Activity">
       <ActivityFeed
         theme={theme}
-        events={activity.events}
+        events={agents.events}
         loading={timeline.loading}
         error={timeline.error}
         reduceMotion={reduceMotion}
       />
     </Card>
   );
-  const helpers = agents.children.length + activity.subagents.length;
+  const helpers = agents.children.length + agents.subagents.length;
   const agentsCard =
     helpers > 0 ? (
       <Card theme={theme} title="Agents" meta={<Text style={styles.hit}>{`${helpers + 1}`}</Text>}>
@@ -384,7 +405,7 @@ function LiveView(props: BodyProps & { issue: IssueDetail }) {
           status={agent.status}
           current={activity.current}
           childAgents={agents.children}
-          subagents={activity.subagents}
+          subagents={agents.subagents}
           onOpenAgent={props.openAgent}
         />
       </Card>

package/client/live-timeline.ts

@@ -1,17 +1,20 @@
 import { usePaseo, useRpc } from "@getpaseo/plugin/client";
-import { keepPreviousData, useMutation, useQuery } from "@tanstack/react-query";
-import { useEffect, useMemo, useState } from "react";
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { AccessibilityInfo, Platform } from "react-native";
 import type { DirTouch, FileTouch, TimelineItemLike } from "../shared/activity";
 import type { IssueDetail } from "../shared/linear";
 import type { FileLink } from "../shared/links";
 import {
+  clearMapRpc,
   exploreRpc,
   type IssueMap,
   type Job,
   listFilesRpc,
   linksRpc,
   liveMapRpc,
+  type SubagentLog,
+  subagentLogsRpc,
   MAX_LINK_FILES,
   MAX_LIST_DIRS,
   type MapFile,
@@ -244,6 +247,11 @@ export interface LiveMap {
   starting: boolean;
   error: string | null;
   explore(force: boolean): void;
+  /** Reads the map, folder listings, links, and subagents again. */
+  refresh(): void;
+  /** Forgets the saved explore map; the map falls back to the ticket text. */
+  clear(): void;
+  clearing: boolean;
 }
 
 export function useLiveMap(
@@ -270,9 +278,13 @@ export function useLiveMap(
     onSettled: () => void refetch(),
   });
   const { mutate } = explore;
+  const queries = useQueryClient();
+  const refresh = useCallback(() => void queries.invalidateQueries({ queryKey: ["linear", "live"] }), [queries]);
+  const clearMap = useRpc(clearMapRpc);
+  const clear = useMutation({ mutationFn: () => clearMap({ agentId }), onSettled: refresh });
   const fallback = useMemo(() => semanticMap(issue), [issue]);
   const stored = query.data?.map ?? null;
-  const failure = explore.error ?? query.error;
+  const failure = explore.error ?? clear.error ?? query.error;
   return {
     map: stored ?? fallback,
     stored: stored !== null,
@@ -281,6 +293,9 @@ export function useLiveMap(
     starting: explore.isPending,
     error: failure ? errorMessage(failure) : null,
     explore: mutate,
+    refresh,
+    clear: clear.mutate as () => void,
+    clearing: clear.isPending,
   };
 }
 
@@ -339,3 +354,23 @@ export function useFileLinks(
     ready: sorted.length === 0 || query.data !== undefined || query.isError,
   };
 }
+
+const NO_RUNS: readonly SubagentLog[] = [];
+
+/** Tool calls of the agent's subagents, read again every few seconds while the agent works. */
+export function useSubagentLogs(
+  agentId: string,
+  enabled: boolean,
+  polling: boolean,
+): { runs: readonly SubagentLog[]; checkedAt: number } {
+  const read = useRpc(subagentLogsRpc);
+  const query = useQuery({
+    queryKey: ["linear", "live", "subagents", agentId],
+    queryFn: () => read({ agentId }),
+    enabled,
+    refetchInterval: polling ? 3_000 : false,
+    placeholderData: keepPreviousData,
+    staleTime: 2_000,
+  });
+  return { runs: query.data?.runs ?? NO_RUNS, checkedAt: query.dataUpdatedAt };
+}

package/client/settings-live.tsx

@@ -26,6 +26,7 @@ const VIEW_OPTIONS: readonly { label: string; value: LiveView }[] = [
   { label: "Graph: issue, files, and agents as connected nodes", value: "graph" },
 ];
 const SAME_AGENT = "";
+const MODEL_DEFAULT = "";
 
 export function LiveSettings({ theme }: PluginSurfaceProps) {
   const settings = useSettings(linearSettings);
@@ -62,6 +63,20 @@ function LiveEditor({ theme, settings }: { theme: Theme; settings: ReadySettings
     }
     return options;
   }, [providers.data, live.exploreProvider]);
+  // Efforts of the chosen model, such as Low to Max, with its default first.
+  const effortOptions = useMemo(() => {
+    const [agentId, ...rest] = live.exploreProvider.split("/");
+    const modelId = rest.join("/");
+    const model = providers.data
+      ?.find((agent) => agent.id === agentId)
+      ?.models.find((entry) => entry.id === modelId);
+    if (!model || model.efforts.length === 0) return null;
+    const fallback = model.efforts.find((effort) => effort.id === model.defaultEffortId);
+    return [
+      { label: fallback ? `Model default: ${fallback.label}` : "Model default", value: MODEL_DEFAULT },
+      ...model.efforts.map((effort) => ({ label: effort.label, value: effort.id })),
+    ];
+  }, [providers.data, live.exploreProvider]);
 
   return (
     <View>
@@ -94,8 +109,17 @@ function LiveEditor({ theme, settings }: { theme: Theme; settings: ReadySettings
             hint="It may only read and search the project folder. A faster, cheaper model is usually enough."
             value={live.exploreProvider}
             options={agentOptions}
-            onValueChange={(exploreProvider) => change({ exploreProvider })}
+            onValueChange={(exploreProvider) => change({ exploreProvider, exploreEffort: MODEL_DEFAULT })}
           />
+          {effortOptions ? (
+            <SettingsSelect
+              label="Explore and setup effort"
+              hint="How much the model thinks before it answers. Lower is faster and uses less of your plan."
+              value={effortOptions.some((option) => option.value === live.exploreEffort) ? live.exploreEffort : MODEL_DEFAULT}
+              options={effortOptions}
+              onValueChange={(exploreEffort) => change({ exploreEffort })}
+            />
+          ) : null}
         </SettingsCard>
       </SettingsSection>
       <SettingsSection title="Linear status sync">

package/client/tool-buttons.tsx

@@ -0,0 +1,68 @@
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { type ReactNode, useMemo } from "react";
+import { ActivityIndicator, Pressable, View } from "react-native";
+import { type Theme, usePressableStyle } from "./ui";
+
+// Small icon buttons for card toolbars: map actions and the graph's camera. A group draws them
+// in one bordered track, like the Map and Graph switch.
+
+export function ToolGroup({ theme, children }: { theme: Theme; children: ReactNode }) {
+  const { colors } = theme;
+  const style = useMemo(
+    () =>
+      ({
+        flexDirection: "row",
+        alignItems: "center",
+        padding: 2,
+        gap: 2,
+        borderRadius: 8,
+        borderWidth: 1,
+        borderColor: colors.border,
+        backgroundColor: colors.surface1,
+      }) as const,
+    [colors],
+  );
+  return <View style={style}>{children}</View>;
+}
+
+export function ToolButton(props: {
+  theme: Theme;
+  icon: string;
+  /** Read by screen readers and shown as the tooltip on web. */
+  label: string;
+  onPress(): void;
+  /** A toggle that is on. */
+  active?: boolean;
+  disabled?: boolean;
+  busy?: boolean;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(() => {
+    const idle = {
+      width: 26,
+      height: 24,
+      borderRadius: 6,
+      alignItems: "center",
+      justifyContent: "center",
+      backgroundColor: props.active ? colors.surface2 : "transparent",
+      opacity: props.disabled ? 0.4 : 1,
+    } as const;
+    return { idle, hover: { ...idle, backgroundColor: colors.surface2 } };
+  }, [colors, props.active, props.disabled]);
+  const pressStyle = usePressableStyle(styles.idle, styles.hover);
+  const color = props.active ? colors.foreground : colors.foregroundMuted;
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={props.label}
+      accessibilityState={{ selected: props.active === true, disabled: props.disabled === true }}
+      disabled={props.disabled || props.busy}
+      onPress={props.onPress}
+      hitSlop={4}
+      style={pressStyle}
+      {...({ title: props.label } as object)}
+    >
+      {props.busy ? <ActivityIndicator size="small" color={color} /> : <Icon name={props.icon} size={14} color={color} />}
+    </Pressable>
+  );
+}

package/client/web.ts

@@ -0,0 +1,45 @@
+import { Platform } from "react-native";
+
+// The only module that uses the DOM. React wheel listeners are passive, so they cannot keep
+// the page from scrolling while the wheel zooms the graph. Off the web each export does nothing.
+
+interface WheelEventLike {
+  deltaY: number;
+  deltaMode: number;
+  clientX: number;
+  clientY: number;
+  preventDefault(): void;
+}
+
+type WheelListener = (event: WheelEventLike) => void;
+
+interface ElementLike {
+  addEventListener(type: "wheel", listener: WheelListener, options: { passive: boolean }): void;
+  removeEventListener(type: "wheel", listener: WheelListener): void;
+  getBoundingClientRect(): { left: number; top: number };
+}
+
+function isElement(node: unknown): node is ElementLike {
+  if (typeof node !== "object" || node === null) return false;
+  const element = node as Partial<ElementLike>;
+  return typeof element.addEventListener === "function" && typeof element.getBoundingClientRect === "function";
+}
+
+const LINE = 16;
+const PAGE = 400;
+
+/** Calls onWheel with the point under the pointer and a zoom factor. Returns the cleanup. */
+export function listenWheel(
+  node: unknown,
+  onWheel: (point: { x: number; y: number }, factor: number) => void,
+): () => void {
+  if (Platform.OS !== "web" || !isElement(node)) return () => {};
+  const listener: WheelListener = (event) => {
+    event.preventDefault();
+    const rect = node.getBoundingClientRect();
+    const pixels = event.deltaY * (event.deltaMode === 1 ? LINE : event.deltaMode === 2 ? PAGE : 1);
+    onWheel({ x: event.clientX - rect.left, y: event.clientY - rect.top }, Math.exp(-pixels * 0.002));
+  };
+  node.addEventListener("wheel", listener, { passive: false });
+  return () => node.removeEventListener("wheel", listener);
+}

package/index.server.ts

@@ -1,5 +1,7 @@
 import path from "node:path";
 import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { registerAgentHooks } from "./server/agent-hooks";
+import { registerAgentTools } from "./server/agent-tools";
 import { createCredentialStore, defaultCredentialPath } from "./server/credentials";
 import { registerHandlers } from "./server/handlers";
 import { registerInit } from "./server/init";
@@ -24,9 +26,11 @@ export default function contribute(server: PluginServerContext) {
   registerLive(server, { access, maps, launches, readSettings });
   registerSync(server, { access, readSettings });
   registerInit(server, { readSettings });
+  registerAgentHooks(server, dataDirectory);
+  const closeTools = registerAgentTools(server, { access, dataDirectory });
   server.handle(accessRpc, async () => {
     const values = await readSettings();
     return values?.access ?? linearSettings.schema.parse({}).access;
   });
-  return () => {};
+  return closeTools;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yannelli/paseo-linear-plugin",
-  "version": "1.1.0-beta.0",
+  "version": "1.1.0-beta.1",
   "description": "Browse and triage Linear issues in Paseo and start agents from them",
   "license": "Apache-2.0",
   "type": "module",

package/server/agent-hooks.ts

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { agentHooksRpc, claudeHooks, hookPluginName, IDENTIFIER } from "../shared/agent-hooks";
+
+// Writes one Claude Code plugin folder per issue under the plugin's data folder. A launch passes
+// the folder to Claude with --plugin-dir. The name holds a hash of the hooks, so a later launch
+// never changes the hooks of a running agent. Resumed agents keep using it, so it stays.
+
+async function writeAtomic(file: string, text: string) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, text, { mode: 0o600 });
+  await rename(temporary, file);
+}
+
+export function registerAgentHooks(server: PluginServerContext, dataDirectory: string) {
+  server.handle(agentHooksRpc, async ({ issue, guidance }) => {
+    // The hooks run printf in a POSIX shell, which Windows hosts do not have.
+    if (process.platform === "win32" || !IDENTIFIER.test(issue.identifier)) return { pluginDir: null };
+    const hooks = claudeHooks(issue, guidance);
+    if (!hooks) return { pluginDir: null };
+    const text = `${JSON.stringify(hooks, null, 2)}\n`;
+    const hash = createHash("sha256").update(text).digest("hex").slice(0, 12);
+    const root = path.join(dataDirectory, "claude-hooks", `${issue.identifier.toUpperCase()}-${hash}`);
+    await mkdir(path.join(root, ".claude-plugin"), { recursive: true, mode: 0o700 });
+    await mkdir(path.join(root, "hooks"), { recursive: true, mode: 0o700 });
+    const manifest = {
+      name: hookPluginName(issue.identifier),
+      version: "1.0.0",
+      description: `Linear context for ${issue.identifier} from the Paseo Linear plugin`,
+    };
+    await writeAtomic(path.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    await writeAtomic(path.join(root, "hooks", "hooks.json"), text);
+    return { pluginDir: root };
+  });
+}

package/server/agent-runs.ts

@@ -20,6 +20,8 @@ export interface InternalRun<T> {
   /** Folder the agent works in; its reads must stay inside. */
   cwd: string;
   provider: string;
+  /** Thinking option for the model in `provider`; ignored when another model runs. */
+  effort?: string;
   title: string;
   prompt: string;
   labels: Record<string, string>;
@@ -144,7 +146,7 @@ export async function agentConfigFor(paseo: Paseo, preferred: string) {
   return { provider, ...(modeId ? { modeId } : {}) };
 }
 
-async function lastReply(handle: AgentHandle) {
+export async function lastReply(handle: AgentHandle) {
   const page = await handle.timeline.refetch({
     direction: "tail",
     limit: 60,
@@ -221,8 +223,14 @@ export interface StartedRun<T> {
   result: Promise<T>;
 }
 
+/** Adds the chosen effort only when the chosen model runs, not a fallback provider. */
+export function withEffort<C extends { provider: string }>(config: C, chosen: string, effort?: string) {
+  const applies = Boolean(effort) && chosen.includes("/") && config.provider === chosen;
+  return applies ? { ...config, thinkingOptionId: effort as string } : config;
+}
+
 export async function startInternalRun<T>(run: InternalRun<T>): Promise<StartedRun<T>> {
-  const config = await agentConfigFor(run.paseo, run.provider);
+  const config = withEffort(await agentConfigFor(run.paseo, run.provider), run.provider, run.effort);
   const handle = await run.workspace.agents.create({
     config,
     title: run.title,
@@ -239,6 +247,8 @@ export interface JobStore<T> {
   start(id: string | null, begin: () => Promise<StartedRun<T>>): Promise<Job>;
   /** Resolves with the job once it is done or failed; null for an unknown id. */
   wait(id: string): Promise<Job | null>;
+  /** Drops a finished job, so the next start makes a new run. A running job is kept. */
+  forget(id: string): void;
 }
 
 interface JobRecord<T> {
@@ -254,6 +264,9 @@ export function createJobStore<T>(): JobStore<T> {
       const record = jobs.get(id);
       return record ? { job: record.job, value: record.value } : null;
     },
+    forget(id) {
+      if (jobs.get(id)?.job.status !== "running") jobs.delete(id);
+    },
     async wait(id) {
       const record = jobs.get(id);
       if (!record) return null;