@brunyee-studio/onus-cli 2.28.0

package/dist/bin.js

@@ -0,0 +1,2354 @@
+#!/usr/bin/env node
+import {
+  cliVersion,
+  createApiClient,
+  loginWithOAuth
+} from "./chunk-HJQGUY5T.js";
+import {
+  clearConfig,
+  getConfigDirectory,
+  getConfigFilePath,
+  loadConfig,
+  saveConfig
+} from "./chunk-HE2HTZ3Y.js";
+
+// src/bin.ts
+import pc9 from "picocolors";
+
+// src/program.ts
+import { Command } from "commander";
+import pc7 from "picocolors";
+
+// src/commands/auth.ts
+import pc2 from "picocolors";
+
+// src/format.ts
+import pc from "picocolors";
+function sanitizeTerminal(value) {
+  let s = value === null || value === void 0 ? "" : String(value);
+  s = s.replace(/\u001b\[[0-9;:?]*[ -/]*[@-~]/g, "");
+  s = s.replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "");
+  s = s.replace(/\u001b[PX^_][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "");
+  s = s.replace(/\u001b[A-Z\\[\\]\\_]/gi, "");
+  s = s.replace(/\u001b/g, "");
+  return s.replace(/[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\u007f\u0080-\u009f]/g, "");
+}
+function displayValue(cell) {
+  return cell === null || cell === void 0 ? pc.dim("\u2014") : sanitizeTerminal(cell);
+}
+function isJsonMode(explicitJson) {
+  if (explicitJson !== void 0) return explicitJson;
+  if (process.env.ONUS_OUTPUT === "json") return true;
+  return !process.stdout.isTTY;
+}
+function formatRecord(fields) {
+  if (fields.length === 0) return "";
+  const width = Math.max(...fields.map((f) => sanitizeTerminal(f.label).length));
+  return fields.map((f) => {
+    const label = (sanitizeTerminal(f.label) + ":").padEnd(width + 1);
+    return `${pc.bold(pc.cyan(label))}  ${displayValue(f.value)}`;
+  }).join("\n");
+}
+function formatRecordList(records) {
+  return records.map((fields) => formatRecord(fields)).join("\n\n");
+}
+function printJsonOrFormatted(data, explicitJson, ttyRenderer) {
+  if (isJsonMode(explicitJson)) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    ttyRenderer();
+  }
+}
+function formatSuccess(message) {
+  console.log(pc.green("\u2714") + " " + sanitizeTerminal(message));
+}
+function exitCodeForStatus(status) {
+  if (status === 401 || status === 403) return 3;
+  if (status === 404) return 4;
+  if (status === 400 || status === 422) return 2;
+  return 1;
+}
+async function handleApiError(error, explicitJson) {
+  const isJson = isJsonMode(explicitJson);
+  const apiError = typeof error === "object" && error !== null ? error : {};
+  const status = exitCodeForStatus(apiError.status ?? apiError.response?.status);
+  let body;
+  try {
+    if (apiError.response && typeof apiError.response.json === "function") {
+      body = await apiError.response.json();
+    } else if (apiError.json && typeof apiError.json === "function") {
+      body = await apiError.json();
+    }
+  } catch {
+    body = void 0;
+  }
+  const message = body?.message || body?.error || apiError.statusText || apiError.response?.statusText || (error instanceof Error ? error.message : String(error));
+  const payload = {
+    error: body?.error || "error",
+    message
+  };
+  if (isJson) {
+    const bodyHasKeys = body && typeof body === "object" && Object.keys(body).length > 0;
+    console.error(JSON.stringify(bodyHasKeys ? body : payload, null, 2));
+  } else {
+    console.error(pc.red(`Error (${status}):`), sanitizeTerminal(message));
+  }
+  process.exit(status);
+}
+
+// src/help.ts
+function withExamples(command, examples) {
+  const block = `
+Examples:
+${examples.map((e) => `  $ ${e}`).join("\n")}
+`;
+  return command.addHelpText("after", block);
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage CLI authentication and API endpoint configuration");
+  auth.command("login").description("Authenticate with Onus via OAuth browser flow or store an access token").option("-t, --token <token>", "Direct access token or API key (headless/agent mode)").option("-u, --api-url <url>", "API base URL").option("-m, --manual", "Use manual copy-paste authorization code without a local browser").option("--timeout <seconds>", "Timeout in seconds for interactive browser callback", "120").option(
+    "--loopback-host <host>",
+    "Loopback host to bind the callback server. Use 0.0.0.0 under WSL2 mirror networking. Defaults to ONUS_OAUTH_HOST or 127.0.0.1"
+  ).action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    const directToken = opts.token || globals.token;
+    const apiUrl = opts.apiUrl || globals.apiUrl;
+    if (directToken) {
+      const updated = saveConfig({
+        token: directToken,
+        ...apiUrl ? { apiUrl } : {}
+      });
+      formatSuccess(`Logged in successfully. Using API: ${updated.apiUrl}`);
+      return;
+    }
+    const activeConfig = loadConfig();
+    const targetApiUrl = apiUrl || activeConfig.apiUrl;
+    const loopbackHost = opts.loopbackHost || process.env.ONUS_OAUTH_HOST || void 0;
+    try {
+      const oauthResult = await loginWithOAuth({
+        apiUrl: targetApiUrl,
+        manual: Boolean(opts.manual),
+        timeoutSeconds: opts.timeout ? Number(opts.timeout) : 120,
+        ...loopbackHost ? { loopbackHost } : {}
+      });
+      const updated = saveConfig({
+        token: oauthResult.token,
+        ...oauthResult.refreshToken ? { refreshToken: oauthResult.refreshToken } : {},
+        apiUrl: targetApiUrl
+      });
+      try {
+        const client = createApiClient({
+          token: updated.token,
+          apiUrl: updated.apiUrl
+        });
+        const viewer = await client.meGet();
+        const name = viewer.full_name || viewer.id;
+        formatSuccess(
+          `Logged in successfully as ${name}. Stored credentials in ${getConfigFilePath()}`
+        );
+      } catch {
+        formatSuccess(`Logged in successfully. Stored credentials in ${getConfigFilePath()}`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  auth.command("logout").description("Clear stored authentication credentials").action(() => {
+    clearConfig();
+    formatSuccess("Logged out successfully. Stored credentials removed.");
+  });
+  auth.command("status").description("Show current authentication status and active API endpoint").option("-j, --json", "Output raw JSON").action(function() {
+    const globals = this.optsWithGlobals();
+    const config = loadConfig();
+    const maskedToken = config.token && config.token.length > 10 ? `${config.token.slice(0, 6)}...${config.token.slice(-4)}` : config.token ? "***" : null;
+    const hasRefreshToken = Boolean(config.refreshToken);
+    const statusObj = {
+      authenticated: Boolean(config.token),
+      token: maskedToken,
+      hasRefreshToken,
+      apiUrl: config.apiUrl
+    };
+    printJsonOrFormatted(statusObj, globals.json, () => {
+      console.log(pc2.bold("Onus CLI Auth Status:"));
+      console.log(`  API URL:        ${pc2.cyan(config.apiUrl)}`);
+      console.log(
+        `  Authenticated:  ${config.token ? pc2.green("Yes") + ` (Token: ${maskedToken})` : pc2.yellow('No (Run "onus auth login")')}`
+      );
+      console.log(
+        `  Refresh Token:  ${hasRefreshToken ? pc2.green("Configured") : pc2.dim("None")}`
+      );
+    });
+  });
+  withExamples(
+    auth.commands.find((c) => c.name() === "login"),
+    [
+      "onus auth login",
+      "onus auth login --manual",
+      "onus auth login --token <TOKEN> --api-url https://onus.example.com/v1"
+    ]
+  );
+  withExamples(
+    auth.commands.find((c) => c.name() === "logout"),
+    ["onus auth logout"]
+  );
+  withExamples(
+    auth.commands.find((c) => c.name() === "status"),
+    ["onus auth status", "onus auth status --json"]
+  );
+}
+
+// src/commands/context.ts
+import pc3 from "picocolors";
+function registerContextCommands(program2) {
+  program2.command("context").description("Emit environment, auth, and agent-interaction context snapshot").option("-j, --json", "Output raw JSON").action(async function() {
+    const globals = this.optsWithGlobals();
+    const config = loadConfig();
+    const effectiveToken = globals.token || config.token;
+    const effectiveUrl = globals.apiUrl || config.apiUrl;
+    let viewer = null;
+    if (effectiveToken) {
+      try {
+        const client = createApiClient({ token: effectiveToken, apiUrl: effectiveUrl });
+        viewer = await client.meGet();
+      } catch {
+      }
+    }
+    const contextData = {
+      cliVersion,
+      apiUrl: effectiveUrl,
+      authenticated: Boolean(effectiveToken),
+      viewer,
+      resources: ["team", "project", "issue", "comment", "label"],
+      capabilities: {
+        jsonOutputSupported: true,
+        envAuthSupported: true,
+        standardExitCodes: {
+          success: 0,
+          generalError: 1,
+          validationError: 2,
+          authError: 3,
+          notFound: 4
+        }
+      },
+      quickExamples: [
+        "onus me --json",
+        "onus team list --json",
+        "onus project list --json",
+        "onus issue list --status in_progress --json",
+        'onus issue create --title "Fix login" --team <team-id> --json',
+        "onus comment list <issue-id> --json"
+      ]
+    };
+    printJsonOrFormatted(contextData, globals.json, () => {
+      console.log(pc3.bold("Onus CLI Agent Context Snapshot:"));
+      console.log(`  CLI Version:   ${pc3.cyan(contextData.cliVersion)}`);
+      console.log(`  API Endpoint:  ${pc3.cyan(contextData.apiUrl)}`);
+      console.log(
+        `  Auth State:    ${contextData.authenticated ? pc3.green("Authenticated") : pc3.yellow("Unauthenticated")}`
+      );
+      if (viewer) {
+        console.log(`  Viewer:        ${pc3.bold(viewer.full_name)} (${viewer.id})`);
+      }
+      console.log("\n" + pc3.bold("Available Resources:"));
+      console.log("  " + contextData.resources.join(", "));
+      console.log("\n" + pc3.bold("Quick Examples:"));
+      for (const ex of contextData.quickExamples) {
+        console.log(`  $ ${pc3.dim(ex)}`);
+      }
+    });
+  });
+  program2.command("schema [resource]").description(
+    "Output OpenAPI schemas for resources (issue, project, team, comment, label) or --all"
+  ).option("-a, --all", "Output full OpenAPI document").option("-j, --json", "Output raw JSON").action(async function(resource, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const config = loadConfig();
+      const basePath = (globals.apiUrl || config.apiUrl || "").replace(/\/+$/, "");
+      const response = await fetch(`${basePath}/openapi.json`);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch schema from ${basePath}/openapi.json: HTTP ${response.status}`
+        );
+      }
+      const doc = await response.json();
+      let result = doc;
+      if (resource && !opts.all) {
+        const key = resource.toLowerCase();
+        const components = doc.components?.schemas || {};
+        const matchedKey = Object.keys(components).find((k) => k.toLowerCase().startsWith(key));
+        if (matchedKey) {
+          result = { [matchedKey]: components[matchedKey] };
+        } else {
+          console.error(
+            pc3.red(
+              `Schema for resource "${resource}" not found. Available: ${Object.keys(components).join(", ")}`
+            )
+          );
+          process.exit(4);
+        }
+      }
+      printJsonOrFormatted(result, globals.json ?? true, () => {
+        console.log(JSON.stringify(result, null, 2));
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(pc3.red("Error fetching schema:"), message);
+      process.exit(1);
+    }
+  });
+  withExamples(
+    program2.commands.find((c) => c.name() === "context"),
+    ["onus context", "onus context --json"]
+  );
+  withExamples(
+    program2.commands.find((c) => c.name() === "schema"),
+    ["onus schema", "onus schema issue", "onus schema --all"]
+  );
+}
+
+// src/commands/me.ts
+function registerMeCommand(program2) {
+  program2.command("me").description("Get the authenticated viewer profile").option("-j, --json", "Output raw JSON").action(async function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const viewer = await client.meGet();
+      printJsonOrFormatted(viewer, globals.json, () => {
+        console.log(
+          formatRecord([
+            { label: "Name", value: viewer.full_name },
+            { label: "Role", value: viewer.role },
+            { label: "ID", value: viewer.id }
+          ])
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    program2.commands.find((c) => c.name() === "me"),
+    ["onus me", "onus me --json"]
+  );
+}
+
+// src/teams.ts
+import pc4 from "picocolors";
+var TEAM_UUID_RE = /^[0-9a-f-]{36}$/i;
+async function resolveTeamId(client, team) {
+  if (TEAM_UUID_RE.test(team)) return team;
+  const teams = await client.teamsGet();
+  const match = (teams ?? []).find((t) => t.key?.toUpperCase() === team.toUpperCase());
+  if (!match) {
+    console.error(pc4.red(`Unknown team key: ${team}`));
+    process.exit(2);
+  }
+  return match.id;
+}
+
+// src/commands/team.ts
+function registerTeamCommands(program2) {
+  const team = program2.command("team").description("List and inspect Onus teams (read-only)");
+  team.command("list").description("List all teams").option("-j, --json", "Output raw JSON").action(async function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const data = await client.teamsGet();
+      const items = Array.isArray(data) ? data : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No teams found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((t) => [
+              { label: "ID", value: t.id },
+              { label: "Name", value: t.name },
+              { label: "Key", value: t.key },
+              { label: "Icon", value: t.icon },
+              { label: "Color", value: t.color }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  team.command("get <team>").description("Get a single team by UUID or KEY (e.g. ONUS)").option("-j, --json", "Output raw JSON").action(async function(team2) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const id = await resolveTeamId(client, team2);
+      const teamRow = await client.teamsIdGet({ id });
+      printJsonOrFormatted(teamRow, globals.json, () => {
+        console.log(
+          formatRecord([
+            { label: "ID", value: teamRow.id },
+            { label: "Name", value: teamRow.name },
+            { label: "Key", value: teamRow.key },
+            { label: "Icon", value: teamRow.icon },
+            { label: "Color", value: teamRow.color }
+          ])
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    team.commands.find((c) => c.name() === "list"),
+    ["onus team list", "onus team list --json"]
+  );
+  withExamples(
+    team.commands.find((c) => c.name() === "get"),
+    ["onus team get <teamId>", "onus team get ONUS"]
+  );
+}
+
+// src/commands/analytics.ts
+function registerAnalyticsCommands(program2) {
+  const analytics = program2.command("analytics").description("Query team analytics (read-only)");
+  analytics.command("overview").description("Visitors, pageviews, sessions, bounce and duration with previous-period deltas").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--from <from>", "Range start (ISO 8601 with offset)").option("--to <to>", "Range end (ISO 8601 with offset)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const overview = await client.analyticsOverviewGet({
+        teamId,
+        ...opts.from ? { from: new Date(opts.from) } : {},
+        ...opts.to ? { to: new Date(opts.to) } : {}
+      });
+      printJsonOrFormatted(overview, globals.json, () => {
+        const periods = overview;
+        console.log(
+          formatRecordList(
+            [
+              "visitors",
+              "pageviews",
+              "sessions",
+              "bounce_rate",
+              "median_session_duration_seconds"
+            ].map((metric) => [
+              { label: "Metric", value: metric },
+              {
+                label: "Current",
+                value: periods.current?.[metric] != null ? String(periods.current[metric]) : null
+              },
+              {
+                label: "Previous",
+                value: periods.previous?.[metric] != null ? String(periods.previous[metric]) : null
+              }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  analytics.command("events").description("List ingested event names with counts, ordered by volume").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--limit <limit>", "Maximum number of event names (1-500, default 100)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const limit = opts.limit === void 0 ? void 0 : Number(opts.limit);
+      const events = await client.analyticsEventsGet({ teamId, limit });
+      const items = Array.isArray(events) ? events : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No events ingested yet.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((e) => [
+              { label: "Event", value: e.event },
+              { label: "Count", value: String(e.count) },
+              { label: "Last Seen", value: e.last_seen == null ? null : String(e.last_seen) }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  analytics.command("query").description(
+    "Execute a trends or funnel query (JSON body; paths and property math are rejected)"
+  ).requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").requiredOption(
+    "--query <json>",
+    `Query payload, e.g. '{"type":"trends","series":[{"event":"signup"}]}'`
+  ).option("--from <from>", "Range start (ISO 8601 with offset)").option("--to <to>", "Range end (ISO 8601 with offset)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      let query;
+      try {
+        query = JSON.parse(opts.query);
+      } catch {
+        throw new Error("--query must be valid JSON");
+      }
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const result = await client.analyticsQueryPost({
+        analyticsQueryPostRequest: {
+          team_id: teamId,
+          query,
+          ...opts.from || opts.to ? {
+            from: opts.from ? new Date(opts.from) : null,
+            to: opts.to ? new Date(opts.to) : null
+          } : {}
+        }
+      });
+      printJsonOrFormatted(result, globals.json, () => {
+        const record = result;
+        if (Array.isArray(record.steps)) {
+          console.log(
+            formatRecordList(
+              record.steps.map(
+                (s, i) => [
+                  { label: "Step", value: String(i + 1) },
+                  { label: "Event", value: s.event },
+                  { label: "Count", value: String(s.count) },
+                  { label: "Overall", value: String(s.overall) }
+                ]
+              )
+            )
+          );
+        } else if (Array.isArray(record.series)) {
+          console.log(
+            formatRecordList(
+              record.series.map((s) => [
+                { label: "Series", value: s.label },
+                { label: "Event", value: s.event },
+                { label: "Math", value: s.math },
+                { label: "Total", value: s.rows?.total != null ? String(s.rows.total) : null }
+              ])
+            )
+          );
+        } else {
+          console.log(JSON.stringify(result, null, 2));
+        }
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    analytics.commands.find((c) => c.name() === "overview"),
+    [
+      "onus analytics overview --team ONUS",
+      "onus analytics overview --team ONUS --from 2026-08-01T00:00:00+00:00 --to 2026-08-31T23:59:59+00:00 --json"
+    ]
+  );
+  withExamples(
+    analytics.commands.find((c) => c.name() === "events"),
+    ["onus analytics events --team ONUS", "onus analytics events --team ONUS --limit 25 --json"]
+  );
+  withExamples(
+    analytics.commands.find((c) => c.name() === "query"),
+    [
+      `onus analytics query --team ONUS --query '{"type":"trends","series":[{"event":"signup"}]}' --json`,
+      `onus analytics query --team ONUS --query '{"type":"funnel","steps":[{"event":"signup"},{"event":"pay"}]}'`
+    ]
+  );
+}
+
+// src/commands/project.ts
+import { readFileSync } from "fs";
+function resolveAgentContext(text, file) {
+  if (file !== void 0 && text !== void 0) {
+    throw new Error("--agent-context and --agent-context-file cannot be used together");
+  }
+  if (file !== void 0) return readFileSync(file, "utf8");
+  return text;
+}
+function previewAgentContext(value) {
+  if (!value) return null;
+  const firstLine = value.split("\n")[0].trim();
+  const truncated = value.includes("\n") || firstLine.length > 80;
+  return truncated ? `${firstLine.slice(0, 79)}\u2026` : firstLine;
+}
+function registerProjectCommands(program2) {
+  const project = program2.command("project").description("Manage Onus projects");
+  project.command("list").description("List projects").option("-j, --json", "Output raw JSON").action(async function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const data = await client.projectsGet();
+      const items = Array.isArray(data) ? data : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No projects found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((p) => [
+              { label: "ID", value: p.id },
+              { label: "Name", value: p.name },
+              { label: "Description", value: p.description ?? null },
+              { label: "Status", value: p.status },
+              { label: "To Date", value: p.target_date },
+              { label: "Lead", value: p.lead?.full_name ?? (p.lead_id ? p.lead_id : null) }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  project.command("get <id>").description("Get a single project by UUID").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const project2 = await client.projectsIdGet({ id });
+      printJsonOrFormatted(project2, globals.json, () => {
+        console.log(
+          formatRecord([
+            { label: "ID", value: project2.id },
+            { label: "Name", value: project2.name },
+            { label: "Description", value: project2.description ?? null },
+            { label: "Agent context", value: previewAgentContext(project2.agent_context) },
+            { label: "Status", value: project2.status },
+            { label: "To Date", value: project2.target_date }
+          ])
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  project.command("create").description("Create a new project").requiredOption("--name <name>", "Project name").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--status <status>", "Project status (backlog|planned|in_progress|completed|canceled)").option("--priority <priority>", "Priority (none|urgent|high|medium|low)").option("--lead <leadId>", "Lead user UUID").option("--target-date <date>", "Target completion date (ISO)").option("--description <text>", "Project description (rendered under the title)").option(
+    "--agent-context <text>",
+    "Agent context markdown (agents.md-style guidance; '' clears)"
+  ).option("--agent-context-file <path>", "Read agent context markdown from a file").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const agentContext = resolveAgentContext(opts.agentContext, opts.agentContextFile);
+      const project2 = await client.projectsPost({
+        projectsPostRequest: {
+          team_id: teamId,
+          name: opts.name,
+          status: opts.status,
+          priority: opts.priority,
+          lead_id: opts.lead,
+          target_date: opts.targetDate,
+          description: opts.description,
+          agent_context: agentContext
+        }
+      });
+      printJsonOrFormatted(project2, globals.json, () => {
+        formatSuccess(`Created project "${project2.name}" (${project2.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  project.command("update <id>").description("Update an existing project by UUID").option("--name <name>", "Project name").option("--status <status>", "Project status (backlog|planned|in_progress|completed|canceled)").option("--priority <priority>", "Priority (none|urgent|high|medium|low)").option("--lead <leadId>", "Lead user UUID").option("--target-date <date>", "Target completion date (ISO)").option("--description <text>", "Project description (rendered under the title)").option(
+    "--agent-context <text>",
+    "Agent context markdown (agents.md-style guidance; '' clears)"
+  ).option("--agent-context-file <path>", "Read agent context markdown from a file").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const agentContext = resolveAgentContext(opts.agentContext, opts.agentContextFile);
+      const project2 = await client.projectsIdPatch({
+        id,
+        projectsIdPatchRequest: {
+          name: opts.name,
+          status: opts.status,
+          priority: opts.priority,
+          lead_id: opts.lead,
+          target_date: opts.targetDate,
+          description: opts.description,
+          agent_context: agentContext
+        }
+      });
+      printJsonOrFormatted(project2, globals.json, () => {
+        formatSuccess(`Updated project "${project2.name}" (${project2.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  const attachment = project.command("attachment").description("List attachments associated with a project");
+  attachment.command("list <id>").description("List attachments on a project").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const items = await client.projectsIdAttachmentsGet({ id });
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No attachments found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((a) => [
+              { label: "ID", value: a.id },
+              { label: "Filename", value: a.filename },
+              { label: "Type", value: a.content_type },
+              { label: "Size", value: a.size_bytes == null ? null : String(a.size_bytes) },
+              { label: "Uploader", value: a.uploader?.full_name }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    project.commands.find((c) => c.name() === "list"),
+    ["onus project list", "onus project list --json"]
+  );
+  withExamples(
+    project.commands.find((c) => c.name() === "get"),
+    ["onus project get <projectId>", "onus project get <projectId> --json"]
+  );
+  withExamples(
+    project.commands.find((c) => c.name() === "create"),
+    [
+      'onus project create --name "Website" --team ONUS',
+      'onus project create --name "Mobile" --team ONUS --priority high --target-date <YYYY-MM-DD>',
+      'onus project create --name "Migration" --team ONUS --agent-context-file AGENTS.md'
+    ]
+  );
+  withExamples(
+    project.commands.find((c) => c.name() === "update"),
+    [
+      "onus project update <projectId> --status in_progress",
+      "onus project update <projectId> --agent-context 'Add debug logging to all new code'",
+      "onus project update <projectId> --agent-context ''   # clears agent context"
+    ]
+  );
+  withExamples(
+    attachment.commands.find((c) => c.name() === "list"),
+    ["onus project attachment list <projectId>", "onus project attachment list <projectId> --json"]
+  );
+}
+
+// src/commands/issue.ts
+import { readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { basename } from "path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CLEAR_SENTINELS = /* @__PURE__ */ new Set(["null", "none", ""]);
+function isClearSentinel(value) {
+  return CLEAR_SENTINELS.has(value.trim().toLowerCase());
+}
+function collect(value, previous) {
+  return [...previous ?? [], value];
+}
+function refToRelationTarget(ref) {
+  return UUID_RE.test(ref) ? { related_issue_id: ref } : { related_issue_ref: ref };
+}
+var MIME_BY_EXT = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".mp4": "video/mp4",
+  ".mp3": "audio/mpeg"
+};
+function contentTypeFor(filename) {
+  const dot = filename.lastIndexOf(".");
+  if (dot >= 0) {
+    const guess = MIME_BY_EXT[filename.slice(dot).toLowerCase()];
+    if (guess) return guess;
+  }
+  return "application/octet-stream";
+}
+function registerIssueCommands(program2) {
+  const issue = program2.command("issue").description("Manage Onus issues");
+  issue.command("list").description("List and filter issues").option("-j, --json", "Output raw JSON").option("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--project <projectId>", "Filter by project UUID").option("--assignee <assigneeId>", "Filter by assignee UUID").option("--parent <parentId>", "Filter by parent issue UUID").option("--status <status>", "Filter by status (backlog|todo|in_progress|done|canceled)").option("--q <query>", "Free-text search query").option(
+    "--created-after <date>",
+    "Inclusive lower bound on created_at (yyyy-MM-dd or ISO datetime)"
+  ).option(
+    "--created-before <date>",
+    "Inclusive upper bound on created_at (yyyy-MM-dd or ISO datetime)"
+  ).option(
+    "--updated-after <date>",
+    "Inclusive lower bound on updated_at (yyyy-MM-dd or ISO datetime)"
+  ).option(
+    "--updated-before <date>",
+    "Inclusive upper bound on updated_at (yyyy-MM-dd or ISO datetime)"
+  ).option(
+    "--completed-after <date>",
+    "Inclusive lower bound on completed_at (yyyy-MM-dd or ISO datetime)"
+  ).option(
+    "--completed-before <date>",
+    "Inclusive upper bound on completed_at (yyyy-MM-dd or ISO datetime)"
+  ).option("--due-after <date>", "Inclusive lower bound on due_date (yyyy-MM-dd)").option("--due-before <date>", "Inclusive upper bound on due_date (yyyy-MM-dd)").option("--limit <n>", "Limit result count", (v) => Number(v)).option("--cursor <cursor>", "Pagination cursor").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = opts.team ? await resolveTeamId(client, opts.team) : void 0;
+      const response = await client.issuesGet({
+        status: opts.status,
+        teamId,
+        assigneeId: opts.assignee,
+        projectId: opts.project,
+        parentId: opts.parent,
+        q: opts.q,
+        createdAfter: opts.createdAfter,
+        createdBefore: opts.createdBefore,
+        updatedAfter: opts.updatedAfter,
+        updatedBefore: opts.updatedBefore,
+        completedAfter: opts.completedAfter,
+        completedBefore: opts.completedBefore,
+        dueAfter: opts.dueAfter,
+        dueBefore: opts.dueBefore,
+        limit: opts.limit,
+        cursor: opts.cursor
+      });
+      const items = response?.data ?? [];
+      printJsonOrFormatted(response, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No issues found.");
+          return;
+        }
+        for (const issue2 of items) {
+          const ref = issue2.identifier != null ? `#${issue2.identifier}` : issue2.id;
+          const parts = [
+            issue2.status,
+            issue2.priority,
+            issue2.team?.name,
+            issue2.assignee?.full_name
+          ].filter((p) => p != null && p !== "");
+          console.log(`\u2022 ${ref}  ${sanitizeTerminal(issue2.title ?? "\u2014")}`);
+          if (parts.length > 0) {
+            console.log(`    ${parts.map((p) => sanitizeTerminal(String(p))).join(" \xB7 ")}`);
+          }
+        }
+        if (response?.next_cursor) {
+          console.log(`
+Next cursor: ${sanitizeTerminal(response.next_cursor)}`);
+        }
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("get <ref>").alias("view").description("Get full issue detail (reference like TEAM-42, or UUID)").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const issue2 = await client.issuesIdGet({ id });
+      printJsonOrFormatted(issue2, globals.json, () => {
+        console.log(
+          formatRecord([
+            { label: "ID", value: issue2.id },
+            { label: "Title", value: issue2.title },
+            { label: "Status", value: issue2.status },
+            { label: "Priority", value: issue2.priority },
+            {
+              label: "Identifier",
+              value: issue2.identifier != null ? String(issue2.identifier) : null
+            }
+          ])
+        );
+        if (issue2.description) {
+          console.log(`
+Description:
+${sanitizeTerminal(issue2.description)}`);
+        }
+        if (issue2.comments?.length) {
+          console.log(`
+Comments (${issue2.comments.length}):`);
+          for (const comment of issue2.comments) {
+            console.log(
+              `  [${comment.id}] ${sanitizeTerminal(
+                comment.author?.full_name ?? "\u2014"
+              )}: ${sanitizeTerminal(comment.body)}`
+            );
+          }
+        }
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("create").description("Create a new issue").option("--title <title>", "Issue title").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("-d, --description <description>", "Issue description (markdown)").option("--status <status>", "Status (backlog|todo|in_progress|done|canceled)").option("--priority <priority>", "Priority (none|urgent|high|medium|low)").option("--assignee <assigneeId>", "Assignee UUID").option("--project <projectId>", "Project UUID").option("--parent <parentId>", "Parent issue UUID").option("--label <labelId>", "Label UUID to attach (repeatable)", collect, []).option(
+    "--template <nameOrId>",
+    "Issue template: UUID or exact name within the team; fills omitted fields"
+  ).option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      let title = opts.title;
+      let description = opts.description;
+      let priority = opts.priority;
+      let labels = (opts.label ?? []).length > 0 ? opts.label : void 0;
+      if (opts.template) {
+        const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+          opts.template
+        );
+        let template;
+        if (isUuid) {
+          try {
+            template = await client.templatesIdGet({ id: opts.template });
+          } catch {
+            template = void 0;
+          }
+        }
+        if (!template) {
+          const teamTemplates = await client.templatesGet({ teamId });
+          template = (teamTemplates ?? []).find((t) => t.name === opts.template);
+        }
+        if (!template) {
+          throw new Error(`unknown template "${opts.template}"`);
+        }
+        if (title === void 0 && template.title) title = template.title;
+        if (description === void 0 && template.description) description = template.description;
+        if (priority === void 0 && template.priority && template.priority !== "none") {
+          priority = template.priority;
+        }
+        if (labels === void 0 && (template.preset_label_ids ?? []).length > 0) {
+          labels = template.preset_label_ids;
+        }
+      }
+      if (title === void 0 || String(title).trim().length === 0) {
+        throw new Error("title is required (or provide --template that defines one)");
+      }
+      const issue2 = await client.issuesPost({
+        issuesPostRequest: {
+          team_id: teamId,
+          title,
+          description,
+          status: opts.status,
+          priority,
+          assignee_id: opts.assignee,
+          project_id: opts.project,
+          parent_id: opts.parent,
+          labels
+        }
+      });
+      printJsonOrFormatted(issue2, globals.json, () => {
+        formatSuccess(`Created issue "${issue2.title}" (${issue2.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("update <ref>").alias("edit").description("Update (or edit) an existing issue by reference").option("--title <title>", "Issue title").option("-d, --description <description>", "Issue description").option("--status <status>", "Status (backlog|todo|in_progress|done|canceled)").option("--priority <priority>", "Priority (none|urgent|high|medium|low)").option("--assignee <assigneeId>", "Assignee UUID").option("--project <projectId>", "Project UUID").option("--parent <parentId>", 'Parent issue UUID (pass "null", "none", or "" to clear)').option("--add-label <labelId>", "Label UUID to add (repeatable)", collect, []).option(
+    "--remove-label <labelId>",
+    "Label UUID to remove (repeatable)",
+    collect,
+    []
+  ).option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const patch = {};
+      if (opts.title !== void 0) patch.title = opts.title;
+      if (opts.description !== void 0) patch.description = opts.description;
+      if (opts.status !== void 0) patch.status = opts.status;
+      if (opts.priority !== void 0) patch.priority = opts.priority;
+      if (opts.assignee !== void 0) patch.assignee_id = opts.assignee;
+      if (opts.project !== void 0) patch.project_id = opts.project;
+      if (opts.parent !== void 0)
+        patch.parent_id = isClearSentinel(opts.parent) ? null : opts.parent;
+      let issue2;
+      if (Object.keys(patch).length > 0) {
+        issue2 = await client.issuesIdPatch({ id, issuesIdPatchRequest: patch });
+      } else {
+        issue2 = await client.issuesIdGet({ id });
+      }
+      for (const labelId of opts.addLabel ?? []) {
+        await client.issuesIdLabelsPost({ id, issuesIdLabelsPostRequest: { label_id: labelId } });
+      }
+      for (const labelId of opts.removeLabel ?? []) {
+        await client.issuesIdLabelsLabelIdDelete({ id, labelId });
+      }
+      printJsonOrFormatted(issue2, globals.json, () => {
+        formatSuccess(`Updated issue "${issue2.title}" (${issue2.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("delete <ref>").description("Delete an issue by reference").option("-y, --yes", "Skip confirmation").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    if (!opts.yes) {
+      console.error("Destructive operation. Re-run with --yes to confirm deletion.");
+      process.exit(2);
+    }
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.issuesIdDelete({ id });
+      if (globals.json) {
+        console.log(JSON.stringify({ ok: true, id }, null, 2));
+      } else {
+        formatSuccess(`Deleted issue ${id}.`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    issue.commands.find((c) => c.name() === "list"),
+    [
+      "onus issue list",
+      "onus issue list --status in_progress --team ONUS",
+      "onus issue list --json"
+    ]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "get"),
+    ["onus issue get <issueId>"]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "create"),
+    [
+      'onus issue create --title "Fix login bug" --team ONUS',
+      'onus issue create --title "Ship v2" --team ONUS --priority high --project <projectId>'
+    ]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "update"),
+    [
+      "onus issue update <issueId> --status done",
+      "onus issue update <issueId> --priority urgent --assignee <assigneeId>"
+    ]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "delete"),
+    ["onus issue delete <issueId> --yes"]
+  );
+  registerIssueCommentCommands(issue);
+  registerIssueRelationCommands(issue);
+  registerIssueAttachmentCommands(issue);
+  registerIssueSubscriptionCommands(issue);
+  registerIssuePrCommands(issue);
+}
+function registerIssueCommentCommands(issue) {
+  const comment = issue.command("comment").description("Create, list, edit, and delete issue comments");
+  comment.command("create <ref>").description("Post a comment on an issue").requiredOption("--body <body>", "Comment body text (markdown)").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const c = await client.issuesIdCommentsPost({
+        id,
+        commentsCommentIdPatchRequest: { body: opts.body }
+      });
+      printJsonOrFormatted(c, globals.json, () => formatSuccess(`Posted comment ${c.id}.`));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  comment.command("list <ref>").description("List comments for an issue").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const data = await client.issuesIdCommentsGet({ id });
+      const items = Array.isArray(data) ? data : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No comments found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((c) => [
+              { label: "ID", value: c.id },
+              { label: "Author", value: c.author?.full_name },
+              { label: "Created", value: c.created_at },
+              { label: "Body", value: c.body }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  comment.command("edit <ref>").description("Edit an existing comment").requiredOption("--comment <commentId>", "Comment UUID").requiredOption("--body <body>", "New comment body text").option("-j, --json", "Output raw JSON").action(async function(_id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const c = await client.commentsCommentIdPatch({
+        commentId: opts.comment,
+        commentsCommentIdPatchRequest: { body: opts.body }
+      });
+      printJsonOrFormatted(c, globals.json, () => formatSuccess(`Updated comment ${c.id}.`));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  comment.command("delete <ref>").description("Delete a comment").requiredOption("--comment <commentId>", "Comment UUID").option("-j, --json", "Output raw JSON").action(async function(_id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.commentsCommentIdDelete({ commentId: opts.comment });
+      if (globals.json) {
+        console.log(JSON.stringify({ ok: true, commentId: opts.comment }, null, 2));
+      } else {
+        formatSuccess(`Deleted comment ${opts.comment}.`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    comment.commands.find((c) => c.name() === "create"),
+    ['onus issue comment create <issueId> --body "Thanks for the fix!"']
+  );
+  withExamples(
+    comment.commands.find((c) => c.name() === "list"),
+    ["onus issue comment list <issueId>"]
+  );
+  withExamples(
+    comment.commands.find((c) => c.name() === "edit"),
+    ['onus issue comment edit <issueId> --comment <commentId> --body "Updated text"']
+  );
+  withExamples(
+    comment.commands.find((c) => c.name() === "delete"),
+    ["onus issue comment delete <issueId> --comment <commentId>"]
+  );
+}
+function registerIssueRelationCommands(issue) {
+  const relation = issue.command("relation").description("Manage issue relations");
+  relation.command("add <ref>").description("Relate one issue to another").requiredOption("--with <ref>", "Target issue (TEAM-42 or UUID)").requiredOption("--type <type>", "Relation type (blocks|duplicate|related|similar)").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const row = await client.issuesIdRelationsPost({
+        id,
+        issuesIdRelationsPostRequest: {
+          ...refToRelationTarget(opts.with),
+          type: opts.type
+        }
+      });
+      printJsonOrFormatted(row, globals.json, () => {
+        formatSuccess(`Added ${opts.type} relation (${row.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  relation.command("remove <ref>").description("Remove a relation from an issue").requiredOption("--relation <relationId>", "Relation UUID").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.issuesIdRelationsRelationIdDelete({ id, relationId: opts.relation });
+      if (globals.json) {
+        console.log(JSON.stringify({ ok: true, relationId: opts.relation }, null, 2));
+      } else {
+        formatSuccess(`Removed relation ${opts.relation}.`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    relation.commands.find((c) => c.name() === "add"),
+    ["onus issue relation add <issueId> --with TEAM-42 --type blocks"]
+  );
+  withExamples(
+    relation.commands.find((c) => c.name() === "remove"),
+    ["onus issue relation remove <issueId> --relation <relationId>"]
+  );
+}
+function registerIssueAttachmentCommands(issue) {
+  const attachment = issue.command("attachment").description("Upload, download, list, and delete issue attachments");
+  attachment.command("upload <ref>").description("Upload a file attachment to an issue").requiredOption("--file <path>", "Path to the file to upload").option("--name <name>", "Override stored filename").option("--type <type>", "Override content type").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const filename = opts.name ?? basename(opts.file);
+      const contentType = opts.type ?? contentTypeFor(filename);
+      const stat = statSync(opts.file);
+      const sizeBytes = stat.size;
+      const content = readFileSync2(opts.file);
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const upload = await client.issuesIdAttachmentsPost({
+        id,
+        issuesIdAttachmentsPostRequest: {
+          filename,
+          content_type: contentType,
+          size_bytes: sizeBytes
+        }
+      });
+      const res = await fetch(upload.upload_url, {
+        method: "PUT",
+        body: content,
+        headers: { "Content-Type": contentType, "x-upsert": "false" }
+      });
+      if (!res.ok) throw new Error(`upload failed with HTTP ${res.status}`);
+      printJsonOrFormatted(upload, globals.json, () => {
+        formatSuccess(`Uploaded "${filename}" (${upload.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  attachment.command("download <ref>").description("Download an attachment to a local file").requiredOption("--attachment <attachmentId>", "Attachment UUID").option("--output <path>", "Output file path (defaults to the attachment filename)").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const { download_url } = await client.attachmentsIdDownloadUrlGet({ id: opts.attachment });
+      const res = await fetch(download_url);
+      if (!res.ok) throw new Error(`download failed with HTTP ${res.status}`);
+      const buffer = Buffer.from(await res.arrayBuffer());
+      let output = opts.output;
+      if (!output) {
+        const issue2 = await client.issuesIdGet({ id });
+        const attach = (issue2.attachments ?? []).find((a) => a.id === opts.attachment);
+        output = attach?.filename ?? opts.attachment;
+      }
+      writeFileSync(output, buffer);
+      printJsonOrFormatted({ ok: true, path: output, bytes: buffer.length }, globals.json, () => {
+        formatSuccess(`Downloaded ${buffer.length} bytes to ${output}.`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  attachment.command("list <ref>").description("List attachments on an issue").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const issue2 = await client.issuesIdGet({ id });
+      const items = issue2.attachments ?? [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No attachments found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((a) => [
+              { label: "ID", value: a.id },
+              { label: "Filename", value: a.filename },
+              { label: "Type", value: a.content_type },
+              { label: "Size", value: a.size_bytes != null ? String(a.size_bytes) : null },
+              { label: "Uploader", value: a.uploader?.full_name }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  attachment.command("delete <ref>").description("Delete an attachment from an issue").requiredOption("--attachment <attachmentId>", "Attachment UUID").option("-j, --json", "Output raw JSON").action(async function(_id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.attachmentsIdDelete({ id: opts.attachment });
+      if (globals.json) {
+        console.log(JSON.stringify({ ok: true, attachmentId: opts.attachment }, null, 2));
+      } else {
+        formatSuccess(`Deleted attachment ${opts.attachment}.`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    attachment.commands.find((c) => c.name() === "upload"),
+    ["onus issue attachment upload <issueId> --file ./report.pdf"]
+  );
+  withExamples(
+    attachment.commands.find((c) => c.name() === "download"),
+    ["onus issue attachment download <issueId> --attachment <attachmentId>"]
+  );
+  withExamples(
+    attachment.commands.find((c) => c.name() === "list"),
+    ["onus issue attachment list <issueId>"]
+  );
+  withExamples(
+    attachment.commands.find((c) => c.name() === "delete"),
+    ["onus issue attachment delete <issueId> --attachment <attachmentId>"]
+  );
+}
+function registerIssueSubscriptionCommands(issue) {
+  issue.command("subscribe <ref>").description("Subscribe the current user to an issue").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const res = await client.issuesIdSubscriptionPost({
+        id,
+        issuesIdSubscriptionPostRequest: { isSubscribed: true }
+      });
+      printJsonOrFormatted(res, globals.json, () => formatSuccess("Subscribed."));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("unsubscribe <ref>").description("Unsubscribe the current user from an issue").option("-j, --json", "Output raw JSON").action(async function(id) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const res = await client.issuesIdSubscriptionPost({
+        id,
+        issuesIdSubscriptionPostRequest: { isSubscribed: false }
+      });
+      printJsonOrFormatted(res, globals.json, () => formatSuccess("Unsubscribed."));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    issue.commands.find((c) => c.name() === "subscribe"),
+    ["onus issue subscribe <issueId>"]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "unsubscribe"),
+    ["onus issue unsubscribe <issueId>"]
+  );
+  registerIssueBulkCommands(issue);
+}
+var BULK_CHUNK = 100;
+async function runBulkChunks(client, request, idempotencyKey) {
+  const results = [];
+  let succeeded = 0;
+  let failed = 0;
+  const init = idempotencyKey ? { headers: { "Idempotency-Key": idempotencyKey } } : void 0;
+  for (let i = 0; i < request.items.length; i += BULK_CHUNK) {
+    const chunk = request.items.slice(i, i + BULK_CHUNK);
+    const res = await client.issuesBulkPost(
+      { issuesBulkPostRequest: { ...request, items: chunk } },
+      ...init ? [init] : []
+    );
+    results.push(...res.results ?? []);
+    succeeded += res.succeeded ?? 0;
+    failed += res.failed ?? 0;
+  }
+  return { results, succeeded, failed };
+}
+function registerIssueBulkCommands(issue) {
+  issue.command("bulk-update [refs...]").description("Batched update of issues with per-item partial success").option("--status <status>", "New status (backlog|todo|in_progress|done|canceled)").option("--priority <priority>", "New priority (none|urgent|high|medium|low)").option("--assignee <assigneeId>", "New assignee UUID").option("--project <projectId>", "New project UUID").option("--label <labelId>", "Label UUID; full replacement set (repeatable)", collect).option("--file <path>", "JSON file with extra update items [{ref, set}]").option("-j, --json", "Output raw JSON").action(async function(refs, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const set = {};
+      if (opts.status) set.status = opts.status;
+      if (opts.priority) set.priority = opts.priority;
+      if (opts.assignee) set.assignee_id = opts.assignee;
+      if (opts.project) set.project_id = opts.project;
+      if (opts.label?.length) set.labels = opts.label;
+      let items = refs.map((ref) => ({ ref, set }));
+      if (opts.file) {
+        const extra = JSON.parse(readFileSync2(opts.file, "utf8"));
+        items = items.concat(extra);
+      }
+      if (items.length === 0) throw new Error("no items provided");
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const out = await runBulkChunks(client, { operation: "update", items });
+      printJsonOrFormatted(out, globals.json, () => {
+        console.log(`${out.succeeded} succeeded, ${out.failed} failed.`);
+        for (const r of out.results.filter((r2) => !r2.ok)) {
+          console.error(`${r.index}: ${r.error?.code} \u2014 ${r.error?.message}`);
+        }
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("bulk-comment [refs...]").description("Batched comments on issues with dedup + idempotency support").requiredOption("--body <text>", "Comment body applied to every ref").option("--file <path>", "JSON file with extra comment items [{ref, body, client_token?}]").option("--idempotency-key <key>", "Retry-safe key: replays the stored response for 24h").option("-j, --json", "Output raw JSON").action(async function(refs, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      let items = refs.map((ref) => ({ ref, body: opts.body }));
+      if (opts.file) {
+        const extra = JSON.parse(readFileSync2(opts.file, "utf8"));
+        items = items.concat(extra);
+      }
+      if (items.length === 0) throw new Error("no items provided");
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const out = await runBulkChunks(
+        client,
+        { operation: "comment", items },
+        opts.idempotencyKey
+      );
+      printJsonOrFormatted(out, globals.json, () => {
+        console.log(`${out.succeeded} succeeded, ${out.failed} failed.`);
+        for (const r of out.results.filter((r2) => !r2.ok)) {
+          console.error(`${r.index}: ${r.error?.code} \u2014 ${r.error?.message}`);
+        }
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    issue.commands.find((c) => c.name() === "bulk-update"),
+    [
+      "onus issue bulk-update ENG-42 ENG-43 --status done",
+      "onus issue bulk-update ENG-42 --priority high --label <uuid>",
+      "onus issue bulk-update --file items.json"
+    ]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "bulk-comment"),
+    ['onus issue bulk-comment ENG-42 ENG-43 --body "Deployed" --idempotency-key run-17']
+  );
+}
+function registerIssuePrCommands(issue) {
+  issue.command("link-pr <ref>").description("Manually link an issue to a GitHub pull request").requiredOption("--repo <owner/name>", "GitHub repository (owner/name)").requiredOption("--pr <number>", "Pull request number", (v) => Number(v)).option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const res = await client.issuesIdPullRequestsPost({
+        id,
+        issuesIdPullRequestsPostRequest: { repo: opts.repo, number: opts.pr }
+      });
+      printJsonOrFormatted(res, globals.json, () => {
+        formatSuccess(`Linked PR ${opts.repo}#${opts.pr} (link ${res.id}).`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  issue.command("unlink-pr <ref>").description("Unlink a GitHub pull request from an issue").requiredOption("--pr-link <linkId>", "Pull request link UUID").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.issuesIdPullRequestsLinkIdDelete({ id, linkId: opts.prLink });
+      if (globals.json) {
+        console.log(JSON.stringify({ ok: true, linkId: opts.prLink }, null, 2));
+      } else {
+        formatSuccess(`Unlinked PR (${opts.prLink}).`);
+      }
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    issue.commands.find((c) => c.name() === "link-pr"),
+    ["onus issue link-pr <issueId> --repo owner/repo --pr 42"]
+  );
+  withExamples(
+    issue.commands.find((c) => c.name() === "unlink-pr"),
+    ["onus issue unlink-pr <issueId> --pr-link <linkId>"]
+  );
+}
+
+// src/commands/comment.ts
+function registerCommentCommands(program2) {
+  const comment = program2.command("comment").description("List and create issue comments");
+  comment.command("list <issueId>").description("List comments for an issue").option("-j, --json", "Output raw JSON").action(async function(issueId) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const data = await client.issuesIdCommentsGet({ id: issueId });
+      const items = Array.isArray(data) ? data : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No comments found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((c) => [
+              { label: "ID", value: c.id },
+              { label: "Author", value: c.author?.full_name },
+              { label: "Created", value: c.created_at },
+              { label: "Body", value: c.body }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  comment.command("create <issueId>").description("Post a comment on an issue").requiredOption("--body <body>", "Comment body text (markdown)").option("-j, --json", "Output raw JSON").action(async function(issueId, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const comment2 = await client.issuesIdCommentsPost({
+        id: issueId,
+        commentsCommentIdPatchRequest: { body: opts.body }
+      });
+      printJsonOrFormatted(comment2, globals.json, () => {
+        formatSuccess(`Posted comment ${comment2.id}.`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    comment.commands.find((c) => c.name() === "list"),
+    ["onus comment list <issueId>"]
+  );
+  withExamples(
+    comment.commands.find((c) => c.name() === "create"),
+    ['onus comment create <issueId> --body "Looks good to me"']
+  );
+}
+
+// src/commands/label.ts
+function registerLabelCommands(program2) {
+  const label = program2.command("label").description("List and create issue labels");
+  label.command("list").description("List all labels").option("-j, --json", "Output raw JSON").action(async function() {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const data = await client.labelsGet();
+      const items = Array.isArray(data) ? data : [];
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No labels found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((l) => [
+              { label: "ID", value: l.id },
+              { label: "Name", value: l.name },
+              { label: "Team", value: l.team_id },
+              { label: "Color", value: l.color }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  label.command("create").description("Create a new label").requiredOption("--name <name>", "Label name").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--color <color>", "Label color (hex)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const label2 = await client.labelsPost({
+        labelsPostRequest: {
+          team_id: teamId,
+          name: opts.name,
+          color: opts.color
+        }
+      });
+      printJsonOrFormatted(label2, globals.json, () => {
+        formatSuccess(`Created label "${label2.name}".`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    label.commands.find((c) => c.name() === "list"),
+    ["onus label list", "onus label list --json"]
+  );
+  withExamples(
+    label.commands.find((c) => c.name() === "create"),
+    ['onus label create --name "Bug" --team ONUS --color #e11d48']
+  );
+}
+
+// src/commands/dsn.ts
+function registerDsnCommands(program2) {
+  const dsn = program2.command("dsn").description("Manage team ingest keys (DSNs) \u2014 errors + analytics ingestion credentials");
+  dsn.command("list").description("List a team's ingest keys (masked \u2014 the secret is never re-shown)").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const items = await client.teamsIdIngestKeysGet({ id: teamId });
+      printJsonOrFormatted(items, globals.json, () => {
+        if (items.length === 0) {
+          console.log("No ingest keys found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((k) => [
+              { label: "ID", value: k.id },
+              { label: "Label", value: k.label },
+              { label: "Hint", value: k.key_hint },
+              { label: "Status", value: k.status },
+              { label: "DSN", value: k.dsn.replace(/^[^@]+/, (h) => `${h.slice(0, 4)}\u2026`) }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  dsn.command("create").description("Create an ingest key (the full secret is printed exactly once)").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("--label <label>", "Key label", "Default key").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const key = await client.teamsIdIngestKeysPost({
+        id: teamId,
+        teamsIdIngestKeysPostRequest: {
+          label: opts.label ?? "Default key"
+        }
+      });
+      printJsonOrFormatted(key, globals.json, () => {
+        formatSuccess("Key created \u2014 store this secret now, it is shown only once:");
+        console.log(key.dsn);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  dsn.command("rotate <keyId>").description("Rotate a key; the old secret stays valid for the grace window").option(
+    "--grace-seconds <seconds>",
+    "Zero-downtime cutover window (default 604800 = 7 days)",
+    "604800"
+  ).option("-j, --json", "Output raw JSON").action(async function(keyId, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const key = await client.ingestKeysIdRotatePost({
+        id: keyId,
+        ingestKeysIdRotatePostRequest: { grace_seconds: Number(opts.graceSeconds ?? 604800) }
+      });
+      printJsonOrFormatted(key, globals.json, () => {
+        formatSuccess("Key rotated \u2014 the new secret is shown only once:");
+        console.log(key.dsn);
+        if (key.grace_until)
+          console.log(`Old secret accepted until ${key.grace_until.toISOString()}`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  dsn.command("disable <keyId>").description("Disable an ingest key (reversible)").option("-j, --json", "Output raw JSON").action(async function(keyId) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.ingestKeysIdPatch({
+        id: keyId,
+        ingestKeysIdPatchRequest: { status: "disabled" }
+      });
+      printJsonOrFormatted({ ok: true }, globals.json, () => formatSuccess("Key disabled."));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  dsn.command("enable <keyId>").description("Re-enable a disabled ingest key").option("-j, --json", "Output raw JSON").action(async function(keyId) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.ingestKeysIdPatch({
+        id: keyId,
+        ingestKeysIdPatchRequest: { status: "active" }
+      });
+      printJsonOrFormatted({ ok: true }, globals.json, () => formatSuccess("Key enabled."));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  dsn.command("revoke <keyId>").description("Revoke an ingest key (terminal)").option("-j, --json", "Output raw JSON").action(async function(keyId) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.ingestKeysIdDelete({ id: keyId });
+      printJsonOrFormatted({ ok: true }, globals.json, () => formatSuccess("Key revoked."));
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    dsn.commands.find((c) => c.name() === "list"),
+    ["onus dsn list --team ONUS", "onus dsn list --team <teamId> --json"]
+  );
+  withExamples(
+    dsn.commands.find((c) => c.name() === "create"),
+    ["onus dsn create --team ONUS --label ci", "onus dsn create --team <teamId> --label ci --json"]
+  );
+  withExamples(
+    dsn.commands.find((c) => c.name() === "rotate"),
+    ["onus dsn rotate <keyId>", "onus dsn rotate <keyId> --grace-seconds 0"]
+  );
+  withExamples(
+    dsn.commands.find((c) => c.name() === "disable"),
+    ["onus dsn disable <keyId>"]
+  );
+  withExamples(
+    dsn.commands.find((c) => c.name() === "enable"),
+    ["onus dsn enable <keyId>"]
+  );
+  withExamples(
+    dsn.commands.find((c) => c.name() === "revoke"),
+    ["onus dsn revoke <keyId>"]
+  );
+}
+
+// src/commands/skill.ts
+import pc5 from "picocolors";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+
+// src/commands/skills-output-filter.ts
+var FAILED_HEADER_PATTERN = /Failed to install \d+/;
+var PROMPTSCRIPT_GLOBAL_ERROR_PATTERN = /→\s*PromptScript:\s*PromptScript does not support global skill installation/;
+var FAILURE_DETAIL_PATTERN = /✗/;
+function stripAnsi(line) {
+  return line.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+}
+function createPromptScriptGlobalFailureFilter() {
+  let held = null;
+  let rest = "";
+  const isBogusDetail = (plain) => PROMPTSCRIPT_GLOBAL_ERROR_PATTERN.test(plain);
+  const isBlockLine = (plain) => plain.trim() === "" || FAILED_HEADER_PATTERN.test(plain) || FAILURE_DETAIL_PATTERN.test(plain);
+  function resolveHeld() {
+    if (held === null) return "";
+    const lines = held;
+    held = null;
+    const hasGenuineDetail = lines.some((l) => {
+      const plain = stripAnsi(l);
+      return FAILURE_DETAIL_PATTERN.test(plain) && !isBogusDetail(plain);
+    });
+    if (!hasGenuineDetail) return "";
+    return lines.filter((l) => !isBogusDetail(stripAnsi(l))).join("");
+  }
+  return {
+    write(chunk) {
+      let out = "";
+      rest += chunk;
+      for (; ; ) {
+        const newlineIndex = rest.indexOf("\n");
+        if (newlineIndex === -1) break;
+        const line = rest.slice(0, newlineIndex + 1);
+        rest = rest.slice(newlineIndex + 1);
+        const plain = stripAnsi(line);
+        if (held !== null) {
+          if (isBlockLine(plain)) {
+            held.push(line);
+          } else {
+            out += resolveHeld() + line;
+          }
+        } else if (FAILED_HEADER_PATTERN.test(plain)) {
+          held = [line];
+        } else if (!isBogusDetail(plain)) {
+          out += line;
+        }
+      }
+      return out;
+    },
+    end() {
+      const out = resolveHeld() + rest;
+      rest = "";
+      return out;
+    }
+  };
+}
+
+// src/commands/skill.ts
+var SKILL_NAME = "onus-cli";
+var SKILLS_CLI_VERSION = "1.5.23";
+function resolveBundledSkillDir(startDir = path.dirname(fileURLToPath(import.meta.url))) {
+  let dir = startDir;
+  for (let i = 0; i < 4; i++) {
+    const candidate = path.join(dir, "skills", SKILL_NAME);
+    if (existsSync(path.join(candidate, "SKILL.md"))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    `Bundled "${SKILL_NAME}" skill not found (looked upward from ${startDir}). The installation may be corrupt.`
+  );
+}
+function buildSkillArgs(opts) {
+  const args = [];
+  if (opts.global) args.push("--global");
+  if (opts.agent?.length) args.push("--agent", ...opts.agent);
+  if (opts.copy) args.push("--copy");
+  return args;
+}
+function quoteArgForWindows(arg) {
+  return /\s/.test(arg) ? `"${arg}"` : arg;
+}
+async function runSkillsCli(args) {
+  const isWindows = process.platform === "win32";
+  const finalArgs = isWindows ? [`--yes`, `skills@${SKILLS_CLI_VERSION}`, ...args].map(quoteArgForWindows) : [`--yes`, `skills@${SKILLS_CLI_VERSION}`, ...args];
+  const filterGlobalFailures = args.includes("--global") && !args.includes("--agent");
+  const child = spawn("npx", finalArgs, {
+    stdio: filterGlobalFailures ? ["inherit", "pipe", "pipe"] : "inherit",
+    ...isWindows ? { shell: true } : {}
+  });
+  if (filterGlobalFailures) {
+    const pipeThroughFilter = (readable, target) => {
+      if (!readable) return;
+      const filter = createPromptScriptGlobalFailureFilter();
+      readable.setEncoding("utf8");
+      readable.on("data", (chunk) => {
+        const text = filter.write(chunk);
+        if (text) target.write(text);
+      });
+      readable.on("end", () => {
+        const rest = filter.end();
+        if (rest) target.write(rest);
+      });
+    };
+    pipeThroughFilter(child.stdout, process.stdout);
+    pipeThroughFilter(child.stderr, process.stderr);
+  }
+  let status;
+  try {
+    status = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code) => resolve(code));
+    });
+  } catch (err) {
+    console.error(
+      pc5.red("Failed to run the skills CLI (npx):"),
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  }
+  if (status !== 0) {
+    console.error(pc5.red(`Skills CLI exited with status ${status ?? "unknown"}.`));
+    process.exit(status ?? 1);
+  }
+}
+function addSharedOptions(cmd) {
+  return cmd.option("-g, --global", "Operate on the user-wide skill directory instead of the project").option("-a, --agent <agents...>", "Target specific agents (e.g. claude-code, codex)").option("-c, --copy", "Copy files instead of symlinking into agent directories");
+}
+function registerSkillCommands(program2) {
+  const skill = program2.command("skill").description(
+    `Manage the ${SKILL_NAME} agent skill for AI coding assistants (via the skills npm package)`
+  );
+  addSharedOptions(
+    skill.command("install").description(`Install the bundled ${SKILL_NAME} skill into detected AI agents`)
+  ).action(async function(opts) {
+    try {
+      const skillDir = resolveBundledSkillDir();
+      await runSkillsCli(["add", skillDir, "--yes", ...buildSkillArgs(opts)]);
+      console.log(
+        pc5.green(`
+${SKILL_NAME} skill installed. Agents can now use it to drive the Onus CLI.`)
+      );
+    } catch (err) {
+      console.error(
+        pc5.red("Error installing skill:"),
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  });
+  addSharedOptions(
+    skill.command("remove").alias("rm").description("Remove the installed skill from AI agents")
+  ).action(async function(opts) {
+    await runSkillsCli(["remove", SKILL_NAME, "--yes", ...buildSkillArgs(opts)]);
+    console.log(pc5.green(`
+${SKILL_NAME} skill removed.`));
+  });
+  addSharedOptions(
+    skill.command("update").description("Update installed copies of the skill to the bundled version")
+  ).action(async function(opts) {
+    try {
+      const skillDir = resolveBundledSkillDir();
+      await runSkillsCli(["add", skillDir, "--yes", ...buildSkillArgs(opts)]);
+      console.log(pc5.green(`
+${SKILL_NAME} skill updated.`));
+    } catch (err) {
+      console.error(
+        pc5.red("Error updating skill:"),
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  });
+  withExamples(
+    skill.commands.find((c) => c.name() === "install"),
+    [
+      "onus skill install",
+      "onus skill install --global",
+      "onus skill install --agent claude-code codex",
+      "onus skill install --copy"
+    ]
+  );
+  withExamples(
+    skill.commands.find((c) => c.name() === "remove"),
+    ["onus skill remove", "onus skill remove --agent claude-code"]
+  );
+  withExamples(
+    skill.commands.find((c) => c.name() === "update"),
+    ["onus skill update", "onus skill update --global"]
+  );
+}
+
+// src/commands/template.ts
+var PRIORITIES = ["urgent", "high", "medium", "low", "none"];
+function asPriority(value) {
+  return PRIORITIES.includes(value) ? value : void 0;
+}
+function collect2(value, previous) {
+  return [...previous, value];
+}
+function registerTemplateCommands(program2) {
+  const template = program2.command("template").description("Manage reusable per-team issue templates");
+  template.command("list").description("List issue templates (optionally for one team)").option("--team <team>", "Team UUID or KEY (e.g. ONUS)").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = opts.team ? await resolveTeamId(client, opts.team) : void 0;
+      const items = await client.templatesGet(teamId ? { teamId } : {});
+      printJsonOrFormatted(items, globals.json, () => {
+        if (!Array.isArray(items) || items.length === 0) {
+          console.log("No templates found.");
+          return;
+        }
+        console.log(
+          formatRecordList(
+            items.map((t) => [
+              { label: "ID", value: t.id },
+              { label: "Name", value: t.name },
+              { label: "Team", value: t.team_id },
+              { label: "Default", value: t.is_default ? "yes" : "no" }
+            ])
+          )
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  template.command("create").description("Create an issue template").requiredOption("--team <team>", "Team UUID or KEY (e.g. ONUS)").requiredOption("--name <name>", "Template name").option("--title <title>", "Title prefix applied on use").option("-d, --description <description>", "Description body (markdown)").option("--priority <priority>", `Priority (${PRIORITIES.join("|")})`).option("--label <labelId>", "Preset label UUID (repeatable)", collect2, []).option("--default", "Make this the team default template").option("-j, --json", "Output raw JSON").action(async function(opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const teamId = await resolveTeamId(client, opts.team);
+      const created = await client.templatesPost({
+        templatesPostRequest: {
+          team_id: teamId,
+          name: opts.name,
+          title: opts.title,
+          description: opts.description,
+          priority: opts.priority ? asPriority(opts.priority) : void 0,
+          preset_label_ids: (opts.label ?? []).length > 0 ? opts.label : void 0,
+          is_default: opts.default
+        }
+      });
+      printJsonOrFormatted(created, globals.json, () => {
+        formatSuccess(`Created template "${created.name}".`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  template.command("get <id>").description("Show a single issue template").option("-j, --json", "Output raw JSON").action(async function(id, _opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const row = await client.templatesIdGet({ id });
+      printJsonOrFormatted(row, globals.json, () => {
+        console.log(
+          formatRecord([
+            { label: "ID", value: row.id },
+            { label: "Name", value: row.name },
+            { label: "Team", value: row.team_id },
+            { label: "Title", value: row.title },
+            { label: "Priority", value: row.priority },
+            { label: "Labels", value: (row.preset_label_ids ?? []).join(", ") || null },
+            { label: "Default", value: row.is_default ? "yes" : "no" }
+          ])
+        );
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  template.command("update <id>").alias("edit").description("Update an issue template").option("--name <name>").option("--title <title>", 'Title prefix ("--title \\"\\" to clear)').option("-d, --description <description>", "Description body (markdown)").option("--priority <priority>", `Priority (${PRIORITIES.join("|")})`).option(
+    "--add-label <labelId>",
+    "Add a preset label UUID (repeatable)",
+    collect2,
+    []
+  ).option("--default", "Make this the team default template").option("--no-default", "Remove the default flag from this template").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      const defaultExplicit = opts.default === false ? false : opts.default === void 0 ? void 0 : true;
+      const added = opts.addLabel ?? [];
+      let mergedLabels;
+      if (added.length > 0) {
+        const current = await client.templatesIdGet({ id });
+        mergedLabels = Array.from(/* @__PURE__ */ new Set([...current.preset_label_ids ?? [], ...added]));
+      }
+      const updated = await client.templatesIdPatch({
+        id,
+        templatesIdPatchRequest: {
+          ...opts.name ? { name: opts.name } : {},
+          ...opts.title !== void 0 ? { title: opts.title } : {},
+          ...opts.description !== void 0 ? { description: opts.description } : {},
+          ...opts.priority ? { priority: asPriority(opts.priority) } : {},
+          ...mergedLabels ? { preset_label_ids: mergedLabels } : {},
+          ...defaultExplicit !== void 0 ? { is_default: defaultExplicit } : {}
+        }
+      });
+      printJsonOrFormatted(updated, globals.json, () => {
+        formatSuccess(`Updated template "${updated.name}".`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  template.command("delete <id>").description("Delete an issue template").option("-y, --yes", "Skip confirmation").option("-j, --json", "Output raw JSON").action(async function(id, opts) {
+    const globals = this.optsWithGlobals();
+    try {
+      if (!opts.yes && !globals.json) {
+        const { default: pc10 } = await import("picocolors");
+        const answer = await new Promise((resolve) => {
+          process.stdout.write(pc10.yellow(`Delete template ${id}? (y/N) `));
+          process.stdin.once("data", (d) => resolve(String(d).trim().toLowerCase()));
+        });
+        if (answer !== "y" && answer !== "yes") {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      const client = createApiClient({ token: globals.token, apiUrl: globals.apiUrl });
+      await client.templatesIdDelete({ id });
+      printJsonOrFormatted({ deleted: id }, globals.json, () => {
+        formatSuccess(`Deleted template ${id}.`);
+      });
+    } catch (err) {
+      await handleApiError(err, globals.json);
+    }
+  });
+  withExamples(
+    template.commands.find((c) => c.name() === "list"),
+    ["onus template list", "onus template list --team ONUS"]
+  );
+  withExamples(
+    template.commands.find((c) => c.name() === "create"),
+    ['onus template create --team ONUS --name "Bug report" --priority high --default']
+  );
+  withExamples(
+    template.commands.find((c) => c.name() === "get"),
+    ["onus template get <id>"]
+  );
+  withExamples(
+    template.commands.find((c) => c.name() === "update"),
+    ["onus template update <id> --priority urgent", "onus template update <id> --default"]
+  );
+  withExamples(
+    template.commands.find((c) => c.name() === "delete"),
+    ["onus template delete <id> --yes"]
+  );
+}
+
+// src/commands/watch.ts
+import pc6 from "picocolors";
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_MAX_MS = 3e4;
+function computeBackoff(attempt) {
+  return Math.min(BACKOFF_BASE_MS * 2 ** Math.max(0, attempt), BACKOFF_MAX_MS);
+}
+function parseSseFrames(raw) {
+  const frames = [];
+  let start = 0;
+  for (; ; ) {
+    const end = raw.indexOf("\n\n", start);
+    if (end === -1) break;
+    const block = raw.slice(start, end);
+    start = end + 2;
+    const lines = block.split("\n");
+    if (lines.every((l) => l.startsWith(":") || l.trim() === "")) continue;
+    const msg = { data: "" };
+    const dataLines = [];
+    for (const line of lines) {
+      if (line.startsWith("id:")) msg.id = line.slice(3).trim();
+      else if (line.startsWith("event:")) msg.event = line.slice(6).trim();
+      else if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
+    }
+    msg.data = dataLines.join("\n");
+    frames.push(msg);
+  }
+  return { frames, rest: raw.slice(start) };
+}
+var WatchStop = class extends Error {
+  constructor() {
+    super("watch-stop");
+  }
+};
+async function runWatch(opts, deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const out = deps.out ?? ((line) => console.log(line));
+  const decoder = new TextDecoder();
+  let cursor = null;
+  let attempt = 0;
+  try {
+    for (; ; ) {
+      const url = new URL(`${opts.apiUrl.replace(/\/+$/, "")}/v1/events/stream`);
+      if (opts.team) url.searchParams.set("team_id", opts.team);
+      if (opts.type) url.searchParams.set("type", opts.type);
+      const headers = {
+        Authorization: `Bearer ${opts.token}`,
+        Accept: "text/event-stream"
+      };
+      if (cursor != null) {
+        headers["Last-Event-ID"] = String(cursor);
+        url.searchParams.set("cursor", String(cursor));
+      }
+      const res = await fetchImpl(url, { headers });
+      if (res.status === 401 || res.status === 403) return 1;
+      if (!res.ok || !res.body) {
+        await sleep(computeBackoff(attempt++));
+        continue;
+      }
+      const reader = res.body.getReader();
+      let buffer = "";
+      let gotData = false;
+      let gracefulClose = false;
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const { frames, rest } = parseSseFrames(buffer);
+        buffer = rest;
+        for (const frame of frames) {
+          if (frame.event === "stream.close") {
+            try {
+              const closeData = JSON.parse(frame.data || "{}");
+              if (typeof closeData.last_seq === "number") cursor = closeData.last_seq;
+            } catch {
+            }
+            gracefulClose = true;
+            break;
+          }
+          let payload = {};
+          try {
+            payload = JSON.parse(frame.data || "{}");
+          } catch {
+          }
+          if (typeof payload.seq === "number") cursor = payload.seq;
+          gotData = true;
+          if (opts.json) out(frame.data);
+          else if (payload.replay === true)
+            out(`[replay] ${pc6.dim(`${frame.event} ${frame.data}`)}`);
+          else out(`${frame.event} ${frame.data}`);
+        }
+        if (gracefulClose) break;
+      }
+      if (gotData) attempt = 0;
+      if (!gracefulClose) await sleep(computeBackoff(attempt++));
+    }
+  } catch (err) {
+    if (err instanceof WatchStop) return 0;
+    throw err;
+  }
+}
+function registerWatchCommand(program2) {
+  program2.command("watch").description("Stream live issue/comment/error events (SSE) with automatic resume").option("--team <keyOrId>", "Limit to one team (key like HOT or a team UUID)").option("--type <types>", "Comma-separated event types to allowlist").option("-j, --json", "Output NDJSON data lines instead of formatted output");
+  withExamples(
+    program2.commands.find((c) => c.name() === "watch"),
+    [
+      "onus watch",
+      "onus watch --team HOT --type issue.status_changed,error_group.regressed",
+      "onus watch --json"
+    ]
+  );
+  program2.commands.find((c) => c.name() === "watch").action(async function() {
+    const globals = this.optsWithGlobals();
+    const { loadConfig: loadConfig2 } = await import("./config-FWANRWOT.js");
+    const config = loadConfig2();
+    const token = globals.token ?? config.token ?? "";
+    const apiUrl = globals.apiUrl ?? config.apiUrl;
+    const opts = this.opts();
+    let teamId = opts.team;
+    if (teamId) {
+      const { createApiClient: createApiClient2 } = await import("./client-QNEDGCP7.js");
+      const client = createApiClient2({ token, apiUrl });
+      teamId = await resolveTeamId(client, teamId);
+    }
+    const code = await runWatch(
+      { token, apiUrl, team: teamId, type: opts.type, json: opts.json },
+      {}
+    );
+    if (code !== 0) process.exitCode = code;
+  });
+}
+
+// src/program.ts
+function buildProgram() {
+  const program2 = new Command();
+  program2.name("onus").description("Official CLI and Agent Toolkit for Onus issue tracker").version(cliVersion).option("-j, --json", "Output pure JSON for machine parsing / agent interaction").option("-t, --token <token>", "Override authentication token").option("-u, --api-url <url>", "Override API base URL");
+  registerAuthCommands(program2);
+  registerContextCommands(program2);
+  registerMeCommand(program2);
+  registerTeamCommands(program2);
+  registerAnalyticsCommands(program2);
+  registerProjectCommands(program2);
+  registerIssueCommands(program2);
+  registerCommentCommands(program2);
+  registerLabelCommands(program2);
+  registerDsnCommands(program2);
+  registerSkillCommands(program2);
+  registerTemplateCommands(program2);
+  registerWatchCommand(program2);
+  program2.on("command:*", () => {
+    console.error(pc7.red(`Invalid command: ${program2.args.join(" ")}`));
+    console.error(`See ${pc7.bold("onus --help")} for a list of available commands.`);
+    process.exit(2);
+  });
+  return program2;
+}
+
+// src/update-check.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
+import path2 from "path";
+import pc8 from "picocolors";
+var REGISTRY_LATEST_URL = "https://registry.npmjs.org/@brunyee-studio/onus-cli/latest";
+var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 2e3;
+function getUpdateCheckFilePath() {
+  return path2.join(getConfigDirectory(), "update-check.json");
+}
+function readUpdateCheckCache() {
+  const filePath = getUpdateCheckFilePath();
+  try {
+    if (!existsSync2(filePath)) return null;
+    const raw = JSON.parse(readFileSync3(filePath, "utf8"));
+    if (typeof raw?.lastChecked !== "number" || typeof raw?.latestVersion !== "string" || raw.latestVersion === "") {
+      return null;
+    }
+    return { lastChecked: raw.lastChecked, latestVersion: raw.latestVersion };
+  } catch {
+    return null;
+  }
+}
+function writeUpdateCheckCache(state) {
+  const filePath = getUpdateCheckFilePath();
+  try {
+    const dir = path2.dirname(filePath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    writeFileSync2(filePath, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+  } catch {
+  }
+}
+function isNewerVersion(installed, latest) {
+  const parse = (v) => {
+    const [mainPart, ...preParts] = v.split("-");
+    const main = (mainPart ?? "").split(".").map((s) => Number.parseInt(s, 10));
+    if (main.length === 0 || main.some((n) => Number.isNaN(n))) return null;
+    return { main, pre: preParts.join("-") ? preParts.join("-").split(".") : [] };
+  };
+  const installedParsed = parse(installed);
+  const latestParsed = parse(latest);
+  if (!installedParsed || !latestParsed) return false;
+  const len = Math.max(installedParsed.main.length, latestParsed.main.length);
+  for (let i = 0; i < len; i++) {
+    const a = installedParsed.main[i] ?? 0;
+    const b = latestParsed.main[i] ?? 0;
+    if (a !== b) return b > a;
+  }
+  if (installedParsed.pre.length > 0 && latestParsed.pre.length === 0) return true;
+  if (installedParsed.pre.length === 0 && latestParsed.pre.length > 0) return false;
+  return comparePrerelease(installedParsed.pre, latestParsed.pre);
+}
+function comparePrerelease(a, b) {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const aPart = a[i];
+    const bPart = b[i];
+    if (aPart === void 0) return false;
+    if (bPart === void 0) return true;
+    const aNum = Number.parseInt(aPart, 10);
+    const bNum = Number.parseInt(bPart, 10);
+    const bothNumeric = !Number.isNaN(aNum) && !Number.isNaN(bNum);
+    if (bothNumeric) {
+      if (aNum !== bNum) return bNum > aNum;
+    } else if (aPart !== bPart) {
+      return false;
+    }
+  }
+  return false;
+}
+async function fetchLatestVersion(options = {}) {
+  const url = options.registryUrl ?? REGISTRY_LATEST_URL;
+  try {
+    const doFetch = options.fetchFn ?? fetch;
+    const response = await doFetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    if (!response.ok) return null;
+    const body = await response.json();
+    const version = body?.version;
+    return typeof version === "string" && version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+function shouldRunUpdateCheck(options) {
+  const { stderrIsTTY, argv, env } = options;
+  if (argv.includes("--json") || argv.includes("-j")) return false;
+  if (env.ONUS_OUTPUT === "json") return false;
+  if (argv.some((a) => ["--help", "-h", "--version", "-V", "-v"].includes(a))) return false;
+  if (!stderrIsTTY) return false;
+  if (env.CI && env.CI !== "0" && env.CI !== "false") return false;
+  if (env.ONUS_NO_UPDATE_CHECK && !["0", "false", ""].includes(env.ONUS_NO_UPDATE_CHECK)) {
+    return false;
+  }
+  return true;
+}
+async function checkForUpdate(options = {}) {
+  const argv = options.argv ?? process.argv.slice(2);
+  const env = options.env ?? process.env;
+  const stderrIsTTY = options.stderrIsTTY ?? (options.stderrStream ? options.stderrStream.isTTY === true : process.stderr.isTTY === true);
+  if (!options.skipGuards && !shouldRunUpdateCheck({ stderrIsTTY, argv, env })) {
+    return null;
+  }
+  const installed = options.installedVersion ?? cliVersion;
+  const now = options.now ?? Date.now();
+  const cached = readUpdateCheckCache();
+  let latest = null;
+  if (cached && now - cached.lastChecked < UPDATE_CHECK_TTL_MS) {
+    latest = cached.latestVersion;
+  } else {
+    latest = await fetchLatestVersion(options);
+    if (latest) {
+      writeUpdateCheckCache({ lastChecked: now, latestVersion: latest });
+    } else if (cached) {
+      latest = cached.latestVersion;
+    }
+  }
+  if (!latest || !isNewerVersion(installed, latest)) return null;
+  return { installed, latest };
+}
+function renderUpdateNotice(installed, latest) {
+  const header = pc8.yellow(`Update available: ${installed} \u2192 ${latest}`);
+  const line1 = pc8.dim("  Run: ") + pc8.bold("npm i -g @brunyee-studio/onus-cli@latest");
+  const line2 = pc8.dim("       ") + pc8.bold("onus skill update -g");
+  return `
+${pc8.dim("\u2500".repeat(52))}
+\u26A0 ${header}
+${line1}
+${line2}
+${pc8.dim("\u2500".repeat(52))}
+`;
+}
+async function notifyIfUpdateAvailable(options = {}) {
+  try {
+    const result = await checkForUpdate(options);
+    if (!result) return;
+    const stream = options.stderrStream ?? process.stderr;
+    stream.write(renderUpdateNotice(result.installed, result.latest));
+  } catch {
+  }
+}
+
+// src/bin.ts
+var program = buildProgram();
+process.on("unhandledRejection", (reason) => {
+  console.error(pc9.red("Unhandled error:"), reason);
+  process.exit(1);
+});
+program.parseAsync(process.argv).then(() => notifyIfUpdateAvailable()).catch((err) => {
+  console.error(pc9.red("Execution error:"), err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});