@google/jules-fleet 0.0.1-experimental.0

package/dist/cli/analyze.command.mjs

@@ -0,0 +1,1015 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/analyze.command.ts
+import { defineCommand } from "citty";
+
+// src/analyze/spec.ts
+import { z } from "zod";
+var AnalyzeInputSchema = z.object({
+  goal: z.string().optional(),
+  goalsDir: z.string().default(".fleet/goals"),
+  milestone: z.string().optional(),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  baseBranch: z.string().default("main")
+});
+var AnalyzeErrorCode = z.enum([
+  "GOAL_NOT_FOUND",
+  "NO_GOALS_FOUND",
+  "MILESTONE_FETCH_FAILED",
+  "SESSION_DISPATCH_FAILED",
+  "UNKNOWN_ERROR"
+]);
+
+// src/analyze/handler.ts
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { basename } from "path";
+import { globSync } from "glob";
+
+// src/shared/result/create-result-schemas.ts
+import { z as z2 } from "zod";
+// src/shared/result/ok.ts
+function ok(data) {
+  return { success: true, data };
+}
+// src/shared/result/fail.ts
+function fail(code, message, recoverable = false, suggestion) {
+  return {
+    success: false,
+    error: { code, message, recoverable, suggestion }
+  };
+}
+// src/analyze/goals.ts
+import { readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+function parseGoalFile(filePath) {
+  const raw = readFileSync(filePath, "utf-8");
+  return parseGoalContent(raw);
+}
+function parseGoalContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    return { config: {}, body: trimmed };
+  }
+  const closingIndex = trimmed.indexOf(`
+---`, 3);
+  if (closingIndex === -1) {
+    return { config: {}, body: trimmed };
+  }
+  const frontmatterRaw = trimmed.slice(4, closingIndex).trim();
+  const body = trimmed.slice(closingIndex + 4).trim();
+  const parsed = frontmatterRaw ? parseYaml(frontmatterRaw) ?? {} : {};
+  return {
+    config: {
+      milestone: parsed.milestone?.toString()
+    },
+    body
+  };
+}
+
+// src/analyze/milestone.ts
+var IGNORE_LABEL = "status: ignore";
+function isTargetIssue(issue) {
+  if (issue.pull_request)
+    return false;
+  const hasIgnoreLabel = issue.labels?.some((label) => {
+    const labelName = typeof label === "string" ? label : label.name;
+    return labelName === IGNORE_LABEL;
+  });
+  return !hasIgnoreLabel;
+}
+function toMilestoneIssue(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    state: raw.state,
+    labels: (raw.labels ?? []).map((l) => typeof l === "string" ? l : l.name),
+    body: raw.body ?? "",
+    createdAt: raw.created_at,
+    closedAt: raw.closed_at ?? undefined
+  };
+}
+function toPullRequest(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    head: raw.head.ref,
+    base: raw.base.ref,
+    body: raw.body ?? ""
+  };
+}
+async function getMilestoneContext(octokit, options) {
+  const { owner, repo, milestone, closedLookbackDays = 14 } = options;
+  let milestoneInfo;
+  if (milestone) {
+    const { data } = await octokit.rest.issues.getMilestone({
+      owner,
+      repo,
+      milestone_number: parseInt(milestone, 10)
+    });
+    milestoneInfo = { number: data.number, title: data.title };
+  }
+  const apiMilestoneFilter = milestone || "none";
+  const { data: openRaw } = await octokit.rest.issues.listForRepo({
+    owner,
+    repo,
+    state: "open",
+    milestone: apiMilestoneFilter,
+    per_page: 100
+  });
+  const since = new Date;
+  since.setDate(since.getDate() - closedLookbackDays);
+  const { data: closedRaw } = await octokit.rest.issues.listForRepo({
+    owner,
+    repo,
+    state: "closed",
+    milestone: apiMilestoneFilter,
+    since: since.toISOString(),
+    per_page: 100
+  });
+  const { data: openPRs } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    per_page: 100
+  });
+  return {
+    milestone: milestoneInfo,
+    issues: {
+      open: openRaw.filter(isTargetIssue).map(toMilestoneIssue),
+      closed: closedRaw.filter(isTargetIssue).map(toMilestoneIssue)
+    },
+    pullRequests: openPRs.map(toPullRequest)
+  };
+}
+
+// src/analyze/formatting.ts
+function toIssueMarkdown(issue) {
+  const lines = [
+    `## #${issue.number}: ${issue.title}`,
+    ``,
+    `| Field | Value |`,
+    `|-------|-------|`,
+    `| **State** | ${issue.state}${issue.closedAt ? ` (closed ${issue.closedAt})` : ""} |`,
+    `| **Labels** | ${issue.labels.map((l) => `\`${l}\``).join(", ") || "none"} |`,
+    `| **Created** | ${issue.createdAt} |`
+  ];
+  if (issue.closedAt) {
+    lines.push(`| **Closed** | ${issue.closedAt} |`);
+  }
+  lines.push(``);
+  if (issue.body) {
+    lines.push(`### Description`, ``, issue.body.trim(), ``);
+  }
+  lines.push(`---`, ``);
+  return lines.join(`
+`);
+}
+function formatPRContext(pr) {
+  const fixesPattern = /(?:fixes|closes|resolves)\s+#(\d+)/gi;
+  const linkedIssues = [];
+  let match;
+  while ((match = fixesPattern.exec(pr.body || "")) !== null) {
+    linkedIssues.push(`#${match[1]}`);
+  }
+  const links = linkedIssues.length > 0 ? ` → Fixes ${linkedIssues.join(", ")}` : "";
+  return `- PR #${pr.number}: ${pr.title}${links}
+  Head: ${pr.head || "?"} → Base: ${pr.base || "?"}
+`;
+}
+
+// src/analyze/prompt.ts
+var SYSTEM_PREAMBLE = `You are a senior software architect performing a rigorous code analysis against a set of goal directives. Your job is to identify gaps and create GitHub issues for each actionable task.`;
+var DEDUP_RULES = `**Deduplication Rules (MANDATORY):**
+1. **Closed Issue = Work Already Done.** Do NOT recreate issues that have been closed.
+2. **Open Issue = Work In Progress.** Someone is already handling it. Do NOT create a duplicate.
+3. **PR with "Fixes #N" = Issue Being Resolved.** If a PR references an issue, that issue is handled. Do NOT create a new issue for the same thing.
+4. **When in doubt, skip it.** It is better to miss a real gap than to create a duplicate that wastes engineering time.`;
+var PHASE_0_VERIFY = `### Phase 0: Reality Verification
+Before planning new tasks, verify the current state of the repository against your goal directives.
+
+The full details of every open and recently closed issue are provided above in "Historical Context (The Map)". Read each issue's **Objective** and **Proposed Implementation** sections carefully to understand what work is already planned or completed.
+
+Then, inspect the actual source files to confirm whether the required changes or architectural gaps currently exist. Cross-reference your findings with both the Open and Recently Closed Issues to ensure the work has not already been completed or is not already tracked.
+
+Proceed to Phase 1 exclusively for gaps that are:
+1. Demonstrably present in the live codebase today, AND
+2. Not already covered by an existing open issue's Objective.`;
+var PHASE_1_INVESTIGATE = `### Phase 1: Investigate
+Trace identified gaps directly to their source in the codebase. Produce a code-level diagnosis.
+
+For every identified issue, you must:
+1. **Identify the exact code path:** Map the execution flow referencing specific files, functions, and line ranges.
+2. **Explain the mechanism:** Show the relevant code snippet from the existing codebase and annotate exactly where the logic diverges from the goal directives.
+3. **Determine the root cause:** Classify the gap (e.g., architectural mismatch, schema update, missing logic).`;
+var PHASE_2_ARCHITECT = `### Phase 2: Architect
+Design a concrete, production-ready solution for each root cause.
+
+For each solution, you must provide:
+1. **Proposed Implementation:** Write the actual TypeScript/code demonstrating the solution. Include function signatures, interfaces, and logic.
+2. **Integration Points:** Detail exactly where in the existing code this gets wired in, using before/after diffs to show the structural changes.
+3. **Edge Cases:** Identify assumptions and define fallback behaviors.
+4. **Test Scenarios:** Define specific test cases, inputs, and expected outputs that validate the fix.`;
+var PHASE_3_PLAN = `### Phase 3: Plan (Coupling & Boundary Analysis)
+Evaluate the exact file requirements for each architectural solution to define strict boundaries for the downstream worker agents.
+
+1. **Coupling Analysis:** Map all implicitly coupled files. Identify test files that exercise the modified code, barrel exports (\`index.ts\`), and shared utilities.
+2. **File Ownership & Locking:** The downstream Orchestrator prevents merge conflicts by locking files at runtime. You must exhaustively list every single file (source, test, and utility) the worker agent needs to touch.
+3. **Task Sizing:** Keep tasks strictly isolated by functional domain. You may assign the same core file (e.g., \`types.ts\`) to multiple tasks; the Orchestrator will sequence them automatically based on your exhaustive file list.`;
+var PHASE_4_DISPATCH_HEALTHY = `**Path A: System Healthy Protocol**
+If your Phase 0 verification confirms that the codebase already satisfies the goal directives and no actionable work remains, formulate a comprehensive "Fleet Status: Goal Currently Satisfied" report. Detail exactly which domains, files, and logic paths you verified to reach this conclusion. Output this markdown report and exit gracefully, bypassing the issue creation step entirely. Preserve the repository's current state by creating issues only when substantial, goal-aligned engineering work is required.`;
+var PHASE_4_DISPATCH_ISSUES = `**Path B: Task Dispatch Protocol**
+For EACH validated task that requires execution, perform a **Deduplication Check** before creating an issue:
+
+1. Compare your proposed task's scope against EVERY open issue in the Historical Context above.
+2. If an existing open issue's **Objective** already covers the same gap (even partially or under a different name), **do NOT create a new issue**. Instead, note the overlap in your report and skip creation.
+3. Only create an issue for gaps that are genuinely novel — not covered by any existing open issue.
+
+For each non-duplicate task, create a signal using the \`jules-fleet signal create\` command.`;
+var ISSUE_BODY_TEMPLATE = `\`\`\`markdown
+### Objective
+[2-3 sentences explaining the functional goal of this isolated task]
+
+### Code-Level Diagnosis
+**Code path:** [e.g., \`src/session.ts → fetch()\`]
+**Mechanism:** [Explanation of the current state]
+**Root cause:** [Summary of the architectural gap]
+
+#### Current Implementation
+\\\`\\\`\\\`typescript
+// [Insert exact snippet from current codebase showing the logic to be changed]
+\\\`\\\`\\\`
+
+### Proposed Implementation
+**Files to modify:** [Brief summary of structural changes]
+
+#### Integration (Before → After)
+\\\`\\\`\\\`diff
+// [Insert precise diffs showing how the new logic integrates]
+\\\`\\\`\\\`
+
+### Test Scenarios
+1. [Scenario 1: Input -> Expected Output]
+2. [Scenario 2: Input -> Expected Output]
+
+### Target Files
+- [exact/path/to/source1.ts]
+- [exact/path/to/source2.ts]
+- [exact/path/to/test1.test.ts]
+
+### Boundary Rules
+Restrict your modifications exclusively to the files listed in the Target Files section. Ensure your source changes are entirely backward-compatible if unowned tests outside your boundary fail. Retain all existing file names and locations outside your explicitly declared target list.
+\`\`\``;
+function buildAnalyzerPrompt(options) {
+  const {
+    goalInstructions,
+    openContext,
+    closedContext,
+    prContext,
+    milestoneTitle
+  } = options;
+  const prSection = prContext ? `
+**Recent Pull Requests (shows what code changes are in flight or merged):**
+${prContext}
+` : "";
+  const milestoneFlag = milestoneTitle ? ` \\
+  --scope "${milestoneTitle}"` : "";
+  const cliFormat = `**Signal creation formats:**
+
+**Assessment** (actionable — requires code changes):
+\`\`\`bash
+jules-fleet signal create \\
+  --kind assessment \\
+  --title "[Fleet Execution] <Highly Specific Domain Task Title>" \\
+  --tag fleet \\
+  --body-file <path_to_markdown_file>${milestoneFlag}
+\`\`\`
+
+**Insight** (informational — no action required):
+\`\`\`bash
+jules-fleet signal create \\
+  --kind insight \\
+  --title "<Descriptive Finding>" \\
+  --tag fleet \\
+  --body-file <path_to_markdown_file>${milestoneFlag}
+\`\`\``;
+  return [
+    SYSTEM_PREAMBLE,
+    "",
+    `## Your Goal & Directives`,
+    goalInstructions,
+    "",
+    `---`,
+    "",
+    `## Historical Context (The Map)`,
+    "",
+    `The following are the **full details** of every issue in the milestone. Use these to understand the exact scope of existing and completed work. You MUST cross-reference your findings against these issues to avoid creating duplicates.`,
+    "",
+    DEDUP_RULES,
+    "",
+    `**Open Issues:**`,
+    openContext,
+    "",
+    `**Recently Closed Issues (Last 14 Days — these are COMPLETED, do not recreate):**`,
+    closedContext,
+    prSection,
+    `---`,
+    "",
+    `## Your Methodology`,
+    "",
+    `Perform a rigorous multi-phase analysis: **Verify**, **Investigate**, **Architect**, **Plan**, and **Dispatch**.`,
+    "",
+    PHASE_0_VERIFY,
+    "",
+    PHASE_1_INVESTIGATE,
+    "",
+    PHASE_2_ARCHITECT,
+    "",
+    PHASE_3_PLAN,
+    "",
+    `### Phase 4: Dispatch (Issue Creation or Goal Validation)`,
+    `Translate your analysis into independent signals using \`jules-fleet signal create\`, or provide a clean bill of health.`,
+    "",
+    PHASE_4_DISPATCH_HEALTHY,
+    "",
+    PHASE_4_DISPATCH_ISSUES,
+    "",
+    cliFormat,
+    "",
+    `**Required Issue Body Format:**`,
+    `The issue body MUST follow this exact markdown structure to ensure the worker agent and the Orchestrator function correctly:`,
+    "",
+    ISSUE_BODY_TEMPLATE
+  ].join(`
+`);
+}
+
+// src/analyze/triage-prompt.ts
+var TRIAGE_GOAL_FILENAME = "triage.md";
+function getBuiltInTriagePrompt(repoFullName) {
+  return `# Triage
+
+Triage all open issues in **${repoFullName}** that are not assigned to a milestone.
+For each, determine actionability, root cause, priority, and grouping potential.
+
+## Insight Hints
+- For non-actionable issues, report them as insights with the reason they
+  were skipped and the suggested owner.
+
+## Constraints
+- Only create signals for work that does NOT already have an open issue or recent PR.
+- Every assessment must include a \`Target Files\` section listing the exact files a worker agent should modify.
+- Keep tasks small and isolated — one logical change per issue.
+- Apply the \`fleet\` tag to every created signal.
+- If multiple issues share the same root cause or touch the same files, group them into a single task to avoid merge conflicts.
+`;
+}
+
+// src/analyze/handler.ts
+class AnalyzeHandler {
+  octokit;
+  dispatcher;
+  emit;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.dispatcher = deps.dispatcher;
+    this.emit = deps.emit ?? (() => {});
+  }
+  async execute(input) {
+    try {
+      const goalFiles = this.resolveGoalFiles(input);
+      if (goalFiles.length === 0) {
+        return fail("NO_GOALS_FOUND", `No goal files found in ${input.goalsDir}/`, true, "Create a .md file in .fleet/goals/ or pass --goal <path>");
+      }
+      this.emit({
+        type: "analyze:start",
+        owner: input.owner,
+        repo: input.repo,
+        goalCount: goalFiles.length
+      });
+      const sessionsStarted = [];
+      for (let i = 0;i < goalFiles.length; i++) {
+        const goalFile = goalFiles[i];
+        const result = await this.processGoal(goalFile, input, i + 1, goalFiles.length);
+        if (result) {
+          sessionsStarted.push(result);
+        }
+      }
+      this.emit({
+        type: "analyze:done",
+        sessionsStarted: sessionsStarted.length,
+        goalsProcessed: goalFiles.length
+      });
+      return ok({ sessionsStarted });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+  resolveGoalFiles(input) {
+    if (input.goal) {
+      if (!existsSync(input.goal)) {
+        return [];
+      }
+      return [input.goal];
+    }
+    const userGoals = globSync(`${input.goalsDir}/*.md`);
+    const hasUserTriage = userGoals.some((f) => basename(f) === TRIAGE_GOAL_FILENAME);
+    if (!hasUserTriage) {
+      userGoals.push(`__builtin__:${TRIAGE_GOAL_FILENAME}`);
+    }
+    return userGoals;
+  }
+  async processGoal(goalFile, input, index, total) {
+    const isBuiltIn = goalFile.startsWith("__builtin__:");
+    let goal;
+    let goalInstructions;
+    if (isBuiltIn) {
+      const repoFullName = `${input.owner}/${input.repo}`;
+      goalInstructions = getBuiltInTriagePrompt(repoFullName);
+      goal = parseGoalContent(goalInstructions);
+    } else {
+      goal = parseGoalFile(goalFile);
+      goalInstructions = readFileSync2(goalFile, "utf-8");
+    }
+    const displayName = isBuiltIn ? `triage.md (built-in)` : basename(goalFile);
+    const milestoneId = input.milestone ?? goal.config?.milestone?.toString();
+    this.emit({
+      type: "analyze:goal:start",
+      file: displayName,
+      index,
+      total,
+      milestone: milestoneId
+    });
+    const ctx = await getMilestoneContext(this.octokit, {
+      owner: input.owner,
+      repo: input.repo,
+      milestone: milestoneId
+    });
+    if (ctx.milestone?.title) {
+      this.emit({
+        type: "analyze:milestone:resolved",
+        title: ctx.milestone.title,
+        id: milestoneId
+      });
+    }
+    this.emit({
+      type: "analyze:context:fetched",
+      openIssues: ctx.issues.open.length,
+      closedIssues: ctx.issues.closed.length,
+      prs: ctx.pullRequests.length
+    });
+    const openContext = ctx.issues.open.map(toIssueMarkdown).join(`
+`) || "None.";
+    const closedContext = ctx.issues.closed.map(toIssueMarkdown).join(`
+`) || "None.";
+    const prContext = ctx.pullRequests.map(formatPRContext).join(`
+`) || "None.";
+    const prompt = buildAnalyzerPrompt({
+      goalInstructions,
+      openContext,
+      closedContext,
+      prContext,
+      milestoneTitle: ctx.milestone?.title,
+      milestoneId
+    });
+    this.emit({ type: "analyze:session:dispatching", goal: displayName });
+    try {
+      const session = await this.dispatcher.dispatch({
+        prompt,
+        source: {
+          github: `${input.owner}/${input.repo}`,
+          baseBranch: input.baseBranch
+        },
+        requireApproval: false,
+        autoPr: false
+      });
+      this.emit({
+        type: "analyze:session:started",
+        id: session.id,
+        goal: displayName
+      });
+      return { goal: goalFile, sessionId: session.id };
+    } catch (error) {
+      this.emit({
+        type: "analyze:session:failed",
+        goal: displayName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+}
+
+// src/shared/auth/octokit.ts
+import { Octokit } from "octokit";
+import { createAppAuth } from "@octokit/auth-app";
+
+// src/shared/auth/cache-plugin.ts
+function cachePlugin(octokit) {
+  const cache = new Map;
+  octokit.hook.wrap("request", async (request, options) => {
+    const key = `${options.method} ${options.url}`;
+    const cached = cache.get(key);
+    if (cached) {
+      options.headers = {
+        ...options.headers,
+        "if-none-match": cached.etag
+      };
+    }
+    try {
+      const response = await request(options);
+      const etag = response.headers.etag;
+      if (etag) {
+        cache.set(key, { etag, data: response.data });
+      }
+      return response;
+    } catch (error) {
+      if (error.status === 304 && cached) {
+        return { ...error.response, data: cached.data, status: 200 };
+      }
+      throw error;
+    }
+  });
+}
+
+// src/shared/auth/resolve-key.ts
+function resolvePrivateKey(base64Value, rawValue) {
+  if (base64Value) {
+    return Buffer.from(base64Value, "base64").toString("utf-8");
+  }
+  if (rawValue) {
+    return rawValue.replace(/\\n/g, `
+`);
+  }
+  throw new Error("No private key provided. Set GITHUB_APP_PRIVATE_KEY_BASE64 (recommended) or GITHUB_APP_PRIVATE_KEY.");
+}
+
+// src/shared/auth/octokit.ts
+var CachedOctokit = Octokit.plugin(cachePlugin);
+function getAuthOptions() {
+  const appId = process.env.GITHUB_APP_ID;
+  const privateKeyBase64 = process.env.GITHUB_APP_PRIVATE_KEY_BASE64;
+  const privateKeyRaw = process.env.GITHUB_APP_PRIVATE_KEY;
+  const installationId = process.env.GITHUB_APP_INSTALLATION_ID;
+  if (appId && (privateKeyBase64 || privateKeyRaw) && installationId) {
+    return {
+      authStrategy: createAppAuth,
+      auth: {
+        appId,
+        privateKey: resolvePrivateKey(privateKeyBase64, privateKeyRaw),
+        installationId: Number(installationId)
+      }
+    };
+  }
+  const token = process.env.GITHUB_TOKEN;
+  if (token) {
+    return { auth: token };
+  }
+  throw new Error("GitHub auth not configured. Set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID for App auth, or GITHUB_TOKEN for PAT auth.");
+}
+function createFleetOctokit() {
+  return new CachedOctokit(getAuthOptions());
+}
+
+// src/shared/auth/git.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function getGitRepoInfo(remoteName = "origin") {
+  const ghRepo = process.env.GITHUB_REPOSITORY;
+  if (ghRepo) {
+    const [owner, repo] = ghRepo.split("/");
+    return { owner, repo, fullName: ghRepo };
+  }
+  const { stdout } = await execAsync(`git remote get-url ${remoteName}`);
+  return parseGitRemoteUrl(stdout.trim());
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/(.+?)(\.git)?$/);
+  if (sshMatch) {
+    const [, owner, repo] = sshMatch;
+    return {
+      owner,
+      repo: repo.replace(/\.git$/, ""),
+      fullName: `${owner}/${repo.replace(/\.git$/, "")}`
+    };
+  }
+  const httpsMatch = remoteUrl.match(/https?:\/\/github\.com\/([^/]+)\/(.+?)(\.git)?$/);
+  if (httpsMatch) {
+    const [, owner, repo] = httpsMatch;
+    return {
+      owner,
+      repo: repo.replace(/\.git$/, ""),
+      fullName: `${owner}/${repo.replace(/\.git$/, "")}`
+    };
+  }
+  throw new Error(`Unable to parse git remote URL: ${remoteUrl}`);
+}
+
+// src/shared/ui/interactive.ts
+import * as p from "@clack/prompts";
+
+// src/shared/ui/render/init.ts
+function renderInitEvent(event, ctx) {
+  switch (event.type) {
+    case "init:start":
+      ctx.info(`Initializing fleet for ${event.owner}/${event.repo}`);
+      break;
+    case "init:branch:creating":
+      ctx.startSpinner(`Creating branch ${event.name} from ${event.base}`);
+      break;
+    case "init:branch:created":
+      ctx.stopSpinner(`Branch ${event.name} created`);
+      break;
+    case "init:file:committed":
+      ctx.info(`  ✓ ${event.path}`);
+      break;
+    case "init:file:skipped":
+      ctx.warn(`  ⊘ ${event.path} — ${event.reason}`);
+      break;
+    case "init:pr:creating":
+      ctx.startSpinner("Creating pull request…");
+      break;
+    case "init:pr:created":
+      ctx.stopSpinner(`PR #${event.number} created`);
+      ctx.info(`  ${event.url}`);
+      break;
+    case "init:done":
+      ctx.success(`Fleet initialized — PR: ${event.prUrl}`);
+      break;
+    case "init:auth:detected":
+      ctx.success(`Auth: ${event.method === "token" ? "GITHUB_TOKEN" : "GitHub App"}`);
+      break;
+    case "init:secret:uploading":
+      ctx.startSpinner(`Uploading secret ${event.name}…`);
+      break;
+    case "init:secret:uploaded":
+      ctx.stopSpinner(`Secret ${event.name} saved`);
+      break;
+    case "init:secret:skipped":
+      ctx.warn(`  ⊘ ${event.name} — ${event.reason}`);
+      break;
+    case "init:dry-run":
+      ctx.info("Would create:");
+      event.files.forEach((f) => ctx.message(`  ${f}`));
+      break;
+    case "init:already-initialized":
+      ctx.warn("Repository is already initialized");
+      break;
+  }
+}
+
+// src/shared/ui/render/configure.ts
+function renderConfigureEvent(event, ctx) {
+  switch (event.type) {
+    case "configure:start":
+      ctx.info(`Configuring ${event.resource} for ${event.owner}/${event.repo}`);
+      break;
+    case "configure:label:created":
+      ctx.info(`  ✓ Label "${event.name}" created`);
+      break;
+    case "configure:label:exists":
+      ctx.warn(`  ⊘ Label "${event.name}" already exists`);
+      break;
+    case "configure:secret:uploading":
+      ctx.startSpinner(`Uploading secret ${event.name}…`);
+      break;
+    case "configure:secret:uploaded":
+      ctx.stopSpinner(`Secret ${event.name} uploaded`);
+      break;
+    case "configure:done":
+      ctx.success("Configuration complete");
+      break;
+  }
+}
+
+// src/shared/ui/session-url.ts
+var JULES_BASE_URL = "https://jules.google.com";
+function sessionUrl(sessionId) {
+  return `${JULES_BASE_URL}/sessions/${sessionId}`;
+}
+
+// src/shared/ui/render/analyze.ts
+function renderAnalyzeEvent(event, ctx) {
+  switch (event.type) {
+    case "analyze:start":
+      ctx.info(`Analyzing ${event.goalCount} goal(s) for ${event.owner}/${event.repo}`);
+      break;
+    case "analyze:goal:start":
+      if (event.total > 1) {
+        ctx.step(`[${event.index}/${event.total}] ${event.file}`);
+      } else {
+        ctx.step(event.file);
+      }
+      if (event.milestone)
+        ctx.info(`  Milestone: ${event.milestone}`);
+      break;
+    case "analyze:milestone:resolved":
+      ctx.info(`  Milestone "${event.title}" (#${event.id})`);
+      break;
+    case "analyze:context:fetched":
+      ctx.info(`  Context: ${event.openIssues} open, ${event.closedIssues} closed, ${event.prs} PRs`);
+      break;
+    case "analyze:session:dispatching":
+      ctx.startSpinner(`Dispatching session for ${event.goal}…`);
+      break;
+    case "analyze:session:started":
+      ctx.stopSpinner(`Session started: ${event.id}`);
+      ctx.info(`  ${sessionUrl(event.id)}`);
+      break;
+    case "analyze:session:failed":
+      ctx.stopSpinner();
+      ctx.error(`  Failed: ${event.error}`);
+      break;
+    case "analyze:done":
+      ctx.success(`Analysis complete — ${event.sessionsStarted} session(s) from ${event.goalsProcessed} goal(s)`);
+      break;
+  }
+}
+
+// src/shared/ui/render/dispatch.ts
+function renderDispatchEvent(event, ctx) {
+  switch (event.type) {
+    case "dispatch:start":
+      ctx.info(`Dispatching from milestone ${event.milestone}`);
+      break;
+    case "dispatch:scanning":
+      ctx.startSpinner("Scanning for fleet issues…");
+      break;
+    case "dispatch:found":
+      ctx.stopSpinner(`Found ${event.count} undispatched issue(s)`);
+      break;
+    case "dispatch:issue:dispatching":
+      ctx.startSpinner(`#${event.number}: ${event.title}`);
+      break;
+    case "dispatch:issue:dispatched":
+      ctx.stopSpinner(`#${event.number} → session ${event.sessionId}`);
+      ctx.info(`  ${sessionUrl(event.sessionId)}`);
+      break;
+    case "dispatch:issue:skipped":
+      ctx.warn(`  ⊘ #${event.number}: ${event.reason}`);
+      break;
+    case "dispatch:done":
+      ctx.success(`Dispatch complete — ${event.dispatched} dispatched, ${event.skipped} skipped`);
+      break;
+  }
+}
+
+// src/shared/ui/render/merge.ts
+function renderMergeEvent(event, ctx) {
+  switch (event.type) {
+    case "merge:start":
+      ctx.info(`Merging ${event.prCount} PR(s) in ${event.owner}/${event.repo} [${event.mode}]`);
+      break;
+    case "merge:no-prs":
+      ctx.info("No PRs ready to merge.");
+      break;
+    case "merge:pr:processing":
+      ctx.startSpinner(`PR #${event.number}: ${event.title}${event.retry ? ` (retry ${event.retry})` : ""}`);
+      break;
+    case "merge:branch:updating":
+      ctx.startSpinner(`Updating branch for PR #${event.prNumber}…`);
+      break;
+    case "merge:branch:updated":
+      ctx.stopSpinner(`Branch updated for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:waiting":
+      ctx.startSpinner(`Waiting for CI on PR #${event.prNumber}…`);
+      break;
+    case "merge:ci:check": {
+      const icon = event.status === "pass" ? "✓" : event.status === "fail" ? "✗" : "…";
+      const dur = event.duration ? ` (${event.duration}s)` : "";
+      ctx.info(`  ${icon} ${event.name}${dur}`);
+      break;
+    }
+    case "merge:ci:passed":
+      ctx.stopSpinner(`CI passed for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:failed":
+      ctx.stopSpinner(`CI failed for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:timeout":
+      ctx.stopSpinner(`CI timed out for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:none":
+      ctx.stopSpinner(`No CI checks for PR #${event.prNumber}`);
+      break;
+    case "merge:pr:merging":
+      ctx.startSpinner(`Merging PR #${event.prNumber}…`);
+      break;
+    case "merge:pr:merged":
+      ctx.stopSpinner(`PR #${event.prNumber} merged ✓`);
+      break;
+    case "merge:pr:skipped":
+      ctx.warn(`  ⊘ PR #${event.prNumber}: ${event.reason}`);
+      break;
+    case "merge:conflict:detected":
+      ctx.stopSpinner(`Conflict detected on PR #${event.prNumber}`);
+      break;
+    case "merge:redispatch:start":
+      ctx.startSpinner(`Re-dispatching PR #${event.oldPr}…`);
+      break;
+    case "merge:redispatch:waiting":
+      ctx.startSpinner(`Waiting for re-dispatched PR (was #${event.oldPr})…`);
+      break;
+    case "merge:redispatch:done":
+      ctx.stopSpinner(`Re-dispatched: #${event.oldPr} → #${event.newPr}`);
+      break;
+    case "merge:done":
+      ctx.success(`Merge complete — ${event.merged.length} merged, ${event.skipped.length} skipped`);
+      break;
+  }
+}
+
+// src/shared/ui/render/error.ts
+function renderErrorEvent(event, ctx) {
+  ctx.stopSpinner();
+  ctx.error(`[${event.code}] ${event.message}`);
+  if (event.suggestion)
+    ctx.info(`  \uD83D\uDCA1 ${event.suggestion}`);
+}
+
+// src/shared/ui/interactive.ts
+class InteractiveRenderer {
+  spinner = null;
+  ctx = {
+    info: (msg) => p.log.info(msg),
+    success: (msg) => p.log.success(msg),
+    warn: (msg) => p.log.warn(msg),
+    error: (msg) => p.log.error(msg),
+    message: (msg) => p.log.message(msg),
+    step: (msg) => p.log.step(msg),
+    startSpinner: (msg) => this.startSpinner(msg),
+    stopSpinner: (msg) => this.stopSpinner(msg)
+  };
+  start(title) {
+    p.intro(title);
+  }
+  end(message) {
+    this.stopSpinner();
+    p.outro(message);
+  }
+  error(message) {
+    this.stopSpinner();
+    p.log.error(message);
+  }
+  render(event) {
+    if (event.type.startsWith("init:"))
+      return renderInitEvent(event, this.ctx);
+    if (event.type.startsWith("configure:"))
+      return renderConfigureEvent(event, this.ctx);
+    if (event.type.startsWith("analyze:"))
+      return renderAnalyzeEvent(event, this.ctx);
+    if (event.type.startsWith("dispatch:"))
+      return renderDispatchEvent(event, this.ctx);
+    if (event.type.startsWith("merge:"))
+      return renderMergeEvent(event, this.ctx);
+    if (event.type === "error")
+      return renderErrorEvent(event, this.ctx);
+  }
+  startSpinner(message) {
+    this.stopSpinner();
+    this.spinner = p.spinner();
+    this.spinner.start(message);
+  }
+  stopSpinner(message) {
+    if (this.spinner) {
+      this.spinner.stop(message);
+      this.spinner = null;
+    }
+  }
+}
+
+// src/shared/ui/plain.ts
+class PlainRenderer {
+  ctx = {
+    info: (msg) => console.log(msg),
+    success: (msg) => console.log(msg),
+    warn: (msg) => console.log(msg),
+    error: (msg) => console.error(msg),
+    message: (msg) => console.log(msg),
+    step: (msg) => console.log(msg),
+    startSpinner: (msg) => console.log(msg),
+    stopSpinner: (msg) => {
+      if (msg)
+        console.log(`  ✓ ${msg}`);
+    }
+  };
+  start(title) {
+    console.log(`
+═══ ${title} ═══
+`);
+  }
+  end(message) {
+    console.log(`
+═══ ${message} ═══
+`);
+  }
+  error(message) {
+    console.error(`ERROR: ${message}`);
+  }
+  render(event) {
+    if (event.type.startsWith("init:"))
+      return renderInitEvent(event, this.ctx);
+    if (event.type.startsWith("configure:"))
+      return renderConfigureEvent(event, this.ctx);
+    if (event.type.startsWith("analyze:"))
+      return renderAnalyzeEvent(event, this.ctx);
+    if (event.type.startsWith("dispatch:"))
+      return renderDispatchEvent(event, this.ctx);
+    if (event.type.startsWith("merge:"))
+      return renderMergeEvent(event, this.ctx);
+    if (event.type === "error")
+      return renderErrorEvent(event, this.ctx);
+  }
+}
+
+// src/shared/ui/index.ts
+function isInteractive() {
+  if (process.env.CI === "true")
+    return false;
+  if (!process.stdout.isTTY)
+    return false;
+  return true;
+}
+function createRenderer(interactive) {
+  const useInteractive = interactive ?? isInteractive();
+  return useInteractive ? new InteractiveRenderer : new PlainRenderer;
+}
+function createEmitter(renderer) {
+  return (event) => renderer.render(event);
+}
+
+// src/cli/analyze.command.ts
+var analyze_command_default = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Read goal file(s), fetch milestone context, and fire Jules analyzer sessions"
+  },
+  args: {
+    goal: {
+      type: "string",
+      description: "Path to a specific goal file"
+    },
+    "goals-dir": {
+      type: "string",
+      default: ".fleet/goals",
+      description: "Directory to auto-discover goal files from"
+    },
+    milestone: {
+      type: "string",
+      description: "Milestone ID to scope context"
+    },
+    owner: {
+      type: "string",
+      description: "Repository owner (auto-detected from git remote if omitted)"
+    },
+    repo: {
+      type: "string",
+      description: "Repository name (auto-detected from git remote if omitted)"
+    }
+  },
+  async run({ args }) {
+    const renderer = createRenderer();
+    let owner = args.owner;
+    let repo = args.repo;
+    if (!owner || !repo) {
+      const repoInfo = await getGitRepoInfo();
+      owner = owner || repoInfo.owner;
+      repo = repo || repoInfo.repo;
+    }
+    renderer.start(`Fleet Analyze — ${owner}/${repo}`);
+    const input = AnalyzeInputSchema.parse({
+      goal: args.goal || undefined,
+      goalsDir: args["goals-dir"],
+      milestone: args.milestone || undefined,
+      owner,
+      repo,
+      baseBranch: process.env.FLEET_BASE_BRANCH || "main"
+    });
+    const { jules } = await import("@google/jules-sdk");
+    const dispatcher = {
+      async dispatch(options) {
+        return jules.session({
+          prompt: options.prompt,
+          source: options.source,
+          requireApproval: options.requireApproval,
+          autoPr: options.autoPr
+        });
+      }
+    };
+    const octokit = createFleetOctokit();
+    const emit = createEmitter(renderer);
+    const handler = new AnalyzeHandler({ octokit, dispatcher, emit });
+    const result = await handler.execute(input);
+    if (!result.success) {
+      renderer.error(result.error.message);
+      process.exit(1);
+    }
+    renderer.end(`${result.data.sessionsStarted.length} session(s) dispatched.`);
+  }
+});
+export {
+  analyze_command_default as default
+};