@google/jules-fleet 0.0.1-experimental.0

package/dist/index.mjs

@@ -0,0 +1,2105 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/shared/result/create-result-schemas.ts
+import { z } from "zod";
+function createResultSchemas(dataSchema, errorCodeSchema) {
+  const Success = z.object({
+    success: z.literal(true),
+    data: dataSchema
+  });
+  const Failure = z.object({
+    success: z.literal(false),
+    error: z.object({
+      code: errorCodeSchema,
+      message: z.string(),
+      suggestion: z.string().optional(),
+      recoverable: z.boolean()
+    })
+  });
+  return { Success, Failure };
+}
+// 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/shared/schemas/repo-info.ts
+import { z as z2 } from "zod";
+var RepoInfoSchema = z2.object({
+  owner: z2.string().min(1),
+  repo: z2.string().min(1),
+  fullName: z2.string().regex(/^[^/]+\/[^/]+$/, "Must be in owner/repo format")
+});
+// src/shared/schemas/pr.ts
+import { z as z3 } from "zod";
+var PRSchema = z3.object({
+  number: z3.number().positive(),
+  headRef: z3.string(),
+  headSha: z3.string(),
+  body: z3.string().nullable()
+});
+// src/shared/schemas/check-run.ts
+import { z as z4 } from "zod";
+var CheckRunSchema = z4.object({
+  name: z4.string(),
+  status: z4.string(),
+  conclusion: z4.string().nullable()
+});
+// src/shared/schemas/label.ts
+import { z as z5 } from "zod";
+var LabelSchema = z5.object({
+  name: z5.string().min(1),
+  color: z5.string().regex(/^[0-9a-fA-F]{6}$/),
+  description: z5.string()
+});
+// 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}`);
+}
+async function getCurrentBranch() {
+  const { stdout } = await execAsync("git rev-parse --abbrev-ref HEAD");
+  return stdout.trim();
+}
+// 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/merge/spec.ts
+import { z as z6 } from "zod";
+var MergeMode = z6.enum(["label", "fleet-run"]);
+var MergeInputSchema = z6.object({
+  mode: MergeMode.default("label"),
+  runId: z6.string().optional(),
+  baseBranch: z6.string().default("main"),
+  admin: z6.boolean().default(false),
+  maxCIWaitSeconds: z6.number().positive().default(600),
+  maxRetries: z6.number().nonnegative().default(2),
+  reDispatch: z6.boolean().default(false),
+  pollTimeoutSeconds: z6.number().positive().default(900),
+  owner: z6.string().min(1),
+  repo: z6.string().min(1)
+}).refine((d) => d.mode !== "fleet-run" || !!d.runId, {
+  message: "--run-id is required when mode is fleet-run",
+  path: ["runId"]
+});
+var MergeErrorCode = z6.enum([
+  "NO_PRS_FOUND",
+  "CI_FAILED",
+  "CI_TIMEOUT",
+  "MERGE_FAILED",
+  "CONFLICT_RETRIES_EXHAUSTED",
+  "REDISPATCH_TIMEOUT",
+  "GITHUB_API_ERROR",
+  "UNKNOWN_ERROR"
+]);
+// src/merge/select/by-label.ts
+async function selectByLabel(octokit, owner, repo, baseBranch) {
+  const { data: pulls } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    base: baseBranch,
+    per_page: 100
+  });
+  const labeledPRs = pulls.filter((pr) => pr.labels.some((label) => label.name === "fleet-merge-ready")).sort((a, b) => a.number - b.number).map((pr) => ({
+    number: pr.number,
+    headRef: pr.head.ref,
+    headSha: pr.head.sha,
+    body: pr.body
+  }));
+  return labeledPRs;
+}
+
+// src/merge/select/by-fleet-run.ts
+var FLEET_RUN_MARKER_PREFIX = "<!-- fleet-run:";
+async function selectByFleetRun(octokit, owner, repo, baseBranch, runId) {
+  const { data: pulls } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    base: baseBranch,
+    per_page: 100
+  });
+  const marker = `${FLEET_RUN_MARKER_PREFIX} ${runId} -->`;
+  const matchingPRs = pulls.filter((pr) => pr.body?.includes(marker)).sort((a, b) => a.number - b.number).map((pr) => ({
+    number: pr.number,
+    headRef: pr.head.ref,
+    headSha: pr.head.sha,
+    body: pr.body
+  }));
+  return matchingPRs;
+}
+
+// src/merge/ops/update-branch.ts
+async function updateBranch(octokit, owner, repo, prNumber, emit) {
+  try {
+    emit({ type: "merge:branch:updating", prNumber });
+    await octokit.rest.pulls.updateBranch({
+      owner,
+      repo,
+      pull_number: prNumber
+    });
+    emit({ type: "merge:branch:updated", prNumber });
+    return { ok: true, conflict: false };
+  } catch (error) {
+    const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+    if (status === 422) {
+      emit({ type: "merge:conflict:detected", prNumber });
+      return { ok: false, conflict: true };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, conflict: false, error: message };
+  }
+}
+
+// src/merge/ops/wait-for-ci.ts
+async function waitForCI(octokit, owner, repo, prNumber, maxWaitMs, emit, sleep) {
+  const { data: prData } = await octokit.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: prNumber
+  });
+  const headSha = prData.head.sha;
+  emit({ type: "merge:ci:waiting", prNumber });
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const { data } = await octokit.rest.checks.listForRef({
+      owner,
+      repo,
+      ref: headSha
+    });
+    if (data.check_runs.length === 0) {
+      emit({ type: "merge:ci:none", prNumber });
+      return "none";
+    }
+    for (const run of data.check_runs) {
+      if (run.status === "completed") {
+        const passed = run.conclusion === "success" || run.conclusion === "skipped";
+        const durationMs = run.started_at && run.completed_at ? new Date(run.completed_at).getTime() - new Date(run.started_at).getTime() : undefined;
+        emit({
+          type: "merge:ci:check",
+          name: run.name,
+          status: passed ? "pass" : "fail",
+          duration: durationMs ? Math.round(durationMs / 1000) : undefined
+        });
+      }
+    }
+    const allComplete = data.check_runs.every((run) => run.status === "completed");
+    const allPassed = data.check_runs.every((run) => run.conclusion === "success" || run.conclusion === "skipped");
+    if (allComplete && allPassed) {
+      emit({ type: "merge:ci:passed", prNumber });
+      return "pass";
+    }
+    if (allComplete && !allPassed) {
+      emit({ type: "merge:ci:failed", prNumber });
+      return "fail";
+    }
+    await sleep(30000);
+  }
+  emit({ type: "merge:ci:timeout", prNumber });
+  return "timeout";
+}
+
+// src/merge/ops/squash-merge.ts
+async function squashMerge(octokit, owner, repo, prNumber) {
+  try {
+    await octokit.rest.pulls.merge({
+      owner,
+      repo,
+      pull_number: prNumber,
+      merge_method: "squash"
+    });
+    return { ok: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  }
+}
+
+// src/merge/ops/redispatch.ts
+async function redispatch(octokit, owner, repo, oldPr, baseBranch, pollTimeoutSeconds, emit, sleep) {
+  emit({ type: "merge:redispatch:start", oldPr: oldPr.number });
+  try {
+    await octokit.rest.pulls.update({
+      owner,
+      repo,
+      pull_number: oldPr.number,
+      state: "closed",
+      body: `${oldPr.body ?? ""}
+
+---
+⚠️ Closed by fleet-merge: merge conflict detected. Task re-dispatched.`
+    });
+  } catch {}
+  try {
+    const { jules } = await import("@google/jules-sdk");
+    const session = await jules.session({
+      prompt: oldPr.body ?? "",
+      source: {
+        github: `${owner}/${repo}`,
+        baseBranch
+      }
+    });
+    emit({ type: "merge:redispatch:waiting", oldPr: oldPr.number });
+    const start = Date.now();
+    const timeoutMs = pollTimeoutSeconds * 1000;
+    const pollIntervalMs = 30000;
+    while (Date.now() - start < timeoutMs) {
+      await sleep(pollIntervalMs);
+      const { data: pulls } = await octokit.rest.pulls.list({
+        owner,
+        repo,
+        state: "open",
+        base: baseBranch,
+        per_page: 100
+      });
+      const newPr = pulls.find((pr) => pr.head.ref.includes(session.id) || pr.body?.includes(session.id));
+      if (newPr) {
+        const result = {
+          number: newPr.number,
+          headRef: newPr.head.ref,
+          headSha: newPr.head.sha,
+          body: newPr.body
+        };
+        emit({
+          type: "merge:redispatch:done",
+          oldPr: oldPr.number,
+          newPr: newPr.number
+        });
+        return result;
+      }
+    }
+  } catch (error) {
+    emit({
+      type: "error",
+      code: "REDISPATCH_FAILED",
+      message: `Re-dispatch failed: ${error instanceof Error ? error.message : error}`
+    });
+  }
+  return null;
+}
+
+// src/merge/handler.ts
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+class MergeHandler {
+  octokit;
+  emit;
+  sleep;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+    this.sleep = deps.sleep ?? defaultSleep;
+  }
+  async execute(input) {
+    try {
+      const prs = await this.selectPRs(input);
+      if (prs.length === 0) {
+        this.emit({ type: "merge:no-prs" });
+        return ok({ merged: [], skipped: [], redispatched: [] });
+      }
+      this.emit({
+        type: "merge:start",
+        owner: input.owner,
+        repo: input.repo,
+        mode: input.mode,
+        prCount: prs.length
+      });
+      const merged = [];
+      const skipped = [];
+      const redispatched = [];
+      for (const pr of prs) {
+        let currentPr = pr;
+        let retryCount = 0;
+        let prMerged = false;
+        while (!prMerged) {
+          this.emit({
+            type: "merge:pr:processing",
+            number: currentPr.number,
+            title: currentPr.body?.split(`
+`)[0] ?? `PR #${currentPr.number}`,
+            retry: retryCount > 0 ? retryCount : undefined
+          });
+          if (prs.indexOf(pr) > 0 || retryCount > 0) {
+            const updateResult = await updateBranch(this.octokit, input.owner, input.repo, currentPr.number, this.emit);
+            if (!updateResult.ok && updateResult.conflict) {
+              if (!input.reDispatch) {
+                return fail("CONFLICT_RETRIES_EXHAUSTED", `Merge conflict detected for PR #${currentPr.number}. Use --re-dispatch to automatically retry.`, false, `Review PR: https://github.com/${input.owner}/${input.repo}/pull/${currentPr.number}`);
+              }
+              if (retryCount >= input.maxRetries) {
+                return fail("CONFLICT_RETRIES_EXHAUSTED", `Conflict persists for PR #${currentPr.number} after ${input.maxRetries} retries. Human intervention required.`, false, `Review PR: https://github.com/${input.owner}/${input.repo}/pull/${currentPr.number}`);
+              }
+              const newPr = await redispatch(this.octokit, input.owner, input.repo, currentPr, input.baseBranch, input.pollTimeoutSeconds, this.emit, this.sleep);
+              if (!newPr) {
+                return fail("REDISPATCH_TIMEOUT", `Timed out waiting for re-dispatched PR for #${currentPr.number}.`, true);
+              }
+              redispatched.push({
+                oldPr: currentPr.number,
+                newPr: newPr.number
+              });
+              currentPr = newPr;
+              retryCount++;
+              continue;
+            }
+            if (!updateResult.ok && !updateResult.conflict) {
+              return fail("GITHUB_API_ERROR", `Failed to update branch for PR #${currentPr.number}: ${updateResult.error}`, true);
+            }
+            await this.sleep(5000);
+          }
+          const ciResult = await waitForCI(this.octokit, input.owner, input.repo, currentPr.number, input.maxCIWaitSeconds * 1000, this.emit, this.sleep);
+          if (ciResult === "none") {} else if (ciResult === "fail") {
+            this.emit({
+              type: "merge:pr:skipped",
+              prNumber: currentPr.number,
+              reason: "CI failure"
+            });
+            skipped.push(currentPr.number);
+            break;
+          } else if (ciResult === "timeout") {
+            this.emit({
+              type: "merge:pr:skipped",
+              prNumber: currentPr.number,
+              reason: "CI timeout"
+            });
+            skipped.push(currentPr.number);
+            break;
+          }
+          this.emit({ type: "merge:pr:merging", prNumber: currentPr.number });
+          const mergeResult = await squashMerge(this.octokit, input.owner, input.repo, currentPr.number);
+          if (!mergeResult.ok) {
+            return fail("MERGE_FAILED", `Failed to merge PR #${currentPr.number}: ${mergeResult.error}`, false);
+          }
+          this.emit({ type: "merge:pr:merged", prNumber: currentPr.number });
+          merged.push(currentPr.number);
+          prMerged = true;
+        }
+        await this.sleep(5000);
+      }
+      this.emit({ type: "merge:done", merged, skipped, redispatched });
+      return ok({ merged, skipped, redispatched });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+  async selectPRs(input) {
+    if (input.mode === "fleet-run") {
+      return selectByFleetRun(this.octokit, input.owner, input.repo, input.baseBranch, input.runId);
+    }
+    return selectByLabel(this.octokit, input.owner, input.repo, input.baseBranch);
+  }
+}
+// src/init/spec.ts
+import { z as z7 } from "zod";
+var InitInputSchema = z7.object({
+  repo: z7.string().regex(/^[^/]+\/[^/]+$/, "Must be in owner/repo format").optional(),
+  owner: z7.string().min(1),
+  repoName: z7.string().min(1),
+  baseBranch: z7.string().default("main")
+});
+var InitErrorCode = z7.enum([
+  "REPO_NOT_FOUND",
+  "BRANCH_CREATE_FAILED",
+  "FILE_COMMIT_FAILED",
+  "PR_CREATE_FAILED",
+  "LABEL_CREATE_FAILED",
+  "GITHUB_API_ERROR",
+  "UNKNOWN_ERROR"
+]);
+// src/init/templates/analyze.ts
+var FLEET_ANALYZE_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-analyze.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Analyze
+
+on:
+  schedule:
+    - cron: '0 5 * * *' # Daily at 5am UTC — edit to your preference
+  workflow_dispatch:
+    inputs:
+      goal:
+        description: 'Path to goal file (or blank for all)'
+        type: string
+        default: ''
+      milestone:
+        description: 'Milestone ID override'
+        type: string
+        default: ''
+
+concurrency:
+  group: fleet-analyze
+  cancel-in-progress: false
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npx @google/jules-fleet analyze --goal "\${{ inputs.goal }}" --milestone "\${{ inputs.milestone }}"
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates/dispatch.ts
+var FLEET_DISPATCH_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-dispatch.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Dispatch
+
+on:
+  schedule:
+    - cron: '0 6 * * *' # Daily at 6am UTC — edit to your preference
+  workflow_dispatch:
+    inputs:
+      milestone:
+        description: 'Milestone ID to dispatch'
+        type: string
+        required: true
+
+concurrency:
+  group: fleet-dispatch
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npx @google/jules-fleet dispatch --milestone \${{ inputs.milestone }}
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates/merge.ts
+var FLEET_MERGE_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-merge.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Merge
+
+on:
+  schedule:
+    - cron: '0 */4 * * *' # Every 4 hours — edit to your preference
+  workflow_dispatch:
+    inputs:
+      mode:
+        description: 'PR selection mode'
+        type: choice
+        options:
+          - label
+          - fleet-run
+        default: 'label'
+      fleet_run_id:
+        description: 'Fleet run ID (required for fleet-run mode)'
+        type: string
+        default: ''
+      re_dispatch:
+        description: 'Auto re-dispatch on merge conflict'
+        type: boolean
+        default: true
+
+concurrency:
+  group: fleet-merge
+  cancel-in-progress: false
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: |
+          REDISPATCH_FLAG=""
+          if [ "\${{ inputs.re_dispatch }}" = "true" ]; then
+            REDISPATCH_FLAG="--re-dispatch"
+          fi
+          npx @google/jules-fleet merge \\
+            --mode \${{ inputs.mode || 'label' }} \\
+            --run-id "\${{ inputs.fleet_run_id }}" \\
+            $REDISPATCH_FLAG
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates.ts
+var WORKFLOW_TEMPLATES = [
+  FLEET_ANALYZE_TEMPLATE,
+  FLEET_DISPATCH_TEMPLATE,
+  FLEET_MERGE_TEMPLATE
+];
+
+// src/init/templates/example-goal.ts
+var EXAMPLE_GOAL = `---
+milestone: "1"
+---
+
+# Example Fleet Goal
+
+Analyze the codebase for potential improvements and create
+issues for the engineering team.
+
+## Tools
+- Test Coverage: \`npx vitest --coverage --json\`
+
+## Assessment Hints
+- Focus on missing error handling in API routes
+- Look for hardcoded configuration values
+
+## Insight Hints
+- Report on overall test coverage metrics
+- Note any unusually complex functions (cyclomatic complexity)
+
+## Constraints
+- Do NOT propose changes already covered by open issues
+- Do NOT propose changes rejected in recently closed issues
+- Keep tasks small and isolated — one logical change per issue
+`;
+
+// src/init/ops/create-branch.ts
+async function createBranch(octokit, owner, repo, baseBranch, emit) {
+  const { data: refData } = await octokit.rest.git.getRef({
+    owner,
+    repo,
+    ref: `heads/${baseBranch}`
+  });
+  const baseSha = refData.object.sha;
+  const branchName = `fleet-init-${Date.now()}`;
+  emit({ type: "init:branch:creating", name: branchName, base: baseBranch });
+  try {
+    await octokit.rest.git.createRef({
+      owner,
+      repo,
+      ref: `refs/heads/${branchName}`,
+      sha: baseSha
+    });
+    emit({ type: "init:branch:created", name: branchName });
+  } catch (error) {
+    return fail("BRANCH_CREATE_FAILED", `Failed to create branch "${branchName}": ${error instanceof Error ? error.message : error}`, true);
+  }
+  return { branchName, baseSha };
+}
+function isBranchResult(result) {
+  return "success" in result;
+}
+
+// src/init/ops/commit-files.ts
+async function commitFiles(ctx, templates, exampleGoal) {
+  const filesCreated = [];
+  for (const tmpl of templates) {
+    try {
+      await ctx.octokit.rest.repos.createOrUpdateFileContents({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        path: tmpl.repoPath,
+        message: `chore: add ${tmpl.repoPath}`,
+        content: Buffer.from(tmpl.content).toString("base64"),
+        branch: ctx.branchName
+      });
+      filesCreated.push(tmpl.repoPath);
+      ctx.emit({ type: "init:file:committed", path: tmpl.repoPath });
+    } catch (error) {
+      const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+      if (status === 422) {
+        ctx.emit({ type: "init:file:skipped", path: tmpl.repoPath, reason: "already exists" });
+      } else {
+        return fail("FILE_COMMIT_FAILED", `Failed to commit "${tmpl.repoPath}": ${error instanceof Error ? error.message : error}`, true);
+      }
+    }
+  }
+  try {
+    await ctx.octokit.rest.repos.createOrUpdateFileContents({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      path: ".fleet/goals/example.md",
+      message: "chore: add example fleet goal",
+      content: Buffer.from(exampleGoal).toString("base64"),
+      branch: ctx.branchName
+    });
+    filesCreated.push(".fleet/goals/example.md");
+    ctx.emit({ type: "init:file:committed", path: ".fleet/goals/example.md" });
+  } catch (error) {
+    const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+    if (status !== 422) {
+      ctx.emit({
+        type: "init:file:skipped",
+        path: ".fleet/goals/example.md",
+        reason: `${error instanceof Error ? error.message : error}`
+      });
+    }
+  }
+  return filesCreated;
+}
+function isCommitResult(result) {
+  return !Array.isArray(result);
+}
+
+// src/init/ops/pr-body.ts
+function buildInitPRBody(filesCreated) {
+  return [
+    "## Fleet Initialization",
+    "",
+    "This PR adds the fleet workflow files for automated issue dispatch, merge, and analysis.",
+    "",
+    "### Files added",
+    ...filesCreated.map((f) => `- \`${f}\``),
+    "",
+    "### Next steps",
+    "1. Merge this PR",
+    "2. Add `JULES_API_KEY` to your repo secrets",
+    "3. Create milestones and issues with the `fleet` label",
+    "4. Run `jules-fleet configure labels` to set up labels (or they were already created)"
+  ].join(`
+`);
+}
+
+// src/init/ops/create-pr.ts
+async function createInitPR(ctx, baseBranch, filesCreated) {
+  ctx.emit({ type: "init:pr:creating" });
+  try {
+    const { data: pr } = await ctx.octokit.rest.pulls.create({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      title: "chore: initialize fleet workflows",
+      body: buildInitPRBody(filesCreated),
+      head: ctx.branchName,
+      base: baseBranch
+    });
+    ctx.emit({ type: "init:pr:created", url: pr.html_url, number: pr.number });
+    return { prUrl: pr.html_url, prNumber: pr.number };
+  } catch (error) {
+    return fail("PR_CREATE_FAILED", `Failed to create PR: ${error instanceof Error ? error.message : error}`, true);
+  }
+}
+function isPRResult(result) {
+  return "success" in result;
+}
+
+// src/init/handler.ts
+class InitHandler {
+  octokit;
+  emit;
+  labelConfigurator;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+    this.labelConfigurator = deps.labelConfigurator;
+  }
+  async execute(input) {
+    try {
+      const { owner, repoName: repo, baseBranch } = input;
+      this.emit({ type: "init:start", owner, repo });
+      const branchResult = await createBranch(this.octokit, owner, repo, baseBranch, this.emit);
+      if (isBranchResult(branchResult))
+        return branchResult;
+      const { branchName } = branchResult;
+      const ctx = {
+        octokit: this.octokit,
+        owner,
+        repo,
+        branchName,
+        emit: this.emit
+      };
+      const filesResult = await commitFiles(ctx, WORKFLOW_TEMPLATES, EXAMPLE_GOAL);
+      if (isCommitResult(filesResult))
+        return filesResult;
+      const filesCreated = filesResult;
+      if (filesCreated.length === 0) {
+        this.emit({
+          type: "error",
+          code: "ALREADY_INITIALIZED",
+          message: "All fleet files already exist — nothing to commit.",
+          suggestion: "This repo appears to be already initialized. Use jules-fleet configure to update settings."
+        });
+        return fail("FILE_COMMIT_FAILED", "All fleet files already exist — nothing to commit.", false, "This repo appears to be already initialized. Use jules-fleet configure to update settings.");
+      }
+      const prResult = await createInitPR(ctx, baseBranch, filesCreated);
+      if (isPRResult(prResult))
+        return prResult;
+      const { prUrl, prNumber } = prResult;
+      let labelsCreated = [];
+      if (this.labelConfigurator) {
+        const labelResult = await this.labelConfigurator.execute({
+          resource: "labels",
+          action: "create",
+          owner,
+          repo
+        });
+        labelsCreated = labelResult.success ? labelResult.data.created : [];
+      }
+      this.emit({
+        type: "init:done",
+        prUrl,
+        files: filesCreated,
+        labels: labelsCreated
+      });
+      return ok({ prUrl, prNumber, filesCreated, labelsCreated });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+}
+// src/configure/spec.ts
+import { z as z8 } from "zod";
+var ConfigureAction = z8.enum(["create", "delete"]);
+var ConfigureResource = z8.enum(["labels"]);
+var ConfigureInputSchema = z8.object({
+  resource: ConfigureResource,
+  action: ConfigureAction.default("create"),
+  owner: z8.string().min(1),
+  repo: z8.string().min(1)
+});
+var ConfigureErrorCode = z8.enum([
+  "GITHUB_API_ERROR",
+  "UNKNOWN_ERROR"
+]);
+// src/configure/labels.ts
+var FLEET_LABELS = [
+  {
+    name: "fleet-merge-ready",
+    color: "0e8a16",
+    description: "Ready for fleet sequential merge"
+  },
+  {
+    name: "fleet",
+    color: "1d76db",
+    description: "Fleet-managed issue"
+  }
+];
+
+// src/configure/handler.ts
+class ConfigureHandler {
+  octokit;
+  emit;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+  }
+  async execute(input) {
+    try {
+      this.emit({
+        type: "configure:start",
+        resource: input.resource,
+        owner: input.owner,
+        repo: input.repo
+      });
+      if (input.resource === "labels") {
+        const result = input.action === "create" ? await this.createLabels(input.owner, input.repo) : await this.deleteLabels(input.owner, input.repo);
+        this.emit({ type: "configure:done" });
+        return result;
+      }
+      return fail("UNKNOWN_ERROR", `Unknown resource: ${input.resource}`, false);
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+  async createLabels(owner, repo) {
+    const created = [];
+    const skipped = [];
+    for (const label of FLEET_LABELS) {
+      try {
+        await this.octokit.rest.issues.createLabel({
+          owner,
+          repo,
+          name: label.name,
+          color: label.color,
+          description: label.description
+        });
+        created.push(label.name);
+        this.emit({ type: "configure:label:created", name: label.name });
+      } catch (error) {
+        const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+        if (status === 422) {
+          skipped.push(label.name);
+          this.emit({ type: "configure:label:exists", name: label.name });
+        } else {
+          return fail("GITHUB_API_ERROR", `Failed to create label "${label.name}": ${error instanceof Error ? error.message : error}`, true);
+        }
+      }
+    }
+    return ok({ created, deleted: [], skipped });
+  }
+  async deleteLabels(owner, repo) {
+    const deleted = [];
+    const skipped = [];
+    for (const label of FLEET_LABELS) {
+      try {
+        await this.octokit.rest.issues.deleteLabel({
+          owner,
+          repo,
+          name: label.name
+        });
+        deleted.push(label.name);
+        this.emit({ type: "configure:label:created", name: label.name });
+      } catch (error) {
+        const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+        if (status === 404) {
+          skipped.push(label.name);
+          this.emit({ type: "configure:label:exists", name: label.name });
+        } else {
+          return fail("GITHUB_API_ERROR", `Failed to delete label "${label.name}": ${error instanceof Error ? error.message : error}`, true);
+        }
+      }
+    }
+    return ok({ created: [], deleted, skipped });
+  }
+}
+// src/analyze/spec.ts
+import { z as z9 } from "zod";
+var AnalyzeInputSchema = z9.object({
+  goal: z9.string().optional(),
+  goalsDir: z9.string().default(".fleet/goals"),
+  milestone: z9.string().optional(),
+  owner: z9.string().min(1),
+  repo: z9.string().min(1),
+  baseBranch: z9.string().default("main")
+});
+var AnalyzeErrorCode = z9.enum([
+  "GOAL_NOT_FOUND",
+  "NO_GOALS_FOUND",
+  "MILESTONE_FETCH_FAILED",
+  "SESSION_DISPATCH_FAILED",
+  "UNKNOWN_ERROR"
+]);
+// 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
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { basename } from "path";
+import { globSync } from "glob";
+
+// 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 toIssueLean(issue) {
+  return `- #${issue.number}: ${issue.title} [${issue.state}]`;
+}
+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/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/dispatch/spec.ts
+import { z as z10 } from "zod";
+var DispatchInputSchema = z10.object({
+  milestone: z10.string().min(1),
+  owner: z10.string().min(1),
+  repo: z10.string().min(1),
+  baseBranch: z10.string().default("main")
+});
+var DispatchErrorCode = z10.enum([
+  "NO_FLEET_ISSUES",
+  "MILESTONE_FETCH_FAILED",
+  "SESSION_DISPATCH_FAILED",
+  "UNKNOWN_ERROR"
+]);
+// src/dispatch/status.ts
+var DISPATCH_MARKER = "\uD83E\uDD16 **Fleet Dispatch Event**";
+async function getDispatchStatus(octokit, owner, repo, issueNumbers) {
+  const { data: openPRs } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    per_page: 100
+  });
+  const results = [];
+  for (const issueNumber of issueNumbers) {
+    const { data: issue } = await octokit.rest.issues.get({
+      owner,
+      repo,
+      issue_number: issueNumber
+    });
+    const { data: comments } = await octokit.rest.issues.listComments({
+      owner,
+      repo,
+      issue_number: issueNumber,
+      per_page: 100
+    });
+    const dispatchComment = comments.find((c) => c.body?.includes(DISPATCH_MARKER));
+    let dispatchEvent = null;
+    if (dispatchComment?.body) {
+      const sessionMatch = dispatchComment.body.match(/Session:\s*`([^`]+)`/);
+      dispatchEvent = {
+        sessionId: sessionMatch?.[1] ?? "unknown",
+        timestamp: dispatchComment.created_at,
+        commentId: dispatchComment.id
+      };
+    }
+    const linkedPRs = openPRs.filter((pr) => pr.body?.includes(`#${issueNumber}`) || pr.body?.includes(`Fixes #${issueNumber}`) || pr.body?.includes(`Closes #${issueNumber}`)).map((pr) => pr.number);
+    results.push({
+      number: issueNumber,
+      open: issue.state === "open",
+      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name),
+      dispatchEvent,
+      linkedPRs
+    });
+  }
+  return results;
+}
+
+// src/dispatch/events.ts
+async function recordDispatch(octokit, owner, repo, issueNumber, sessionId) {
+  const timestamp = new Date().toISOString();
+  const body = [
+    `\uD83E\uDD16 **Fleet Dispatch Event**`,
+    `Session: \`${sessionId}\``,
+    `Timestamp: ${timestamp}`
+  ].join(`
+`);
+  const { data: comment } = await octokit.rest.issues.createComment({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    body
+  });
+  return {
+    commentId: comment.id,
+    timestamp
+  };
+}
+
+// src/dispatch/handler.ts
+class DispatchHandler {
+  octokit;
+  dispatcher;
+  emit;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.dispatcher = deps.dispatcher;
+    this.emit = deps.emit ?? (() => {});
+  }
+  async execute(input) {
+    try {
+      this.emit({ type: "dispatch:start", milestone: input.milestone });
+      this.emit({ type: "dispatch:scanning" });
+      const ctx = await getMilestoneContext(this.octokit, {
+        owner: input.owner,
+        repo: input.repo,
+        milestone: input.milestone
+      });
+      const fleetIssues = ctx.issues.open.filter((issue) => issue.labels.includes("fleet"));
+      if (fleetIssues.length === 0) {
+        this.emit({ type: "dispatch:done", dispatched: 0, skipped: 0 });
+        return ok({ dispatched: [], skipped: 0 });
+      }
+      const statuses = await getDispatchStatus(this.octokit, input.owner, input.repo, fleetIssues.map((i) => i.number));
+      const undispatched = statuses.filter((s) => s.open && !s.dispatchEvent && s.linkedPRs.length === 0);
+      const skipped = statuses.length - undispatched.length;
+      if (undispatched.length === 0) {
+        this.emit({ type: "dispatch:done", dispatched: 0, skipped });
+        return ok({ dispatched: [], skipped });
+      }
+      this.emit({ type: "dispatch:found", count: undispatched.length });
+      const dispatched = [];
+      for (const status of undispatched) {
+        const issue = fleetIssues.find((i) => i.number === status.number);
+        this.emit({
+          type: "dispatch:issue:dispatching",
+          number: issue.number,
+          title: issue.title
+        });
+        const workerPrompt = `Fix Issue #${issue.number}: ${issue.title}
+
+IMPORTANT: Your PR title MUST start with "Fixes #${issue.number}" and your PR description MUST include "Fixes #${issue.number}" on its own line so the issue is auto-closed on merge.
+
+You are an autonomous execution agent. Implement the fix described below exactly as specified.
+
+---
+
+${issue.body}
+`;
+        try {
+          const session = await this.dispatcher.dispatch({
+            prompt: workerPrompt,
+            source: {
+              github: `${input.owner}/${input.repo}`,
+              baseBranch: input.baseBranch
+            },
+            requireApproval: false,
+            autoPr: true
+          });
+          await recordDispatch(this.octokit, input.owner, input.repo, issue.number, session.id);
+          dispatched.push({
+            issueNumber: issue.number,
+            sessionId: session.id
+          });
+          this.emit({
+            type: "dispatch:issue:dispatched",
+            number: issue.number,
+            sessionId: session.id
+          });
+        } catch (error) {
+          this.emit({
+            type: "error",
+            code: "DISPATCH_FAILED",
+            message: `Failed to dispatch #${issue.number}: ${error instanceof Error ? error.message : error}`
+          });
+        }
+      }
+      for (const status of statuses) {
+        if (!undispatched.includes(status)) {
+          this.emit({
+            type: "dispatch:issue:skipped",
+            number: status.number,
+            reason: status.dispatchEvent ? "already dispatched" : "has linked PRs"
+          });
+        }
+      }
+      this.emit({
+        type: "dispatch:done",
+        dispatched: dispatched.length,
+        skipped
+      });
+      return ok({ dispatched, skipped });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+}
+// src/signal/spec.ts
+import { z as z11 } from "zod";
+var SignalKind = z11.enum(["insight", "assessment"]);
+var SignalCreateInputSchema = z11.object({
+  owner: z11.string().min(1),
+  repo: z11.string().min(1),
+  kind: SignalKind.default("assessment"),
+  title: z11.string().min(1),
+  body: z11.string().min(1),
+  tags: z11.array(z11.string()).default([]),
+  scope: z11.string().optional()
+});
+var SignalCreateErrorCode = z11.enum([
+  "GITHUB_API_ERROR",
+  "SCOPE_NOT_FOUND",
+  "UNKNOWN_ERROR"
+]);
+// src/signal/handler.ts
+class SignalCreateHandler {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async execute(input) {
+    try {
+      const { octokit } = this.deps;
+      const labels = [...input.tags];
+      labels.push(input.kind === "insight" ? "fleet-insight" : "fleet-assessment");
+      let milestoneNumber;
+      if (input.scope) {
+        const { data: milestones } = await octokit.rest.issues.listMilestones({
+          owner: input.owner,
+          repo: input.repo,
+          state: "open"
+        });
+        const match = milestones.find((m) => m.title.toLowerCase() === input.scope.toLowerCase());
+        if (!match) {
+          return {
+            success: false,
+            error: {
+              code: "SCOPE_NOT_FOUND",
+              message: `No open milestone found matching scope "${input.scope}"`,
+              recoverable: true,
+              suggestion: `Create a milestone named "${input.scope}" or omit --scope`
+            }
+          };
+        }
+        milestoneNumber = match.number;
+      }
+      const { data } = await octokit.rest.issues.create({
+        owner: input.owner,
+        repo: input.repo,
+        title: input.title,
+        body: input.body,
+        labels,
+        ...milestoneNumber && { milestone: milestoneNumber }
+      });
+      return {
+        success: true,
+        data: { id: data.number, url: data.html_url }
+      };
+    } catch (error) {
+      if (error instanceof Error && "status" in error) {
+        return {
+          success: false,
+          error: {
+            code: "GITHUB_API_ERROR",
+            message: error.message,
+            recoverable: error.status === 403 || error.status === 429,
+            suggestion: error.status === 401 ? "Check your GITHUB_TOKEN or GitHub App credentials" : undefined
+          }
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+}
+export {
+  toIssueMarkdown,
+  toIssueLean,
+  selectByLabel,
+  selectByFleetRun,
+  resolvePrivateKey,
+  recordDispatch,
+  parseGoalFile,
+  parseGoalContent,
+  parseGitRemoteUrl,
+  ok,
+  isInteractive,
+  getMilestoneContext,
+  getGitRepoInfo,
+  getDispatchStatus,
+  getCurrentBranch,
+  getBuiltInTriagePrompt,
+  getAuthOptions,
+  formatPRContext,
+  fail,
+  createResultSchemas,
+  createRenderer,
+  createFleetOctokit,
+  createEmitter,
+  cachePlugin,
+  buildAnalyzerPrompt,
+  TRIAGE_GOAL_FILENAME,
+  SignalKind as SignalKindEnum,
+  SignalCreateInputSchema,
+  SignalCreateHandler,
+  RepoInfoSchema,
+  PRSchema,
+  MergeMode,
+  MergeInputSchema,
+  MergeHandler,
+  MergeErrorCode,
+  LabelSchema,
+  InitInputSchema,
+  InitHandler,
+  InitErrorCode,
+  FLEET_LABELS,
+  DispatchInputSchema,
+  DispatchHandler,
+  DispatchErrorCode,
+  ConfigureResource,
+  ConfigureInputSchema,
+  ConfigureHandler,
+  ConfigureErrorCode,
+  ConfigureAction,
+  CheckRunSchema,
+  AnalyzeInputSchema,
+  AnalyzeHandler,
+  AnalyzeErrorCode
+};