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

package/server/subagent-logs.ts

@@ -0,0 +1,146 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import type { SubagentLog } from "../shared/live";
+
+// Claude writes each subagent's transcript beside the session, also for subagents that run in
+// the background and send nothing to the parent timeline. This reads their tool calls and turns
+// them into timeline items the panel already understands. Nothing here writes or runs anything.
+
+const SESSION_ID = /^[A-Za-z0-9-]{8,80}$/;
+const MAX_RUNS = 8;
+const MAX_TAIL_BYTES = 512 * 1024;
+const MAX_ITEMS = 120;
+
+/** Folders that can hold Claude's `projects` folder: the env setting, the default, Paseo homes. */
+async function claudeHomes(): Promise<string[]> {
+  const homes = [process.env.CLAUDE_CONFIG_DIR, path.join(homedir(), ".claude")];
+  const paseoHome = process.env.PASEO_HOME || path.join(homedir(), ".paseo");
+  const accounts = await readdir(path.join(paseoHome, "zerosub", "homes")).catch(() => []);
+  for (const name of accounts) homes.push(path.join(paseoHome, "zerosub", "homes", name));
+  return [...new Set(homes.filter((home): home is string => Boolean(home)))];
+}
+
+const found = new Map<string, string>();
+
+async function isDirectory(target: string): Promise<boolean> {
+  return (await stat(target).catch(() => null))?.isDirectory() ?? false;
+}
+
+/** The session's `subagents` folder. Claude names the project folder after the cwd. */
+export async function subagentFolder(sessionId: string, cwd: string): Promise<string | null> {
+  if (!SESSION_ID.test(sessionId)) return null;
+  const known = found.get(sessionId);
+  if (known) return known;
+  const slug = cwd.replace(/[^A-Za-z0-9]/g, "-");
+  for (const home of await claudeHomes()) {
+    const projects = path.join(home, "projects");
+    const guess = path.join(projects, slug, sessionId, "subagents");
+    const names = (await isDirectory(guess)) ? [slug] : await readdir(projects).catch(() => []);
+    for (const name of names) {
+      const folder = path.join(projects, name, sessionId, "subagents");
+      if (await isDirectory(folder)) {
+        found.set(sessionId, folder);
+        return folder;
+      }
+    }
+  }
+  return null;
+}
+
+async function tail(file: string): Promise<string> {
+  const handle = await open(file, "r");
+  try {
+    const { size } = await handle.stat();
+    const start = Math.max(0, size - MAX_TAIL_BYTES);
+    const buffer = Buffer.alloc(size - start);
+    await handle.read(buffer, 0, buffer.length, start);
+    const text = buffer.toString("utf8");
+    // A cut first line is not valid JSON; drop it.
+    return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+  } finally {
+    await handle.close();
+  }
+}
+
+type Block = Record<string, unknown>;
+type Item = SubagentLog["items"][number];
+
+const str = (value: unknown) => (typeof value === "string" ? value : "");
+const lines = (value: unknown) => (str(value) ? str(value).replace(/\n$/, "").split("\n").length : 0);
+
+/** A Claude tool call as a Paseo-style tool call item, with paths moved from the worktree. */
+export function toolItem(block: Block, move: (value: string) => string, cwd: string): Item {
+  const input = (block.input ?? {}) as Block;
+  const name = str(block.name);
+  const file = move(str(input.file_path) || str(input.notebook_path));
+  let detail: Record<string, unknown> = { type: "unknown" };
+  if (name === "Read" && file) detail = { type: "read", filePath: file };
+  else if ((name === "Edit" || name === "MultiEdit" || name === "NotebookEdit") && file) {
+    const edits = Array.isArray(input.edits) ? (input.edits as Block[]) : [input];
+    const added = edits.reduce((sum, edit) => sum + lines(edit.new_string ?? edit.new_source), 0);
+    const removed = edits.reduce((sum, edit) => sum + lines(edit.old_string), 0);
+    detail = { type: "edit", filePath: file, added, removed };
+  } else if (name === "Write" && file) detail = { type: "write", filePath: file, added: lines(input.content) };
+  else if (name === "Grep" || name === "Glob") detail = { type: "search", query: str(input.pattern) };
+  else if (name === "Bash") detail = { type: "shell", command: move(str(input.command)), cwd };
+  return { type: "tool_call", callId: str(block.id), name, status: "running", detail };
+}
+
+/** Tool calls in a transcript, newest last, with each finished call marked done or failed. */
+export function transcriptItems(text: string, move: (value: string) => string, cwd: string) {
+  const items = new Map<string, Item>();
+  let finished = false;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let entry: Block;
+    try {
+      entry = JSON.parse(line) as Block;
+    } catch {
+      continue;
+    }
+    const message = (entry.message ?? {}) as Block;
+    const content = Array.isArray(message.content) ? (message.content as Block[]) : [];
+    if (entry.type === "assistant") {
+      finished = message.stop_reason === "end_turn" && !content.some((block) => block.type === "tool_use");
+    }
+    for (const block of content) {
+      if (block.type === "tool_use" && str(block.id)) items.set(str(block.id), toolItem(block, move, cwd));
+      const done = block.type === "tool_result" ? items.get(str(block.tool_use_id)) : undefined;
+      if (done) done.status = block.is_error ? "failed" : "completed";
+    }
+  }
+  return { items: [...items.values()].slice(-MAX_ITEMS), finished };
+}
+
+/** The newest subagents of a Claude session, with their tool calls. */
+export async function subagentLogs(sessionId: string, cwd: string): Promise<SubagentLog[]> {
+  const folder = await subagentFolder(sessionId, cwd);
+  if (!folder) return [];
+  const names = (await readdir(folder).catch(() => [])).filter((name) => /^agent-[A-Za-z0-9]+\.jsonl$/.test(name));
+  const dated = await Promise.all(
+    names.map(async (name) => ({ name, at: (await stat(path.join(folder, name)).catch(() => null))?.mtimeMs ?? 0 })),
+  );
+  const newest = dated.sort((a, b) => b.at - a.at).slice(0, MAX_RUNS);
+  const runs: SubagentLog[] = [];
+  for (const { name, at } of newest) {
+    const id = name.slice("agent-".length, -".jsonl".length);
+    const meta = JSON.parse(
+      (await readFile(path.join(folder, `agent-${id}.meta.json`), "utf8").catch(() => "{}")) || "{}",
+    ) as Block;
+    const worktree = str(meta.worktreePath).replace(/\/+$/, "");
+    // A subagent in its own worktree sees the same repository, so its paths map onto the agent's.
+    const move = (value: string) => (worktree ? value.split(worktree).join(cwd) : value);
+    const { items, finished } = transcriptItems(await tail(path.join(folder, name)).catch(() => ""), move, cwd);
+    runs.push({
+      id,
+      type: str(meta.agentType) || "Subagent",
+      description: str(meta.description),
+      toolUseId: str(meta.toolUseId) || null,
+      updatedAt: Math.round(at),
+      finished,
+      items,
+    });
+  }
+  return runs;
+}

package/shared/activity.ts

@@ -87,6 +87,10 @@ function lineCount(value: string | null): number {
 }
 
 function diffCounts(detail: Record<string, unknown>): { added: number; removed: number } {
+  // Subagent transcripts send counts, not the text.
+  if (typeof detail.added === "number") {
+    return { added: detail.added, removed: typeof detail.removed === "number" ? detail.removed : 0 };
+  }
   const diff = text(detail.unifiedDiff);
   if (diff) {
     let added = 0;
@@ -228,7 +232,7 @@ export function deriveActivity(items: readonly TimelineItemLike[], cwd: string):
       if (path) touch(path, "read", order).reads += 1;
     } else if ((detail.type === "edit" || detail.type === "write") && raw) {
       const write = detail.type === "write";
-      const counts = write
+      const counts = write && typeof detail.added !== "number"
         ? { added: lineCount(text(detail.content)), removed: 0 }
         : diffCounts(detail);
       event.kind = write ? "write" : "edit";

package/shared/agent-hooks.ts

@@ -0,0 +1,68 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { GuidanceSchema } from "./settings";
+
+// Claude Code hooks for an agent started from an issue. The daemon writes them as a Claude Code
+// plugin and the launch passes its folder with --plugin-dir, so they never replace the settings
+// Paseo itself passes with --settings. Each hook only prints text; none of them runs project code.
+
+export const IDENTIFIER = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+
+const HookIssueSchema = z.object({
+  identifier: z.string().regex(IDENTIFIER),
+  title: z.string(),
+  children: z.array(z.object({ identifier: z.string().regex(IDENTIFIER), title: z.string() })).max(100),
+});
+export type HookIssue = z.infer<typeof HookIssueSchema>;
+
+export const agentHooksRpc = defineRpc({
+  name: "linear.agent.hooks",
+  input: z.object({ issue: HookIssueSchema, guidance: GuidanceSchema }),
+  /** Null when no hook applies or the daemon host cannot run them. */
+  output: z.object({ pluginDir: z.string().nullable() }),
+});
+
+/** Single-quotes text for a POSIX shell. */
+export function shellQuote(text: string): string {
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function printHook(event: string, context: string) {
+  const output = { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+  return { type: "command", command: `printf '%s' ${shellQuote(JSON.stringify(output))}` };
+}
+
+function issueLines(issue: HookIssue): string[] {
+  const lines = [`Linear issue ${issue.identifier}: ${issue.title}`];
+  for (const child of issue.children.slice(0, 30)) lines.push(`- ${child.identifier}: ${child.title}`);
+  return lines;
+}
+
+/** The plugin's hooks.json, or null when no guidance option needs a hook. */
+export function claudeHooks(issue: HookIssue, guidance: z.infer<typeof GuidanceSchema>) {
+  const hooks: Record<string, unknown[]> = {};
+  if (guidance.subagentKeys) {
+    const context = [
+      `You are a subagent for ${issue.identifier}.`,
+      ...issueLines(issue),
+      "Put the key of the issue you work on in the first line of your reply, such as",
+      `"${issue.children[0]?.identifier ?? issue.identifier}: checked the form".`,
+      "If your work moves to another issue, state the new key.",
+    ].join("\n");
+    hooks.SubagentStart = [{ hooks: [printHook("SubagentStart", context)] }];
+  }
+  if (guidance.updateLinear || guidance.subagentKeys || guidance.paseoSubagents) {
+    // After compaction the summary can drop the issue, so restate it.
+    const context = [
+      `You work on ${issue.identifier}. The Linear rules in your first prompt still apply.`,
+      ...issueLines(issue),
+    ].join("\n");
+    hooks.SessionStart = [{ matcher: "compact", hooks: [printHook("SessionStart", context)] }];
+  }
+  return Object.keys(hooks).length > 0 ? { hooks } : null;
+}
+
+/** Claude Code plugin names are lowercase words joined by hyphens. */
+export function hookPluginName(identifier: string): string {
+  return `paseo-linear-${identifier.toLowerCase()}`;
+}

package/shared/agent-tools.ts

@@ -0,0 +1,130 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { IDENTIFIER } from "./agent-hooks";
+import type { IssueDetail } from "./linear";
+
+// The plugin's MCP server for agents started from an issue. It gives them Linear tools for
+// their issue tree and a way to start Paseo agents on its sub-issues. The daemon hosts it on
+// 127.0.0.1, and each agent gets its own bearer token.
+
+export const TOOLS_SERVER = "linear";
+/** Children get only the Linear tools, so agents never start agents of their own. */
+export const LINEAR_TOOLS = ["read_issue", "edit_issue"] as const;
+export const AGENT_TOOLS = ["start_agent", "wait_agent"] as const;
+
+export const McpHttpServerSchema = z.object({
+  type: z.literal("http"),
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
+export const ToolPolicySchema = z.object({
+  preapproved: z.array(z.object({ kind: z.literal("mcp"), server: z.string(), tool: z.string() })),
+});
+
+export const ToolScopeSchema = z.object({
+  /** The issue the launch started from. The tools reach it and its sub-issues. */
+  root: z.string().regex(IDENTIFIER),
+  /** The issue this agent works on, the default for read_issue and edit_issue. */
+  home: z.string().regex(IDENTIFIER),
+  /** The Paseo project whose Linear key loaded the issue. */
+  keyScope: z.string().nullable(),
+  workspaceId: z.string().min(1),
+  /** The agent config that started agents copy. */
+  config: z.object({
+    provider: z.string().min(1),
+    thinkingOptionId: z.string().optional(),
+    modeId: z.string().optional(),
+  }),
+});
+export type ToolScope = z.infer<typeof ToolScopeSchema>;
+
+export const agentToolsRpc = defineRpc({
+  name: "linear.agent.tools",
+  input: ToolScopeSchema,
+  output: z.object({
+    /** Goes in the agent's labels, so a tool call can find the agent that made it. */
+    grantId: z.string(),
+    server: McpHttpServerSchema,
+    toolPolicy: ToolPolicySchema,
+  }),
+});
+
+export function toolPolicy(tools: readonly string[]): z.infer<typeof ToolPolicySchema> {
+  return { preapproved: tools.map((tool) => ({ kind: "mcp" as const, server: TOOLS_SERVER, tool })) };
+}
+
+const IssueKey = z.string().regex(IDENTIFIER);
+
+export const ReadIssueInput = z.object({
+  issue: IssueKey.optional().describe("Issue key, such as ENG-12. The default is the issue you work on."),
+});
+
+export const EditIssueInput = z.object({
+  issue: IssueKey.optional().describe("Issue key, such as ENG-12. The default is the issue you work on."),
+  old_text: z
+    .string()
+    .describe("Exact text of the description to replace. It must occur one time. Use an empty string to add new_text at the end."),
+  new_text: z.string().describe("The text that replaces old_text."),
+});
+
+export const StartAgentInput = z.object({
+  issue: IssueKey.describe("Key of the sub-issue the agent works on."),
+  title: z.string().min(1).max(120).describe("Short title. Start it with the issue key."),
+  prompt: z.string().min(1).describe("The full task. The agent does not see your conversation."),
+  thinking: z
+    .string()
+    .optional()
+    .describe("Thinking option of the agent's model, such as low, medium, or high. The default is yours."),
+});
+
+export const WaitAgentInput = z.object({
+  agent_id: z.string().min(1),
+  timeout_seconds: z.number().int().min(1).max(600).default(50),
+});
+
+/** Replaces the one place where old text occurs. Empty old text adds the new text at the end. */
+export function editText(body: string, oldText: string, newText: string): { body: string } | { error: string } {
+  if (oldText === "") return { body: body.trimEnd() ? `${body.trimEnd()}\n\n${newText}` : newText };
+  const first = body.indexOf(oldText);
+  if (first < 0) return { error: "old_text is not in the description. Read the issue again, because it can change." };
+  if (body.indexOf(oldText, first + 1) >= 0) {
+    return { error: "old_text occurs more than one time. Add nearby lines so that it occurs one time." };
+  }
+  return { body: body.slice(0, first) + newText + body.slice(first + oldText.length) };
+}
+
+/** Counts Markdown task list items, so a reply can say how many are done. */
+export function taskCount(body: string): { done: number; total: number } {
+  const items = [...body.matchAll(/^\s*[-*+] \[([ xX])\]/gm)];
+  return { done: items.filter((item) => item[1] !== " ").length, total: items.length };
+}
+
+/** The issue as text for read_issue. */
+export function issueText(issue: IssueDetail): string {
+  const tasks = taskCount(issue.description ?? "");
+  const lines = [
+    `${issue.identifier}: ${issue.title}`,
+    `Status: ${issue.state.name}`,
+    `URL: ${issue.url}`,
+    tasks.total > 0 ? `Task list: ${tasks.done} of ${tasks.total} checked` : null,
+    "",
+    "Description:",
+    issue.description?.trim() || "(empty)",
+  ];
+  if (issue.children.length > 0) {
+    lines.push("", "Sub-issues:");
+    for (const child of issue.children) lines.push(`- ${child.identifier} [${child.state.name}]: ${child.title}`);
+  }
+  return lines.filter((line) => line !== null).join("\n");
+}
+
+/** Opens the prompt of an agent that start_agent makes. */
+export function childBrief(key: string, root: string): string {
+  const parent = key.toUpperCase() === root.toUpperCase() ? "" : `, a sub-issue of ${root}`;
+  return [
+    `You work on Linear issue ${key}${parent}. Start your first reply with "${key}:".`,
+    `Use the ${TOOLS_SERVER} MCP tools: read_issue shows the issue, and edit_issue changes its description.`,
+    "Check off each task list item you finish by replacing `- [ ]` with `- [x]`. Do not post comments.",
+  ].join("\n");
+}

package/shared/custom-icon.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+
+// The user's own plugin icon. The web app draws it as an image, which never runs scripts or
+// loads files; the checks below also refuse such content. Paint recolors every visible pixel,
+// and Solid fills shapes that only have an outline.
+
+export const ICON_PAINTS = ["original", "theme", "accent", "linear", "custom"] as const;
+export type IconPaint = (typeof ICON_PAINTS)[number];
+
+/** Linear's brand indigo, the plugin's own color. */
+export const LINEAR_INDIGO = "#5E6AD2";
+export const MAX_SVG_LENGTH = 64_000;
+export const HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+
+export const IconSettingsSchema = z.object({
+  /** Checked SVG markup. Empty uses the built-in icon. */
+  svg: z.string().max(MAX_SVG_LENGTH).default(""),
+  paint: z.enum(ICON_PAINTS).default("original"),
+  /** The color of the custom paint. */
+  color: z.string().regex(HEX_COLOR).default(LINEAR_INDIGO),
+  /** Fill shapes that only have an outline. */
+  solid: z.boolean().default(false),
+});
+export type IconSettings = z.infer<typeof IconSettingsSchema>;
+
+const BLOCKED: readonly (readonly [RegExp, string])[] = [
+  [/<!DOCTYPE|<!ENTITY/i, "The SVG has a DOCTYPE or entities. Export it again without them."],
+  [/<script[\s>/]/i, "The SVG has a script. Use an SVG with shapes only."],
+  [/<foreignObject[\s>/]/i, "The SVG has HTML content. Use an SVG with shapes only."],
+  [/<[^>]*\son[a-z]+\s*=/i, "The SVG has event handlers. Use an SVG with shapes only."],
+  [/[\s:]href\s*=\s*["']\s*(?!#)/i, "The SVG links to other files or images. Use an SVG that has all its shapes inside."],
+  [/url\(\s*["']?\s*(?!#)/i, "The SVG uses files outside it. Use an SVG that has all its shapes inside."],
+  [/@import/i, "The SVG imports styles from another file."],
+];
+
+const ROOT_TAG = /^<svg\b[^>]*>/i;
+const NUMBER = String.raw`(-?[\d.]+(?:e[-+]?\d+)?)`;
+const VIEW_BOX = new RegExp(String.raw`\sviewBox\s*=\s*["']\s*${NUMBER}[\s,]+${NUMBER}[\s,]+${NUMBER}[\s,]+${NUMBER}\s*["']`, "i");
+
+const attribute = (tag: string, name: string) =>
+  new RegExp(String.raw`\s${name}\s*=\s*["']([^"']*)["']`, "i").exec(tag)?.[1]?.trim() ?? null;
+const withoutAttribute = (tag: string, name: string) =>
+  tag.replace(new RegExp(String.raw`\s${name}\s*=\s*(?:"[^"]*"|'[^']*')`, "gi"), "");
+
+/** The root's viewBox as x, y, width, and height, or null without a usable one. */
+export function viewBoxOf(svg: string): [number, number, number, number] | null {
+  const root = ROOT_TAG.exec(svg)?.[0] ?? "";
+  const box = VIEW_BOX.exec(root)?.slice(1, 5).map(Number);
+  if (!box || box.some((value) => !Number.isFinite(value))) return null;
+  const [x = 0, y = 0, width = 0, height = 0] = box;
+  return width > 0 && height > 0 ? [x, y, width, height] : null;
+}
+
+/** Checks pasted or uploaded SVG and returns it ready to save, or why it cannot be used. */
+export function parseIconSvg(text: string): { svg: string } | { error: string } {
+  const svg = text
+    .replace(/^\uFEFF/, "")
+    .replace(/<\?[\s\S]*?\?>/g, "")
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .trim();
+  if (!svg) return { error: "Paste SVG markup or choose an SVG file." };
+  if (svg.length > MAX_SVG_LENGTH) {
+    return { error: `The SVG is too large. Use one under ${Math.round(MAX_SVG_LENGTH / 1000)} KB.` };
+  }
+  if (!/^<svg[\s>]/i.test(svg) || !/<\/svg>$/i.test(svg)) {
+    return { error: "This is not an SVG. It must start with <svg and end with </svg>." };
+  }
+  for (const [pattern, error] of BLOCKED) if (pattern.test(svg)) return { error };
+  const root = ROOT_TAG.exec(svg)?.[0] ?? "";
+  let next = root;
+  if (!viewBoxOf(svg)) {
+    const width = Number(/^([\d.]+)(?:px)?$/.exec(attribute(root, "width") ?? "")?.[1]);
+    const height = Number(/^([\d.]+)(?:px)?$/.exec(attribute(root, "height") ?? "")?.[1]);
+    if (!(width > 0 && height > 0)) return { error: "The SVG needs a viewBox, or a width and height in pixels." };
+    next = withoutAttribute(next, "viewBox").replace(/^<svg/i, `<svg viewBox="0 0 ${width} ${height}"`);
+  }
+  // The image scales to its box from the viewBox, so a fixed size would only crop it.
+  next = withoutAttribute(withoutAttribute(next, "width"), "height");
+  if (!/\sxmlns\s*=/.test(next)) next = next.replace(/^<svg/i, '<svg xmlns="http://www.w3.org/2000/svg"');
+  return { svg: next + svg.slice(root.length) };
+}
+
+/** Keeps a color inside an attribute value; anything else becomes gray. */
+export function safeColor(color: string): string {
+  return /^[#a-z0-9(),.%\s-]+$/i.test(color) ? color.trim() : "#888888";
+}
+
+const FILL_NONE = /(?<![\w-])(fill\s*:\s*)none\b/gi;
+
+/** Fills shapes that only have an outline, with their stroke color or the icon color. */
+export function fillOutlines(svg: string): string {
+  const tags = svg.replace(/<([a-z][\w:.-]*)(\s[^>]*?)?(\/?)>/gi, (tag, name: string, attrs: string | undefined, close: string) => {
+    if (!attrs) return tag;
+    const stroke = attribute(attrs, "stroke") ?? /(?<![\w-])stroke\s*:\s*([^;"']+)/i.exec(attrs)?.[1]?.trim();
+    const fill = stroke && stroke !== "none" ? stroke : "currentColor";
+    const next = attrs.replace(/(\sfill\s*=\s*["'])\s*none\s*(["'])/gi, `$1${fill}$2`).replace(FILL_NONE, `$1${fill}`);
+    return `<${name}${next}${close}>`;
+  });
+  return tags.replace(/(<style\b[^>]*>)([\s\S]*?)(<\/style>)/gi, (_all, open: string, css: string, end: string) =>
+    `${open}${css.replace(FILL_NONE, "$1currentColor")}${end}`,
+  );
+}
+
+const TINT_ID = "paseo-linear-tint";
+
+/** Paints every visible pixel one color and keeps its transparency. */
+export function tint(svg: string, color: string): string {
+  const [x, y, width, height] = viewBoxOf(svg) ?? [0, 0, 24, 24];
+  const filter =
+    `<filter id="${TINT_ID}" filterUnits="userSpaceOnUse" x="${x - width}" y="${y - height}" width="${width * 3}" height="${height * 3}" color-interpolation-filters="sRGB">` +
+    `<feFlood flood-color="${safeColor(color)}"/><feComposite in2="SourceAlpha" operator="in"/></filter>`;
+  return svg
+    .replace(ROOT_TAG, (root) => `${root}<defs>${filter}</defs><g filter="url(#${TINT_ID})">`)
+    .replace(/<\/svg>$/i, "</g></svg>");
+}
+
+export interface IconLook {
+  /** The color `currentColor` takes: the color Paseo gives the icon. */
+  ink: string;
+  /** One color for the whole icon, or null to keep its colors. */
+  paint: string | null;
+  solid: boolean;
+}
+
+/** The SVG to draw for saved markup, or null when it no longer passes the checks. */
+export function iconMarkup(saved: string, look: IconLook): string | null {
+  const parsed = parseIconSvg(saved);
+  if ("error" in parsed) return null;
+  const filled = look.solid ? fillOutlines(parsed.svg) : parsed.svg;
+  const inked = filled.replace(/currentColor/gi, safeColor(look.ink));
+  return look.paint ? tint(inked, look.paint) : inked;
+}
+
+/** The one color a paint gives, or null for the icon's own colors. */
+export function paintColor(icon: IconSettings, colors: { ink: string; accent: string }): string | null {
+  switch (icon.paint) {
+    case "original":
+      return null;
+    case "theme":
+      return colors.ink;
+    case "accent":
+      return colors.accent;
+    case "linear":
+      return LINEAR_INDIGO;
+    case "custom":
+      return icon.color;
+  }
+}

package/shared/graph-camera.ts

@@ -0,0 +1,93 @@
+import type { Point } from "./graph-geometry";
+import type { Graph } from "./graph-model";
+
+// The graph camera shifts and zooms the canvas, which scales around its center. A canvas
+// point p draws at center + shift + zoom * (p - center). Zoom 1 with no shift shows it all.
+
+export interface Camera {
+  x: number;
+  y: number;
+  zoom: number;
+}
+
+export interface Box {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+
+export const FIT: Camera = { x: 0, y: 0, zoom: 1 };
+export const MIN_ZOOM = 1;
+export const MAX_ZOOM = 4;
+/** Auto mode zooms no further than this, so the nodes around the agents stay in view. */
+const AUTO_ZOOM = 2.5;
+const PAD_X = 90;
+const PAD_Y = 56;
+
+const clamp = (value: number, low: number, high: number) => Math.min(high, Math.max(low, value));
+
+/** Where a canvas point draws in the view. */
+export function project(camera: Camera, at: Point, width: number, height: number): Point {
+  return {
+    x: width / 2 + camera.x + camera.zoom * (at.x - width / 2),
+    y: height / 2 + camera.y + camera.zoom * (at.y - height / 2),
+  };
+}
+
+/** The canvas point that draws at a point of the view. */
+export function unproject(camera: Camera, at: Point, width: number, height: number): Point {
+  return {
+    x: width / 2 + (at.x - width / 2 - camera.x) / camera.zoom,
+    y: height / 2 + (at.y - height / 2 - camera.y) / camera.zoom,
+  };
+}
+
+/** Keeps the zoom in range and the canvas edges at or past the edges of the view. */
+export function clampCamera(camera: Camera, width: number, height: number): Camera {
+  const zoom = clamp(camera.zoom, MIN_ZOOM, MAX_ZOOM);
+  const spanX = ((zoom - 1) * width) / 2;
+  const spanY = ((zoom - 1) * height) / 2;
+  return { zoom, x: clamp(camera.x, -spanX, spanX), y: clamp(camera.y, -spanY, spanY) };
+}
+
+/** Zooms by a factor and keeps the canvas point under `at` where it is. */
+export function zoomAt(camera: Camera, at: Point, factor: number, width: number, height: number): Camera {
+  const zoom = clamp(camera.zoom * factor, MIN_ZOOM, MAX_ZOOM);
+  const cx = width / 2;
+  const cy = height / 2;
+  const px = cx + (at.x - cx - camera.x) / camera.zoom;
+  const py = cy + (at.y - cy - camera.y) / camera.zoom;
+  return clampCamera({ zoom, x: at.x - cx - zoom * (px - cx), y: at.y - cy - zoom * (py - cy) }, width, height);
+}
+
+/** Shows the box as large as fits in the view, up to the auto zoom. */
+export function frameBox(box: Box, width: number, height: number): Camera {
+  const fit = Math.min(width / Math.max(1, box.right - box.left), height / Math.max(1, box.bottom - box.top));
+  const zoom = clamp(fit, MIN_ZOOM, AUTO_ZOOM);
+  const x = zoom * (width / 2 - (box.left + box.right) / 2);
+  const y = zoom * (height / 2 - (box.top + box.bottom) / 2);
+  return clampCamera({ zoom, x, y }, width, height);
+}
+
+// The area auto mode shows: the nodes the running agents work on and their neighbors, with
+// room for labels and cursors. Null when no agent works on a node other than the issue.
+export function focusBox(graph: Graph, positions: ReadonlyMap<string, Point>, targets: Iterable<string>): Box | null {
+  const ids = new Set<string>();
+  for (const target of targets) if (target !== graph.root) ids.add(target);
+  if (ids.size === 0) return null;
+  for (const edge of graph.edges) {
+    if (ids.has(edge.from) && edge.to !== graph.root) ids.add(edge.to);
+    else if (ids.has(edge.to) && edge.from !== graph.root) ids.add(edge.from);
+  }
+  let box: Box | null = null;
+  for (const id of ids) {
+    const at = positions.get(id);
+    if (!at) continue;
+    box = box
+      ? { left: Math.min(box.left, at.x), top: Math.min(box.top, at.y), right: Math.max(box.right, at.x), bottom: Math.max(box.bottom, at.y) }
+      : { left: at.x, top: at.y, right: at.x, bottom: at.y };
+  }
+  if (!box) return null;
+  return { left: box.left - PAD_X, top: box.top - PAD_Y, right: box.right + PAD_X, bottom: box.bottom + PAD_Y };
+}

package/shared/live.ts

@@ -1,5 +1,6 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
+import { McpHttpServerSchema, ToolPolicySchema } from "./agent-tools";
 import { IssueCardSchema, WorkflowStateSchema } from "./linear";
 
 // Contracts for Linear Live, todo sync, and project setup. Agents the plugin starts for itself
@@ -42,6 +43,8 @@ export const InitProposalSchema = z.object({
 });
 export type InitProposal = z.infer<typeof InitProposalSchema>;
 
+/** Files an explore run may list; the map and the graph show this many and more. */
+export const MAX_EXPLORE_FILES = 150;
 export const MAX_LIST_DIRS = 40;
 export const MAX_DIR_ENTRIES = 60;
 
@@ -64,6 +67,41 @@ export const linksRpc = defineRpc({
   }),
 });
 
+const SubagentLogSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  description: z.string(),
+  /** The parent's call that started it, when Claude recorded one. */
+  toolUseId: z.string().nullable(),
+  updatedAt: z.number(),
+  /** Its last reply ended the run. */
+  finished: z.boolean(),
+  items: z.array(
+    z.object({
+      type: z.literal("tool_call"),
+      callId: z.string(),
+      name: z.string(),
+      status: z.enum(["running", "completed", "failed"]),
+      detail: z.record(z.string(), z.unknown()),
+    }),
+  ),
+});
+export type SubagentLog = z.infer<typeof SubagentLogSchema>;
+
+/** Tool calls of the subagents an agent started inside its provider. */
+export const subagentLogsRpc = defineRpc({
+  name: "linear.live.subagents",
+  input: z.object({ agentId: z.string().min(1) }),
+  output: z.object({ runs: z.array(SubagentLogSchema) }),
+});
+
+/** Forgets the saved explore map of the agent's issue, so the map falls back to ticket text. */
+export const clearMapRpc = defineRpc({
+  name: "linear.live.map.clear",
+  input: z.object({ agentId: z.string().min(1) }),
+  output: z.object({ cleared: z.boolean() }),
+});
+
 export const liveMapRpc = defineRpc({
   name: "linear.live.map",
   input: z.object({ identifier: z.string().min(1) }),
@@ -80,6 +118,11 @@ export const LaunchConfigSchema = z.object({
   provider: z.string().min(1),
   thinkingOptionId: z.string().optional(),
   modeId: z.string().optional(),
+  /** Only the folder of the issue's Claude Code hooks; see agent-hooks.ts. */
+  providerOptions: z.object({ extraArgs: z.object({ "plugin-dir": z.string().min(1) }) }).optional(),
+  /** Only the plugin's own MCP server; see agent-tools.ts. */
+  mcpServers: z.object({ linear: McpHttpServerSchema }).optional(),
+  toolPolicy: ToolPolicySchema.optional(),
 });
 
 // The daemon maps the files first and then starts the agent, so closing the app mid-way