@allocator-one/infraone 0.0.0-stage → 1.17.0

package/dist/chunk-CEEQW6ZV.js

@@ -0,0 +1,3793 @@
+#!/usr/bin/env node
+import {
+  Client,
+  CommandError,
+  EXPERT_ASSIGNMENTS_PATH,
+  HttpError,
+  LocalError,
+  MalformedResponseError,
+  TransportError,
+  UpgradeRequiredError,
+  UsageError,
+  activityEntries,
+  clean,
+  cleanMultiline,
+  conditionLine,
+  errorDetails,
+  expertAssignments,
+  expertSummary,
+  explainExpertRefusal,
+  gateName,
+  graphemeLength,
+  isAgentStep,
+  isExpertToken,
+  issueDetail,
+  issuesTable,
+  ownerText,
+  planDetail,
+  plansTable,
+  stats,
+  table,
+  truncate
+} from "./chunk-BHBEIT5I.js";
+import {
+  CLI_VERSION,
+  invokedName,
+  named
+} from "./chunk-5THYIKLW.js";
+
+// src/commands/issues.ts
+import { openAsBlob, openSync, closeSync, readFileSync, statSync as statSync2 } from "fs";
+import { basename, extname } from "path";
+
+// src/core/attachments.ts
+import { chmodSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var REF = /\/(?:uploads\/harness|api\/v1)\/attachments\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\/([A-Za-z0-9._-]*\.(?:png|jpe?g|webp|gif))(?![A-Za-z0-9._-])/gi;
+var SOURCES = [
+  ["description", "description"],
+  ["design", "design"],
+  ["acceptance_criteria", "acceptance criteria"],
+  ["notes", "notes"]
+];
+var MAX_IMAGES_PER_SHOW = 20;
+var MAX_ATTACHMENT_BYTES = 25e6;
+function refs(issue) {
+  const texts = SOURCES.map(([field3, source]) => [issue[field3], source]);
+  const comments2 = Array.isArray(issue["comments"]) ? issue["comments"] : [];
+  for (const comment2 of comments2) texts.push([comment2["body"], "comment"]);
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [text, source] of texts) {
+    if (typeof text !== "string" || text === "") continue;
+    for (const match of text.matchAll(REF)) {
+      const ref = {
+        attachmentId: match[1].toLowerCase(),
+        file: match[2],
+        source
+      };
+      const key = `${ref.attachmentId}/${ref.file}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        found.push(ref);
+      }
+    }
+  }
+  return found;
+}
+async function fetchImages(client, issue, cacheDir) {
+  const allRefs = refs(issue);
+  const wanted = allRefs.slice(0, MAX_IMAGES_PER_SHOW);
+  const dropped = allRefs.slice(MAX_IMAGES_PER_SHOW);
+  const images = [];
+  const failures = [];
+  for (const ref of wanted) {
+    const result = await download(client, ref, cacheDir);
+    if (result.ok) {
+      images.push({
+        attachment_id: ref.attachmentId,
+        file: ref.file,
+        path: result.path,
+        source: ref.source
+      });
+    } else {
+      failures.push(`${ref.file}: ${result.message}`);
+    }
+  }
+  if (dropped.length > 0) {
+    failures.push(
+      `${dropped.length} further reference(s) skipped \u2014 the cap is ${MAX_IMAGES_PER_SHOW} images per show`
+    );
+  }
+  return { images, failures };
+}
+async function download(client, ref, cacheDir) {
+  const path = join(cacheDir, hostSegment(client.baseUrl), ref.attachmentId, ref.file);
+  try {
+    if (statSync(path).size > 0) return { ok: true, path };
+  } catch {
+  }
+  const bytes = await fetchBytes(client, ref);
+  if (!bytes.ok) return bytes;
+  return write(path, bytes.bytes);
+}
+function hostSegment(baseUrl) {
+  let host = "unknown-host";
+  let port = null;
+  try {
+    const parsed = new URL(baseUrl);
+    host = parsed.hostname.toLowerCase().replace(/[^a-z0-9.-]/g, "_");
+    port = parsed.port === "" ? null : Number(parsed.port);
+  } catch {
+  }
+  return port === null || port === 80 || port === 443 ? host : `${host}_${port}`;
+}
+async function fetchBytes(client, ref) {
+  let bytes;
+  try {
+    bytes = await client.getBytes(`/api/v1/attachments/${ref.attachmentId}/${ref.file}`);
+  } catch (error) {
+    if (error instanceof HttpError) return { ok: false, message: `${error.message} (HTTP ${error.status})` };
+    if (error instanceof TransportError) return { ok: false, message: error.message };
+    throw error;
+  }
+  if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
+    return { ok: false, message: `response is larger than the ${MAX_ATTACHMENT_BYTES}-byte attachment cap` };
+  }
+  if (!isImage(bytes)) return { ok: false, message: "response is not an image" };
+  return { ok: true, bytes };
+}
+function isImage(bytes) {
+  const startsWith = (prefix) => prefix.every((byte, index) => bytes[index] === byte);
+  if (startsWith([137, 80, 78, 71, 13, 10, 26, 10])) return true;
+  if (startsWith([255, 216, 255])) return true;
+  if (startsWith([71, 73, 70, 56, 55, 97])) return true;
+  if (startsWith([71, 73, 70, 56, 57, 97])) return true;
+  if (startsWith([82, 73, 70, 70]) && bytes.length >= 12) {
+    return bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80;
+  }
+  return false;
+}
+var partialCounter = 0;
+function write(path, bytes) {
+  const partial = `${path}.partial.${process.pid}.${++partialCounter}`;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    chmodSync(dirname(path), 448);
+    writeFileSync(partial, bytes);
+    chmodSync(partial, 384);
+    renameSync(partial, path);
+    return { ok: true, path };
+  } catch (error) {
+    rmSync(partial, { force: true });
+    const detail = error instanceof Error ? error.message : String(error);
+    return { ok: false, message: `cannot write ${path}: ${detail}` };
+  }
+}
+
+// src/core/pagination.ts
+function notices(meta, requestedPageSize, records4) {
+  return capNotice(meta, requestedPageSize) + truncationNotice(meta, records4);
+}
+function capNotice(meta, requestedPageSize) {
+  const served = meta?.page_size;
+  if (typeof served === "number" && typeof requestedPageSize === "number" && requestedPageSize > served) {
+    return `harness: --limit ${requestedPageSize} was capped at ${served} by the server.
+`;
+  }
+  return "";
+}
+function truncationNotice(meta, records4) {
+  const total = meta?.total;
+  const page = meta?.page;
+  const pages = meta?.total_pages;
+  if (typeof total !== "number" || typeof page !== "number" || typeof pages !== "number") return "";
+  const shown = records4.length;
+  if (shown < total) {
+    return `harness: showing ${shown} of ${total} (page ${page} of ${pages}) \u2014 pass --all for the rest, or --page to step through.
+`;
+  }
+  return "";
+}
+async function fetchEveryPage(fetchPage) {
+  const first = await fetchPage(1);
+  const totalPages = pageCount(first.meta);
+  if (totalPages === null) return first.data;
+  let records4 = first.data;
+  for (let page = 2; page <= totalPages; page++) {
+    const body = await fetchPage(page);
+    records4 = dedupe([...records4, ...body.data]);
+  }
+  return records4;
+}
+function pageCount(meta) {
+  const total = meta?.total_pages;
+  return typeof total === "number" && total > 0 ? total : null;
+}
+function dedupe(records4) {
+  const seen = /* @__PURE__ */ new Set();
+  return records4.filter((record) => {
+    const id = record["id"];
+    const key = id === void 0 || id === null ? `struct:${stableKey(record)}` : `id:${stableKey(id)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function stableKey(value) {
+  return JSON.stringify(
+    value,
+    (_field, nested) => nested !== null && typeof nested === "object" && !Array.isArray(nested) ? Object.fromEntries(Object.entries(nested).sort(([a], [b]) => a < b ? -1 : 1)) : nested
+  );
+}
+
+// src/commands/issues.ts
+var PRIORITY_NAMES = { urgent: 1, high: 2, medium: 3, low: 4, none: 0 };
+var PRIORITY_RANK = { 1: 0, 2: 1, 3: 2, 4: 3, 0: 4 };
+var STATUS_STATE_TYPES = {
+  open: "backlog,unstarted",
+  in_progress: "started",
+  closed: "completed,canceled"
+};
+var MAX_IDEMPOTENCY_KEY_BYTES = 200;
+var IDEMPOTENCY_KEY_FORMAT = /^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?(?![\s\S])/;
+var IDENTIFIER_FORMAT = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+var UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+  return UUID_FORMAT.test(value);
+}
+function isIdentifier(value) {
+  return IDENTIFIER_FORMAT.test(value);
+}
+function requireIdentifiers(identifiers) {
+  const bad = identifiers.filter((identifier) => !IDENTIFIER_FORMAT.test(identifier));
+  if (bad.length > 0) {
+    throw new UsageError(`not an issue identifier: ${bad.join(", ")} (expected e.g. ALL-4223)`);
+  }
+}
+async function ready(ctx, opts) {
+  if (opts.claim === true) return claimNext(ctx, opts);
+  const params = { ...listParams(ctx, opts), ready: true };
+  const { records: records4, notice } = await fetchIssues(ctx, params, opts);
+  const rank = (issue) => PRIORITY_RANK[issue["priority"]] ?? 4;
+  const sorted = markAgentSteps([...records4].sort((a, b) => rank(a) - rank(b)));
+  return { json: sorted, human: issuesTable(sorted, { markAgentSteps: true }), notice };
+}
+function markAgentSteps(issues) {
+  return issues.map((issue) => ({ ...issue, agent_step: isAgentStep(issue) }));
+}
+function requireReadyClaimArgs(opts) {
+  const paging = [
+    opts.all === true ? "--all" : null,
+    opts.limit !== void 0 ? "--limit" : null,
+    opts.page !== void 0 ? "--page" : null
+  ].filter((flag) => flag !== null);
+  if (paging.length === 0) return;
+  const last = paging.pop();
+  const flags = paging.length === 0 ? last : `${paging.join(", ")} or ${last}`;
+  throw new UsageError(
+    `--claim cannot be combined with ${flags}: the server picks from the team's whole ready queue, so there are no pages to choose from`
+  );
+}
+async function claimNext(ctx, opts) {
+  requireReadyClaimArgs(opts);
+  const team = requiredTeam(ctx, opts.team);
+  const check = `check \`${invokedName()} list --team ${team} --assignee me --status in_progress\``;
+  const unreadable = (why) => new CommandError(`The claim-next response ${why}, so an issue may have been claimed \u2014 ${check}.`);
+  let body;
+  try {
+    body = await ctx.client.post(`/api/v1/teams/${team}/issues/claim-next`);
+  } catch (error) {
+    if (error instanceof MalformedResponseError) throw unreadable(`could not be read (${error.message})`);
+    if (error instanceof TransportError) {
+      throw new TransportError(
+        `${error.message} \u2014 if the request reached the server, an issue may have been claimed; ${check} before claiming again`
+      );
+    }
+    throw error;
+  }
+  if (body.data === null) {
+    return { json: null, human: `Nothing to claim: team ${team} has no unassigned ready issues.
+` };
+  }
+  const claimed = body.data;
+  if (!isIssueRecord(claimed)) throw unreadable("carried neither an issue nor null");
+  return {
+    json: claimed,
+    human: `Claimed ${str(claimed["identifier"])}: ${clean(claimed["title"])}
+`
+  };
+}
+function isIssueRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const identifier = value["identifier"];
+  return typeof identifier === "string" && identifier !== "";
+}
+async function blocked(ctx, opts) {
+  const params = { ...listParams(ctx, opts), blocked: true };
+  const { records: records4, notice } = await fetchIssues(ctx, params, opts);
+  return { json: records4, human: issuesTable(records4), notice };
+}
+async function list(ctx, opts) {
+  const params = listParams(ctx, opts);
+  const { records: records4, notice } = await fetchIssues(ctx, params, opts);
+  return { json: records4, human: issuesTable(records4), notice };
+}
+async function search(ctx, queryWords, opts) {
+  if (queryWords.length === 0) throw new UsageError("usage: harness search <query>");
+  const deprecation = opts.page !== void 0 || opts.all === true ? "--page/--all are ignored: search returns one ranked list, capped at 20" : void 0;
+  let params = { q: queryWords.join(" ") };
+  if (opts.limit !== void 0) params = { ...params, limit: opts.limit };
+  const body = await ctx.client.get("/api/v1/issues/search", params);
+  const meta = body.meta ?? {};
+  const degraded = meta["mode"] === "lexical" ? "semantic search unavailable \u2014 showing lexical matches only" : void 0;
+  const notice = [deprecation, degraded].filter(Boolean).join("; ") || void 0;
+  return { json: body.data, human: issuesTable(body.data), notice };
+}
+async function show(ctx, identifier, opts) {
+  requireIdentifiers([identifier]);
+  const body = await ctx.client.get(`/api/v1/issues/${identifier}`, {
+    include: "relations,children,comments"
+  });
+  const issue = body.data;
+  let images = [];
+  let failures = [];
+  if (opts.images !== false) {
+    ({ images, failures } = await fetchImages(ctx.client, issue, ctx.config.cacheDir));
+  }
+  const json = images.length === 0 ? issue : { ...issue, local_images: images };
+  const human = issueDetail(issue, images);
+  const notice = failures.map((failure) => `harness: image not downloaded: ${clean(failure)}
+`).join("");
+  return notice === "" ? { json, human } : { json, human, notice };
+}
+var ACTIVITY_MAX_LIMIT = 100;
+var ACTIVITY_INCLUDE = "condition_events,field_events";
+var ACTIVITY_INCLUDE_WITHOUT_FIELDS = "condition_events";
+var ACTIVITY_WITHOUT_FIELDS_NOTICE = "harness: this server doesn't record field changes yet; showing activity without them.\n";
+async function activity(ctx, identifier, opts) {
+  requireIdentifiers([identifier]);
+  const first = await firstActivityPage(ctx, identifier, opts.limit);
+  const include = first.include;
+  let { page, notice } = first;
+  let entries = page.entries;
+  if (opts.all === true) {
+    const pages = [page.entries];
+    const seenCursors = /* @__PURE__ */ new Set();
+    while (page.hasMore) {
+      const cursor = page.nextCursor;
+      if (seenCursors.has(cursor)) {
+        throw new CommandError("Activity response repeated a cursor.");
+      }
+      seenCursors.add(cursor);
+      page = await activityPage(ctx, identifier, include, opts.limit, cursor);
+      pages.push(page.entries);
+    }
+    entries = pages.reverse().flat();
+  }
+  if (opts.all !== true && page.hasMore) {
+    notice += `harness: showing the newest ${entries.length} activity entries \u2014 pass --all for older activity.
+`;
+  }
+  return { json: entries, human: activityEntries(entries), notice: notice === "" ? void 0 : notice };
+}
+async function firstActivityPage(ctx, identifier, limit) {
+  try {
+    const page2 = await activityPage(ctx, identifier, ACTIVITY_INCLUDE, limit);
+    return { page: page2, include: ACTIVITY_INCLUDE, notice: "" };
+  } catch (error) {
+    if (!refusesInclude(error)) throw error;
+  }
+  const page = await activityPage(ctx, identifier, ACTIVITY_INCLUDE_WITHOUT_FIELDS, limit);
+  return { page, include: ACTIVITY_INCLUDE_WITHOUT_FIELDS, notice: ACTIVITY_WITHOUT_FIELDS_NOTICE };
+}
+function refusesInclude(error) {
+  if (!(error instanceof HttpError) || error.status !== 400) return false;
+  const message = error.body["message"];
+  return typeof message === "string" && /\binclude\b/.test(message) && /\b(condition_events|field_events)\b|\baccepts only\b/.test(message);
+}
+async function activityPage(ctx, identifier, include, limit, before) {
+  const body = await ctx.client.get(`/api/v1/issues/${identifier}/activity`, {
+    limit,
+    before,
+    include
+  });
+  if (!Array.isArray(body.data)) throw new CommandError("Activity response data is not an array.");
+  if (body.data.some((entry) => typeof entry !== "object" || entry === null || Array.isArray(entry))) {
+    throw new CommandError("Activity response contains a non-object entry.");
+  }
+  const meta = body.meta;
+  if (typeof meta !== "object" || meta === null) {
+    throw new CommandError("Activity response has no pagination metadata.");
+  }
+  const hasMore = meta.has_more;
+  const nextCursor = meta.next_cursor;
+  if (typeof hasMore !== "boolean") {
+    throw new CommandError("Activity response has an invalid has_more value.");
+  }
+  if (nextCursor !== null && typeof nextCursor !== "string") {
+    throw new CommandError("Activity response has an invalid next_cursor value.");
+  }
+  if (hasMore) {
+    if (nextCursor === null || nextCursor === "") {
+      throw new CommandError("Activity response says older entries exist but provides no cursor.");
+    }
+    if (body.data.length === 0) {
+      throw new CommandError("Activity response says older entries exist but contains no entries.");
+    }
+    return { entries: body.data, hasMore: true, nextCursor };
+  }
+  if (nextCursor !== null) {
+    throw new CommandError("Activity response provides a cursor when no older entries exist.");
+  }
+  return { entries: body.data, hasMore: false, nextCursor: null };
+}
+async function stats2(ctx) {
+  const body = await ctx.client.get("/api/v1/stats");
+  return { json: body.data, human: stats(body.data) };
+}
+async function prime(ctx) {
+  const statsBody = await ctx.client.get("/api/v1/stats");
+  const ready2 = markAgentSteps(await mostImportantReady(ctx));
+  const json = { stats: statsBody.data, ready: ready2 };
+  const human = "# Harness workflow context\n\n" + stats(statsBody.data) + "\nReady to work:\n" + issuesTable(ready2, { markAgentSteps: true }) + named(`
+Workflow: harness ready \u2192 harness update <id> --claim \u2192 work \u2192
+harness close <id> --reason "Implemented in <commit-hash>" (response
+lists newly unblocked issues \u2014 surface them).
+Create tracked work BEFORE coding: harness create --title "\u2026" --type task.
+Dependencies: harness dep add <issue> <blocker> (blocker blocks issue).
+Before reporting done: close the issues you finished.
+`);
+  return { json, human };
+}
+async function mostImportantReady(ctx) {
+  try {
+    return (await ctx.client.get("/api/v1/issues/next", { limit: 10 })).data;
+  } catch (error) {
+    if (!(error instanceof HttpError) || error.status !== 404) throw error;
+    return (await ctx.client.get("/api/v1/issues", { ready: true, page_size: 10 })).data;
+  }
+}
+async function version(config) {
+  let server;
+  if (config === null || config.baseUrl === "") {
+    server = "unconfigured";
+  } else {
+    server = await new Client(config).serverVersion().catch(() => "unreachable");
+  }
+  return { json: { cli: CLI_VERSION, server }, human: `${invokedName()} ${CLI_VERSION} (server API ${server})
+` };
+}
+async function create(ctx, opts) {
+  if (opts.title === void 0) {
+    throw new UsageError("usage: harness create --title <title> [--team <key>] \u2026");
+  }
+  validateType(opts.type);
+  const team = requiredTeam(ctx, opts.team);
+  validateIdempotencyKey(opts.idempotencyKey);
+  const priority = optionalPriority(opts.priority);
+  const dueDate = optionalDueDate(opts.dueDate);
+  const labels = requestedLabelNames(wantedLabels(opts));
+  const labelIds = await prepareCreateLabelIds(ctx, team, labels);
+  let body = { title: opts.title };
+  body = putOpt(body, "description", opts.description);
+  body = putOpt(body, "design", opts.design);
+  body = putOpt(body, "notes", opts.notes);
+  body = putOpt(body, "acceptance_criteria", opts.acceptance);
+  body = putOpt(body, "parent", opts.parent);
+  body = putPresent(body, "priority", priority);
+  body = putDueDate(body, dueDate);
+  body = putAssignee(body, opts.assignee);
+  if (labelIds.length > 0) body["label_ids"] = labelIds;
+  const created = await ctx.client.post(`/api/v1/teams/${team}/issues`, body, {
+    idempotencyKey: opts.idempotencyKey
+  });
+  const issue = created.data;
+  return {
+    json: issue,
+    human: `Created ${str(issue["identifier"])}: ${clean(issue["title"])}
+`
+  };
+}
+function validateIdempotencyKey(key) {
+  if (key === void 0) return;
+  if (key.trim() === "") throw new UsageError("idempotency key must not be blank");
+  if (Buffer.byteLength(key, "utf8") > MAX_IDEMPOTENCY_KEY_BYTES) {
+    throw new UsageError(`idempotency key must not exceed ${MAX_IDEMPOTENCY_KEY_BYTES} UTF-8 bytes`);
+  }
+  if (!IDEMPOTENCY_KEY_FORMAT.test(key)) {
+    throw new UsageError("idempotency key must use printable ASCII and cannot start or end with a space");
+  }
+}
+async function update(ctx, identifier, opts) {
+  requireIdentifiers([identifier]);
+  if (opts.notes !== void 0 && opts.appendNotes !== void 0) {
+    throw new UsageError("--notes replaces and --append-notes appends \u2014 pass one, not both");
+  }
+  if (opts.claim === true && opts.assignee !== void 0) {
+    throw new UsageError(
+      "--claim takes the issue and starts it; --assignee only sets the field \u2014 pass one, not both (--claim to take it yourself, --assignee to hand it to someone)"
+    );
+  }
+  const priority = optionalPriority(opts.priority);
+  const dueDate = optionalDueDate(opts.dueDate);
+  const addLabels = requestedLabelInputs(opts.addLabel ?? []);
+  const removeLabels = requestedLabelInputs(opts.removeLabel ?? []);
+  const labelPlan = addLabels.length > 0 || removeLabels.length > 0 ? await prepareLabelUpdate(ctx, identifier, addLabels, removeLabels) : null;
+  let issue = labelPlan?.issue ?? null;
+  let wrote = false;
+  if (opts.claim === true) {
+    try {
+      const body = await ctx.client.post(`/api/v1/issues/${identifier}/claim`);
+      issue = body.data;
+    } catch (error) {
+      throw explainClaimRefusal(error, identifier);
+    }
+    wrote = true;
+  }
+  let patch = {};
+  patch = putOpt(patch, "title", opts.title);
+  patch = putOpt(patch, "description", opts.description);
+  patch = putOpt(patch, "design", opts.design);
+  patch = putOpt(patch, "notes", opts.notes);
+  patch = putOpt(patch, "acceptance_criteria", opts.acceptance);
+  patch = putOpt(patch, "parent", opts.parent);
+  patch = putPresent(patch, "priority", priority);
+  patch = putDueDate(patch, dueDate);
+  patch = putAssignee(patch, opts.assignee);
+  if (opts.appendNotes !== void 0) {
+    const current = await ctx.client.get(`/api/v1/issues/${identifier}`);
+    const existing = current.data["notes"];
+    const combined = existing === null || existing === void 0 || existing === "" ? opts.appendNotes : `${str(existing)}
+
+${opts.appendNotes}`;
+    patch["notes"] = combined;
+  }
+  if (Object.keys(patch).length > 0) {
+    const body = await ctx.client.patch(`/api/v1/issues/${identifier}`, patch);
+    issue = body.data;
+    wrote = true;
+  }
+  if (opts.state !== void 0) {
+    issue = await setState(ctx, identifier, opts.state);
+    wrote = true;
+  }
+  if (labelPlan?.changed === true) {
+    const body = await ctx.client.put(`/api/v1/issues/${identifier}/labels`, {
+      label_ids: labelPlan.ids
+    });
+    issue = body.data;
+    wrote = true;
+  }
+  if (issue === null) {
+    throw new UsageError("usage: harness update <id> --claim | --title \u2026 | --state <name> | \u2026");
+  }
+  const human = wrote ? `Updated ${str(issue["identifier"])}
+` : `Labels already up to date for ${str(issue["identifier"])}
+`;
+  return { json: issue, human };
+}
+var CLAIM_REFUSAL_HINTS = {
+  // A person never claims an Operator step, so releasing the plan is not the
+  // fix: handing the step to a person is, and a handed-over Operator step
+  // stays frozen until the next release.
+  agent_step: (_identifier, plan) => {
+    const runs = plan.kind === "sole" ? `plan ${plan.root}` : plan.kind === "nearest" ? `its plans (several govern it; the nearest is ${plan.root})` : "its plan";
+    const target = plan.kind === "sole" ? plan.root : "<plan>";
+    return `a person can't claim an Operator step: Operator runs it for ${runs}. To do it yourself, set its executor to none (${invokedName()} plan edit ${target}) and release the plan again`;
+  },
+  plan_not_released: (_identifier, plan) => planReleaseHint(plan),
+  not_in_plan_revision: (_identifier, plan) => planReleaseHint(plan),
+  edited_since_release: (_identifier, plan) => planReleaseHint(plan),
+  waiting_on_condition: (identifier) => `${invokedName()} show ${identifier} lists what it waits on; tick a gate with ${invokedName()} gate satisfy ${identifier} <gate>`
+};
+function planReleaseHint(plan) {
+  if (plan.kind === "sole") return plan.release ? `run ${invokedName()} plan release ${plan.root}` : void 0;
+  if (plan.kind === "nearest") {
+    return `several plans govern it; the nearest is ${plan.root} (${invokedName()} plan show ${plan.root})`;
+  }
+  return void 0;
+}
+function explainClaimRefusal(error, identifier) {
+  if (!(error instanceof HttpError) || error.status !== 409) return error;
+  const reason = error.body["reason"];
+  const hint = typeof reason === "string" && Object.hasOwn(CLAIM_REFUSAL_HINTS, reason) ? CLAIM_REFUSAL_HINTS[reason](identifier, refusingPlan(error.body)) : void 0;
+  if (hint === void 0) return error;
+  return new HttpError(error.status, `${error.message} \u2014 ${hint}`, error.body, error.retryAfter);
+}
+function refusingPlan(body) {
+  const plan = body["plan"];
+  if (typeof plan !== "object" || plan === null || Array.isArray(plan)) return { kind: "none" };
+  const root = plan["root"];
+  if (typeof root !== "string" || !isIdentifier(root)) return { kind: "none" };
+  const message = typeof body["message"] === "string" ? body["message"] : "";
+  if (!new RegExp(`\\bplan ${root}\\b`).test(message)) return { kind: "nearest", root };
+  return { kind: "sole", root, release: new RegExp(`\\brelease plan ${root}\\b`).test(message) };
+}
+function requireCloseArgs(identifiers, opts) {
+  if (identifiers.length === 0) {
+    throw new UsageError(
+      "usage: harness close <id> [<id>\u2026] [--reason <text>] [--cancel | --duplicate-of <id>]"
+    );
+  }
+  requireIdentifiers(identifiers);
+  if (opts.duplicateOf === void 0) return;
+  requireIdentifiers([opts.duplicateOf]);
+  if (opts.cancel === true) {
+    throw new UsageError("--duplicate-of and --cancel are mutually exclusive");
+  }
+  if (identifiers.length !== 1) {
+    throw new UsageError("--duplicate-of accepts exactly one source issue");
+  }
+}
+async function close(ctx, identifiers, opts) {
+  requireCloseArgs(identifiers, opts);
+  let body = {};
+  body = putPresent(body, "reason", opts.reason);
+  body = putPresent(body, "cancel", opts.cancel);
+  body = putPresent(body, "duplicate_of", opts.duplicateOf);
+  const results = [];
+  for (const identifier of identifiers) {
+    try {
+      const response = await ctx.client.post(`/api/v1/issues/${identifier}/close`, body);
+      results.push({ identifier, ok: true, response });
+    } catch (error) {
+      if (error instanceof HttpError || error instanceof TransportError) {
+        results.push({ identifier, ok: false, error: explainExpertRefusal(error, ctx.config.token) });
+      } else {
+        throw error;
+      }
+    }
+  }
+  const human = results.map((result) => closeLine(result, opts.duplicateOf)).join("");
+  const json = results.map(
+    (result) => result.ok ? {
+      identifier: result.identifier,
+      closed: true,
+      ...opts.duplicateOf === void 0 ? {} : { duplicate_of: opts.duplicateOf },
+      unblocked: result.response["unblocked"] ?? null,
+      // Passed through as sent: older servers omit it, and so does this.
+      ..."still_blocking" in result.response ? { still_blocking: result.response["still_blocking"] } : {}
+    } : { identifier: result.identifier, closed: false, error: errorText(result.error) }
+  );
+  const partial = results.some((result) => !result.ok);
+  return partial ? { json, human, partial: true } : { json, human };
+}
+function closeLine(result, duplicateOf) {
+  if (!result.ok) return `FAILED ${result.identifier}: ${errorText(result.error)}
+`;
+  const closure = duplicateOf === void 0 ? `Closed ${result.identifier}` : `Closed ${result.identifier} as duplicate of ${duplicateOf}`;
+  const unblocked = result.response["unblocked"];
+  const line = Array.isArray(unblocked) && unblocked.length > 0 ? `${closure} \u2014 unblocked: ${unblocked.map((identifier) => clean(identifier)).join(", ")}
+` : `${closure}
+`;
+  return line + stillBlockingLine(result.response["still_blocking"]);
+}
+function stillBlockingLine(stillBlocking) {
+  if (!Array.isArray(stillBlocking) || stillBlocking.length === 0) return "";
+  const identifiers = stillBlocking.map((identifier) => clean(identifier)).join(", ");
+  return `  Still blocking: ${identifiers} (a cancelled issue still blocks its dependents)
+`;
+}
+async function archive(ctx, identifiers, opts) {
+  if (identifiers.length === 0) {
+    throw new UsageError("usage: harness archive <id> [<id>\u2026] [--restore]");
+  }
+  requireIdentifiers(identifiers);
+  const archived = opts.restore !== true;
+  const verb = archived ? "Archived" : "Restored";
+  const results = [];
+  for (const identifier of identifiers) {
+    try {
+      const body = await ctx.client.put(`/api/v1/issues/${identifier}/archive_state`, { archived });
+      results.push({ identifier, ok: true, issue: body.data });
+    } catch (error) {
+      if (error instanceof HttpError || error instanceof TransportError) {
+        results.push({ identifier, ok: false, error: explainExpertRefusal(error, ctx.config.token) });
+      } else {
+        throw error;
+      }
+    }
+  }
+  const human = results.map(
+    (result) => result.ok ? `${verb} ${result.identifier}
+` : `FAILED ${result.identifier}: ${errorText(result.error)}
+`
+  ).join("");
+  const json = results.map(
+    (result) => result.ok ? { identifier: result.identifier, archived } : { identifier: result.identifier, error: errorText(result.error) }
+  );
+  const partial = results.some((result) => !result.ok);
+  return partial ? { json, human, partial: true } : { json, human };
+}
+async function comments(ctx, identifier) {
+  requireIdentifiers([identifier]);
+  const records4 = await completeCommentThread(ctx, identifier);
+  if (records4.length === 0) return { json: records4, human: "No comments.\n" };
+  const human = records4.map((comment2) => {
+    const author = clean((comment2["author"] ?? {})["name"] ?? "unknown");
+    const id = clean(comment2["id"] ?? "unknown id");
+    const text = cleanMultiline(str(comment2["body"])).split("\n").map((line) => "  " + line).join("\n");
+    return `[${str(comment2["inserted_at"])}] ${author} (${id}):
+${text}
+`;
+  }).join("\n");
+  return { json: records4, human };
+}
+async function completeCommentThread(ctx, identifier) {
+  const pages = [];
+  const seen = /* @__PURE__ */ new Set();
+  let before;
+  for (; ; ) {
+    const page = await ctx.client.get(`/api/v1/issues/${identifier}/comments`, {
+      limit: 200,
+      before
+    });
+    if (!Array.isArray(page.data) || typeof page.meta?.has_more !== "boolean") {
+      throw new CommandError("Invalid comment pagination: expected a comment array and boolean meta.has_more; completeness unknown.");
+    }
+    const records4 = [];
+    for (const record of page.data) {
+      if (record === null || typeof record !== "object" || Array.isArray(record) || typeof record.id !== "string" || record.id.trim() === "" || seen.has(record.id)) {
+        throw new CommandError("Invalid comment pagination: missing or repeated comment id; completeness unknown.");
+      }
+      seen.add(record.id);
+      records4.push(record);
+    }
+    pages.push(records4);
+    if (!page.meta.has_more) return pages.reverse().flat();
+    if (records4.length === 0) {
+      throw new CommandError("Invalid comment pagination: has_more on an empty page; completeness unknown.");
+    }
+    before = records4[0]["id"];
+  }
+}
+async function dep(ctx, verb, issue, blocker) {
+  requireIdentifiers([issue, blocker]);
+  if (verb === "add") {
+    const response = await ctx.client.post(`/api/v1/issues/${issue}/relations`, {
+      type: "blocked_by",
+      related_issue: blocker
+    });
+    return { json: response.data, human: `${blocker} now blocks ${issue}
+` };
+  }
+  if (verb === "rm") {
+    const body = await ctx.client.get(`/api/v1/issues/${issue}/relations`);
+    const relation = (body.data ?? []).find(
+      (candidate) => candidate["direction"] === "blocked_by" && candidate["other_issue"] === blocker
+    );
+    if (relation === void 0) throw new CommandError(`${blocker} does not block this issue.`);
+    await ctx.client.delete(`/api/v1/issues/${issue}/relations/${str(relation["id"])}`);
+    return { json: { deleted: relation["id"] }, human: `${blocker} no longer blocks ${issue}
+` };
+  }
+  throw new UsageError("usage: harness dep add|rm <issue> <blocker>  (the blocker blocks the issue)");
+}
+var RELATION_CREATE_TYPES = [
+  "blocks",
+  "blocked_by",
+  "related",
+  "duplicate",
+  "duplicate_of",
+  "duplicated_by"
+];
+var RELATION_UPDATE_TYPES = ["blocks", "blocked_by", "related", "duplicate_of"];
+function requireRelationType(type, allowed, operation) {
+  if (!allowed.includes(type)) {
+    throw new UsageError(`relation ${operation} type must be one of: ${allowed.join(", ")}`);
+  }
+}
+async function findRelation(ctx, issue, idOrIssue) {
+  const response = await ctx.client.get(`/api/v1/issues/${issue}/relations`);
+  const idMatch = response.data.find((candidate) => candidate["id"] === idOrIssue);
+  if (idMatch !== void 0) return idMatch;
+  const issueMatches = response.data.filter((candidate) => candidate["other_issue"] === idOrIssue);
+  if (issueMatches.length > 1) {
+    throw new CommandError(`multiple relations on ${issue} match ${idOrIssue}; use a relation id`);
+  }
+  if (issueMatches.length === 0) {
+    throw new CommandError(`no relation on ${issue} matches ${idOrIssue} (by id or related issue)`);
+  }
+  return issueMatches[0];
+}
+async function resolveRelationId(ctx, issue, idOrIssue) {
+  if (isUuid(idOrIssue)) return idOrIssue.toLowerCase();
+  const relation = await findRelation(ctx, issue, idOrIssue);
+  return String(relation["id"]);
+}
+async function relationList(ctx, issue) {
+  requireIdentifiers([issue]);
+  const response = await ctx.client.get(`/api/v1/issues/${issue}/relations`);
+  const human = response.data.length === 0 ? "No relations.\n" : table(
+    ["ID", "DIRECTION", "ISSUE"],
+    response.data.map((relation) => [
+      String(relation["id"] ?? ""),
+      String(relation["direction"] ?? ""),
+      String(relation["other_issue"] ?? "")
+    ])
+  );
+  return { json: response.data, human };
+}
+async function relationAdd(ctx, issue, relatedIssue, type) {
+  requireIdentifiers([issue, relatedIssue]);
+  requireRelationType(type, RELATION_CREATE_TYPES, "add");
+  const response = await ctx.client.post(`/api/v1/issues/${issue}/relations`, {
+    type,
+    related_issue: relatedIssue
+  });
+  return { json: response.data, human: `Related ${issue} to ${relatedIssue} as ${type}
+` };
+}
+async function relationUpdate(ctx, issue, idOrIssue, type) {
+  requireIdentifiers([issue]);
+  requireRelationType(type, RELATION_UPDATE_TYPES, "update");
+  const id = await resolveRelationId(ctx, issue, idOrIssue);
+  const response = await ctx.client.patch(`/api/v1/issues/${issue}/relations/${id}`, { type });
+  return { json: response.data, human: `Updated relation ${id} on ${issue} to ${type}
+` };
+}
+async function relationRm(ctx, issue, idOrIssue) {
+  requireIdentifiers([issue]);
+  const id = await resolveRelationId(ctx, issue, idOrIssue);
+  await ctx.client.delete(`/api/v1/issues/${issue}/relations/${id}`);
+  return { json: { deleted: id }, human: `Removed relation ${id} from ${issue}
+` };
+}
+async function comment(ctx, identifier, textWords, mentions) {
+  requireIdentifiers([identifier]);
+  if (textWords.length === 0) {
+    throw new UsageError("usage: harness comment <id> <text> [--mention NAME]\u2026");
+  }
+  const body = { body: textWords.join(" ") };
+  if (mentions.length > 0) body["mentions"] = mentions;
+  const response = await ctx.client.post(`/api/v1/issues/${identifier}/comments`, body);
+  return { json: response.data, human: `Commented on ${identifier}
+` };
+}
+async function editComment(ctx, identifier, commentId, textWords) {
+  requireIdentifiers([identifier]);
+  requireCommentId(commentId);
+  const body = textWords.join(" ");
+  if (body.trim() === "") {
+    throw new UsageError("the comment text is empty \u2014 nothing to edit");
+  }
+  const response = await ctx.client.patch(
+    `/api/v1/issues/${identifier}/comments/${commentId}`,
+    { body }
+  );
+  return {
+    json: response.data,
+    human: `Edited comment ${commentId} on ${identifier}
+`
+  };
+}
+async function deleteComment(ctx, identifier, commentId) {
+  requireIdentifiers([identifier]);
+  requireCommentId(commentId);
+  const response = await ctx.client.delete(
+    `/api/v1/issues/${identifier}/comments/${commentId}`
+  );
+  return {
+    json: response.data,
+    human: `Deleted comment ${commentId} from ${identifier}
+`
+  };
+}
+function requireCommentId(commentId) {
+  if (!UUID_FORMAT.test(commentId)) {
+    throw new UsageError(`not a comment id: ${commentId} (expected a UUID)`);
+  }
+}
+var MAX_IMAGE_BYTES = 25e6;
+var MAX_VIDEO_BYTES = 1e8;
+async function attachImage(ctx, path) {
+  return uploadAttachment(ctx, path, MAX_IMAGE_BYTES);
+}
+async function attachFile(ctx, path) {
+  const maxBytes = extname(path).toLowerCase() === ".mp4" ? MAX_VIDEO_BYTES : MAX_IMAGE_BYTES;
+  return uploadAttachment(ctx, path, maxBytes);
+}
+async function uploadAttachment(ctx, path, maxBytes) {
+  attachableFile(path, maxBytes);
+  const file = maxBytes === MAX_VIDEO_BYTES ? new File([await openAsBlob(path)], basename(path)) : new File([readFileSync(path)], basename(path));
+  requireAttachmentSize(path, file.size, maxBytes);
+  const form = new FormData();
+  form.set("file", file);
+  const body = await ctx.client.postMultipart("/api/v1/uploads", form, file.size);
+  const attachment = body.data;
+  const markdown = attachment["markdown"];
+  if (typeof markdown !== "string") throw new CommandError("the upload response carried no markdown reference");
+  return { json: attachment, human: clean(markdown) + "\n" };
+}
+function attachableFile(path, maxBytes) {
+  let fileStats;
+  try {
+    fileStats = statSync2(path);
+  } catch (error) {
+    throw new LocalError(`cannot read ${path}: ${posixDetail(error)}`);
+  }
+  if (!fileStats.isFile()) {
+    const kind = fileStats.isDirectory() ? "directory" : "special file";
+    throw new LocalError(`${path} is a ${kind}, not a file.`);
+  }
+  requireAttachmentSize(path, fileStats.size, maxBytes);
+  try {
+    closeSync(openSync(path, "r"));
+  } catch (error) {
+    throw new LocalError(`cannot read ${path}: ${posixDetail(error)}`);
+  }
+}
+function requireAttachmentSize(path, size, maxBytes) {
+  if (size > maxBytes) {
+    throw new LocalError(`${path} is too large: ${size} bytes, and attachments are capped at ${maxBytes}.`);
+  }
+}
+function posixDetail(error) {
+  const code = error.code;
+  if (code === "ENOENT") return "no such file or directory";
+  if (code === "EACCES") return "permission denied";
+  return error instanceof Error ? error.message : String(error);
+}
+async function setState(ctx, identifier, stateName) {
+  const showBody = await ctx.client.get(`/api/v1/issues/${identifier}`);
+  const teamKey = str((showBody.data["team"] ?? {})["key"]);
+  const statesBody = await ctx.client.get(
+    `/api/v1/teams/${teamKey}/workflow_states`
+  );
+  const wanted = stateName.toLowerCase();
+  const state = statesBody.data.find(
+    (candidate) => str(candidate["name"]).toLowerCase() === wanted || str(candidate["type"]) === wanted
+  );
+  if (state === void 0) {
+    const names = statesBody.data.map((candidate) => str(candidate["name"])).join(", ");
+    throw new CommandError(`No workflow state matches "${stateName}". States: ${names}`);
+  }
+  const body = await ctx.client.put(`/api/v1/issues/${identifier}/state`, { state_id: state["id"] });
+  return body.data;
+}
+var ISSUE_TYPES = ["task", "bug", "feature", "epic"];
+function wantedLabels(opts) {
+  const typeLabels = opts.type === void 0 ? [] : [`type/${opts.type}`];
+  return [...typeLabels, ...opts.label ?? []];
+}
+function validateType(type) {
+  if (type !== void 0 && !ISSUE_TYPES.includes(type)) {
+    throw new UsageError(`not an issue type: ${type} (expected ${ISSUE_TYPES.join(", ")})`);
+  }
+}
+function requestedLabelNames(names) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const name of requestedLabelInputs(names)) {
+    const normalized = normalizeLabelName(name);
+    if (!unique.has(normalized)) unique.set(normalized, name);
+  }
+  return [...unique.values()];
+}
+function requestedLabelInputs(values) {
+  return values.map((value) => {
+    const trimmed = value.trim();
+    if (trimmed === "") throw new UsageError("label names and ids cannot be empty");
+    return trimmed;
+  });
+}
+function normalizeLabelName(value) {
+  return str(value).trim().toLowerCase();
+}
+async function prepareCreateLabelIds(ctx, teamKey, names) {
+  if (names.length === 0) return [];
+  const teams = await ctx.client.get("/api/v1/teams");
+  const target = teams.data.find(
+    (team) => str(team["key"]).toLowerCase() === teamKey.toLowerCase()
+  );
+  if (target === void 0) throw new CommandError(`No team matches key "${teamKey}".`);
+  const teamId = str(target["id"]);
+  if (teamId === "") throw new CommandError(`team ${teamKey} carried no id`);
+  return prepareApplicableLabelIds(ctx, teamId, names);
+}
+async function prepareApplicableLabelIds(ctx, teamId, names) {
+  let labels = (await ctx.client.get("/api/v1/labels")).data;
+  const ids = [];
+  for (const name of names) {
+    const resolved = await resolveOrCreateApplicableLabel(ctx, labels, name, teamId);
+    labels = resolved.catalog;
+    ids.push(labelId(resolved.label));
+  }
+  return [...new Set(ids)];
+}
+function applicableLabel(labels, input, teamId) {
+  const normalized = normalizeLabelName(input);
+  const named2 = labels.filter((label) => normalizeLabelName(label["name"]) === normalized);
+  const teamMatches = named2.filter((label) => label["team_id"] === teamId);
+  if (teamMatches.length > 1) {
+    throw new CommandError(`more than one team label matches "${input}"; use a label id`);
+  }
+  if (teamMatches.length === 1) return teamMatches[0];
+  const workspaceMatches = named2.filter(
+    (label) => label["team_id"] === null || label["team_id"] === void 0
+  );
+  if (workspaceMatches.length > 1) {
+    throw new CommandError(`more than one workspace label matches "${input}"; use a label id`);
+  }
+  return workspaceMatches[0];
+}
+async function resolveOrCreateApplicableLabel(ctx, catalog, name, teamId) {
+  const existing = applicableLabel(catalog, name, teamId);
+  if (existing !== void 0) return { label: existing, catalog };
+  try {
+    const created = await ctx.client.post("/api/v1/labels", {
+      name,
+      color: "gray"
+    });
+    return { label: created.data, catalog: [...catalog, created.data] };
+  } catch (error) {
+    if (!(error instanceof HttpError) || error.status !== 422) throw error;
+    const refreshed = (await ctx.client.get("/api/v1/labels")).data;
+    const winner = applicableLabel(refreshed, name, teamId);
+    if (winner === void 0) throw error;
+    return { label: winner, catalog: refreshed };
+  }
+}
+function labelId(label) {
+  const id = str(label["id"]);
+  if (id === "") throw new CommandError("the label response carried no id");
+  return id;
+}
+async function prepareLabelUpdate(ctx, identifier, addInputs, removeInputs) {
+  const issue = (await ctx.client.get(`/api/v1/issues/${identifier}`)).data;
+  const attached = Array.isArray(issue["labels"]) ? issue["labels"] : [];
+  const originalIds = attached.map(labelId);
+  const removed = /* @__PURE__ */ new Set();
+  for (const input of removeInputs) {
+    const idInput = UUID_FORMAT.test(input);
+    const exact = attached.find((label) => {
+      const id = labelId(label);
+      return idInput ? id.toLowerCase() === input.toLowerCase() : id === input;
+    });
+    if (exact !== void 0) {
+      removed.add(labelId(exact));
+      continue;
+    }
+    const normalized = normalizeLabelName(input);
+    const matches = attached.filter((label) => normalizeLabelName(label["name"]) === normalized);
+    if (matches.length > 1) {
+      throw new CommandError(`more than one attached label matches "${input}"; remove by label id`);
+    }
+    if (matches.length === 1) removed.add(labelId(matches[0]));
+  }
+  const ids = originalIds.filter((id) => !removed.has(id));
+  if (addInputs.length > 0) {
+    const team = issue["team"] ?? {};
+    const teamId = str(team["id"]);
+    if (teamId === "") throw new CommandError(`issue ${identifier} carried no team id`);
+    let catalog = (await ctx.client.get("/api/v1/labels")).data;
+    for (const input of addInputs) {
+      const idInput = UUID_FORMAT.test(input);
+      let chosen = idInput ? catalog.find((label) => labelId(label).toLowerCase() === input.toLowerCase()) : void 0;
+      if (chosen !== void 0) {
+        const owner = chosen["team_id"];
+        if (owner !== null && owner !== void 0 && owner !== teamId) {
+          throw new CommandError(
+            `label ${input} belongs to another team and cannot be added to ${identifier}`
+          );
+        }
+      } else {
+        if (idInput) throw new CommandError(`No label matches id "${input}".`);
+        const resolved = await resolveOrCreateApplicableLabel(ctx, catalog, input, teamId);
+        chosen = resolved.label;
+        catalog = resolved.catalog;
+      }
+      const id = labelId(chosen);
+      if (!ids.includes(id)) ids.push(id);
+    }
+  }
+  return {
+    issue,
+    ids,
+    changed: ids.length !== originalIds.length || ids.some((id, index) => id !== originalIds[index])
+  };
+}
+async function fetchIssues(ctx, params, opts) {
+  if (opts.all === true && opts.page !== void 0) {
+    throw new UsageError("--all reads every page from the first \u2014 pass --all or --page, not both");
+  }
+  if (opts.all === true) {
+    const records5 = await fetchEveryPage(
+      (page) => ctx.client.get("/api/v1/issues", { ...params, page })
+    );
+    return { records: records5, notice: "" };
+  }
+  const body = await ctx.client.get("/api/v1/issues", params);
+  const records4 = body.data;
+  const requested = typeof params["page_size"] === "number" ? params["page_size"] : void 0;
+  return { records: records4, notice: notices(body.meta, requested, records4) };
+}
+function listParams(ctx, opts) {
+  if (opts.type !== void 0 && opts.label !== void 0) {
+    throw new UsageError("--type is a label filter itself \u2014 pass either --type or --label, not both");
+  }
+  validateType(opts.type);
+  let params = withTeam({ page_size: opts.limit ?? 50, page: opts.page ?? 1 }, ctx, opts);
+  params = putParam(params, "search", opts.search);
+  params = putParam(params, "parent", opts.parent);
+  params = putParam(params, "label", opts.label);
+  params = putParam(params, "scope", opts.scope);
+  params = putParam(params, "assignee", opts.assignee);
+  params = putParam(params, "created_by", opts.createdBy);
+  params = putParam(params, "involved", opts.involved);
+  if (opts.type !== void 0) params = putParam(params, "label", `type/${opts.type}`);
+  if (opts.status !== void 0) {
+    const stateTypes = Object.hasOwn(STATUS_STATE_TYPES, opts.status) ? STATUS_STATE_TYPES[opts.status] : void 0;
+    if (stateTypes === void 0) {
+      throw new UsageError(`status must be one of: ${Object.keys(STATUS_STATE_TYPES).join(", ")}`);
+    }
+    params = putParam(params, "state_type", stateTypes);
+  }
+  const priority = optionalPriority(opts.priority);
+  if (priority !== null) params = putParam(params, "priority", priority);
+  return params;
+}
+function optionalPriority(value) {
+  if (value === void 0) return null;
+  const named2 = Object.hasOwn(PRIORITY_NAMES, value) ? PRIORITY_NAMES[value] : void 0;
+  if (named2 !== void 0) return named2;
+  if (/^\d+$/.test(value)) {
+    throw new UsageError(
+      `Bare numeric priorities are refused: bd and harness disagree on what
+the numbers mean, so a habit-typed number would silently file the
+wrong priority.
+
+  bd:      0=critical 1=high 2=medium 3=normal 4=backlog
+  harness: 0=none     1=urgent 2=high 3=medium 4=low
+
+Use a name instead: --priority urgent|high|medium|low|none
+`
+    );
+  }
+  throw new UsageError("priority must be one of: urgent, high, medium, low, none");
+}
+function optionalDueDate(value) {
+  if (value === void 0) return null;
+  const trimmed = value.trim();
+  if (trimmed === "") return "clear";
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(trimmed);
+  if (match === null) throw new UsageError(`not a date: ${trimmed} (expected YYYY-MM-DD)`);
+  const [, year, month, day] = match.map(Number);
+  const candidate = /* @__PURE__ */ new Date(0);
+  candidate.setUTCFullYear(year, month - 1, day);
+  const real = candidate.getUTCFullYear() === year && candidate.getUTCMonth() === month - 1 && candidate.getUTCDate() === day;
+  if (!real) throw new UsageError(`not a date: ${trimmed} (no such day on the calendar)`);
+  return trimmed;
+}
+var TEAM_KEY_FORMAT = /^[A-Za-z][A-Za-z0-9]*$/;
+function requiredTeam(ctx, team) {
+  const resolved = team ?? ctx.config.team ?? void 0;
+  if (resolved === void 0) throw new UsageError("No team given. Pass --team <key> or set HARNESS_TEAM.");
+  if (!TEAM_KEY_FORMAT.test(resolved)) throw new UsageError(`not a team key: ${resolved} (expected e.g. ALL)`);
+  return resolved;
+}
+function withTeam(params, ctx, opts) {
+  const team = opts.team ?? ctx.config.team ?? void 0;
+  return team === void 0 ? params : { ...params, team };
+}
+function putParam(params, key, value) {
+  return value === void 0 ? params : { ...params, [key]: value };
+}
+function putOpt(body, field3, value) {
+  return value === void 0 ? body : { ...body, [field3]: value };
+}
+function putPresent(body, key, value) {
+  if (value === null || value === void 0 || value === false) return body;
+  return { ...body, [key]: value };
+}
+function putDueDate(body, dueDate) {
+  if (dueDate === null) return body;
+  if (dueDate === "clear") return { ...body, due_date: null };
+  return { ...body, due_date: dueDate };
+}
+function putAssignee(body, assignee) {
+  if (assignee === void 0) return body;
+  return { ...body, assignee: assignee.trim() === "" ? null : assignee };
+}
+function errorText(error) {
+  if (error instanceof HttpError) return `${clean(error.message)} (HTTP ${error.status})`;
+  return `cannot reach the API: ${clean(error.message)}`;
+}
+function str(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+
+// src/commands/extended.ts
+var SAFE_ID = /^(?!\.{1,2}$)[A-Za-z0-9._-]+$/;
+function requireSafeId(kind, id) {
+  if (!SAFE_ID.test(id)) throw new UsageError(`not a ${kind} id: ${id}`);
+}
+function str2(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function field(row, ...keys) {
+  let current = row;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null) return null;
+    current = current[key];
+  }
+  return current ?? null;
+}
+function putOpt2(body, key, value) {
+  return value === void 0 ? body : { ...body, [key]: value };
+}
+function putDate(body, key, raw) {
+  const parsed = optionalDueDate(raw);
+  if (parsed === null) return body;
+  return { ...body, [key]: parsed === "clear" ? null : parsed };
+}
+async function paginatedRead(ctx, path, params, opts) {
+  if (opts.all === true && opts.page !== void 0) {
+    throw new UsageError("--all reads every page from the first \u2014 pass --all or --page, not both");
+  }
+  if (opts.all === true) {
+    const records4 = await fetchEveryPage((page) => ctx.client.get(path, { ...params, page }));
+    return { records: records4, notice: "" };
+  }
+  const body = await ctx.client.get(path, params);
+  const requested = typeof params["page_size"] === "number" ? params["page_size"] : void 0;
+  return { records: body.data, notice: notices(body.meta, requested, body.data) };
+}
+async function projectList(ctx, opts) {
+  let params = { page_size: opts.limit ?? 50, page: opts.page ?? 1 };
+  if (opts.search !== void 0) params = { ...params, search: opts.search };
+  if (opts.state !== void 0) params = { ...params, state: opts.state };
+  const { records: records4, notice } = await paginatedRead(ctx, "/api/v1/projects", params, opts);
+  const human = records4.length === 0 ? "No projects.\n" : table(
+    ["ID", "STATE", "LEAD", "TARGET", "NAME"],
+    records4.map((project) => [
+      str2(project["id"]),
+      str2(project["state"]) || "-",
+      str2(field(project, "lead", "name")) || "-",
+      str2(project["target_date"]) || "-",
+      str2(project["name"])
+    ])
+  );
+  return { json: records4, human, notice };
+}
+async function projectShow(ctx, id) {
+  requireSafeId("project", id);
+  const body = await ctx.client.get(`/api/v1/projects/${id}`);
+  const project = body.data;
+  const fields = [
+    ["State", project["state"]],
+    ["Lead", field(project, "lead", "name")],
+    ["Start", project["start_date"]],
+    ["Target", project["target_date"]],
+    ["Updated", project["updated_at"]]
+  ];
+  const fieldLines = fields.filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([label, value]) => `  ${(label + ":").padEnd(12)}${clean(value)}
+`).join("");
+  const sections = [
+    ["Summary", project["summary"]],
+    ["Description", project["description"]]
+  ];
+  const sectionText = sections.filter(([, text]) => text !== null && text !== void 0 && text !== "").map(([title, text]) => `
+${title}:
+${indent(String(text))}
+`).join("");
+  const milestones = Array.isArray(project["milestones"]) ? project["milestones"] : [];
+  const milestoneText = milestones.length === 0 ? "" : "\nMilestones:\n" + milestones.map((milestone) => `  ${(str2(milestone["target_date"]) || "-").padEnd(12)}${clean(milestone["name"])}
+`).join("");
+  const human = `${str2(project["id"])} \xB7 ${clean(project["name"])}
+` + fieldLines + sectionText + milestoneText;
+  return { json: project, human };
+}
+function projectBody(opts) {
+  let body = {};
+  body = putOpt2(body, "name", opts.name);
+  body = putOpt2(body, "description", opts.description);
+  body = putOpt2(body, "summary", opts.summary);
+  body = putOpt2(body, "state", opts.state);
+  body = putOpt2(body, "lead_id", opts.lead);
+  body = putDate(body, "start_date", opts.startDate);
+  body = putDate(body, "target_date", opts.targetDate);
+  return body;
+}
+async function projectCreate(ctx, opts) {
+  if (opts.name === void 0) throw new UsageError("usage: harness project create --name <name> \u2026");
+  const body = await ctx.client.post("/api/v1/projects", projectBody(opts));
+  const project = body.data;
+  return { json: project, human: `Created project ${clean(project["name"])} (${str2(project["id"])})
+` };
+}
+async function projectUpdate(ctx, id, opts) {
+  requireSafeId("project", id);
+  const patch = projectBody(opts);
+  if (Object.keys(patch).length === 0) {
+    throw new UsageError("usage: harness project update <id> --name \u2026 | --state \u2026 | \u2026");
+  }
+  const body = await ctx.client.patch(`/api/v1/projects/${id}`, patch);
+  return { json: body.data, human: `Updated project ${str2(body.data["id"])}
+` };
+}
+async function milestoneList(ctx, project) {
+  if (project === void 0) throw new UsageError("usage: harness milestone list --project <id>");
+  requireSafeId("project", project);
+  const body = await ctx.client.get(`/api/v1/projects/${project}/milestones`);
+  const human = body.data.length === 0 ? "No milestones.\n" : table(
+    ["ID", "TARGET", "NAME"],
+    body.data.map((milestone) => [
+      str2(milestone["id"]),
+      str2(milestone["target_date"]) || "-",
+      str2(milestone["name"])
+    ])
+  );
+  return { json: body.data, human };
+}
+async function milestoneCreate(ctx, opts) {
+  if (opts.project === void 0 || opts.name === void 0) {
+    throw new UsageError("usage: harness milestone create --project <id> --name <name> [--description TEXT] [--target-date YYYY-MM-DD]");
+  }
+  requireSafeId("project", opts.project);
+  let body = { name: opts.name };
+  body = putOpt2(body, "description", opts.description);
+  body = putDate(body, "target_date", opts.targetDate);
+  const response = await ctx.client.post(`/api/v1/projects/${opts.project}/milestones`, body);
+  const milestone = response.data;
+  return {
+    json: milestone,
+    human: `Created milestone ${clean(milestone["name"])} (${str2(milestone["id"])})
+`
+  };
+}
+async function docList(ctx, opts) {
+  let params = { page_size: opts.limit ?? 50, page: opts.page ?? 1 };
+  if (opts.search !== void 0) params = { ...params, search: opts.search };
+  const { records: records4, notice } = await paginatedRead(ctx, "/api/v1/documents", params, opts);
+  const human = records4.length === 0 ? "No documents.\n" : table(
+    ["ID", "UPDATED", "TITLE"],
+    records4.map((doc) => [str2(doc["id"]), str2(doc["updated_at"]) || "-", str2(doc["title"])])
+  );
+  return { json: records4, human, notice };
+}
+async function docShow(ctx, id) {
+  requireSafeId("document", id);
+  const body = await ctx.client.get(`/api/v1/documents/${id}`);
+  const doc = body.data;
+  const content = doc["content"];
+  const human = `${str2(doc["id"])} \xB7 ${clean(doc["title"])}
+  Updated:    ${clean(doc["updated_at"])}
+` + (content === null || content === void 0 || content === "" ? "" : "\n" + cleanMultiline(String(content)) + "\n");
+  return { json: doc, human };
+}
+async function docCreate(ctx, opts) {
+  if (opts.title === void 0) throw new UsageError("usage: harness doc create --title <title> [--content TEXT] [--project ID]");
+  let body = { title: opts.title };
+  body = putOpt2(body, "content", opts.content);
+  body = putOpt2(body, "project_id", opts.project);
+  const response = await ctx.client.post("/api/v1/documents", body);
+  const doc = response.data;
+  return { json: doc, human: `Created document ${clean(doc["title"])} (${str2(doc["id"])})
+` };
+}
+async function docUpdate(ctx, id, opts) {
+  requireSafeId("document", id);
+  let patch = {};
+  patch = putOpt2(patch, "title", opts.title);
+  patch = putOpt2(patch, "content", opts.content);
+  patch = putOpt2(patch, "project_id", opts.project);
+  if (Object.keys(patch).length === 0) {
+    throw new UsageError("usage: harness doc update <id> --title \u2026 | --content \u2026 | --project \u2026");
+  }
+  const response = await ctx.client.patch(`/api/v1/documents/${id}`, patch);
+  return { json: response.data, human: `Updated document ${str2(response.data["id"])}
+` };
+}
+async function linkList(ctx, issue) {
+  requireIdentifiers([issue]);
+  const body = await ctx.client.get(`/api/v1/issues/${issue}/links`);
+  const human = body.data.length === 0 ? "No links.\n" : table(
+    ["ID", "URL", "TITLE"],
+    body.data.map((link) => [str2(link["id"]), str2(link["url"]), str2(link["title"]) || "-"])
+  );
+  return { json: body.data, human };
+}
+async function linkAdd(ctx, issue, url, title) {
+  requireIdentifiers([issue]);
+  let body = { url };
+  body = putOpt2(body, "title", title);
+  const response = await ctx.client.post(`/api/v1/issues/${issue}/links`, body);
+  return { json: response.data, human: `Linked ${clean(url)} to ${issue}
+` };
+}
+async function findLink(ctx, issue, idOrUrl, allowDuplicateUrl = false) {
+  const body = await ctx.client.get(`/api/v1/issues/${issue}/links`);
+  const idMatch = body.data.find((candidate) => candidate["id"] === idOrUrl);
+  if (idMatch !== void 0) return idMatch;
+  const urlMatches = body.data.filter((candidate) => candidate["url"] === idOrUrl);
+  if (urlMatches.length > 1 && !allowDuplicateUrl) {
+    throw new CommandError(`multiple links on ${issue} match ${idOrUrl}; use a link id`);
+  }
+  if (urlMatches.length === 0) {
+    throw new CommandError(`no link on ${issue} matches ${idOrUrl} (by id or exact URL)`);
+  }
+  return urlMatches[0];
+}
+async function linkUpdate(ctx, issue, idOrUrl, opts) {
+  requireIdentifiers([issue]);
+  let patch = {};
+  patch = putOpt2(patch, "url", opts.url);
+  patch = putOpt2(patch, "title", opts.title);
+  if (Object.keys(patch).length === 0) {
+    throw new UsageError("usage: harness link update <issue> <link-id-or-url> --url <url> | --title <title>");
+  }
+  const id = isUuid(idOrUrl) ? idOrUrl.toLowerCase() : str2((await findLink(ctx, issue, idOrUrl))["id"]);
+  if (!isUuid(idOrUrl)) patch["expected_url"] = idOrUrl;
+  const response = await ctx.client.patch(`/api/v1/issues/${issue}/links/${id}`, patch);
+  return { json: response.data, human: `Updated link ${clean(response.data["url"])} on ${issue}
+` };
+}
+async function linkRm(ctx, issue, idOrUrl) {
+  requireIdentifiers([issue]);
+  const link = await findLink(ctx, issue, idOrUrl, true);
+  await ctx.client.delete(`/api/v1/issues/${issue}/links/${str2(link["id"])}`);
+  return { json: { deleted: link["id"] }, human: `Removed ${clean(link["url"])} from ${issue}
+` };
+}
+async function labelList(ctx) {
+  const body = await ctx.client.get("/api/v1/labels");
+  const human = body.data.length === 0 ? "No labels.\n" : table(
+    ["NAME", "COLOR", "ISSUES", "ID"],
+    body.data.map((label) => [
+      str2(label["name"]),
+      str2(label["color"]) || "-",
+      str2(label["issue_count"] ?? 0),
+      str2(label["id"])
+    ])
+  );
+  return { json: body.data, human };
+}
+async function labelCreate(ctx, name, color) {
+  if (name === void 0) throw new UsageError("usage: harness label create <name> [--color <color>]");
+  let body = { name };
+  body = putOpt2(body, "color", color);
+  const response = await ctx.client.post("/api/v1/labels", body);
+  return { json: response.data, human: `Created label ${clean(response.data["name"])}
+` };
+}
+var TEAM_CREATE_KEY = /^[A-Za-z][A-Za-z0-9]*$/;
+async function teamCreate(ctx, opts) {
+  if (opts.key === void 0 || opts.name === void 0) {
+    throw new UsageError("usage: harness team create --key <key> --name <name>");
+  }
+  if (!TEAM_CREATE_KEY.test(opts.key)) {
+    throw new UsageError(`not a team key: ${opts.key} (expected e.g. ALL \u2014 letters and digits, letter first)`);
+  }
+  const created = await ctx.client.post("/api/v1/teams", { key: opts.key, name: opts.name });
+  const team = created.data;
+  const states = await ctx.client.get(`/api/v1/teams/${str2(team["key"])}/workflow_states`);
+  const human = `Created team ${str2(team["key"])} \u2014 ${clean(team["name"])}
+` + table(
+    ["NAME", "TYPE"],
+    states.data.map((state) => [str2(state["name"]), str2(state["type"])])
+  );
+  return { json: { ...team, workflow_states: states.data }, human };
+}
+async function teamList(ctx) {
+  const body = await ctx.client.get("/api/v1/teams");
+  const human = body.data.length === 0 ? "No teams.\n" : table(
+    ["KEY", "NAME", "ISSUES", "DEFAULT"],
+    body.data.map((team) => [
+      str2(team["key"]),
+      str2(team["name"]),
+      str2(team["issue_count"] ?? 0),
+      team["is_default"] === true ? "yes" : ""
+    ])
+  );
+  return { json: body.data, human };
+}
+async function workflowStates(ctx, team) {
+  const key = requiredTeam({ client: ctx.client, config: ctx.config }, team);
+  const body = await ctx.client.get(`/api/v1/teams/${key}/workflow_states`);
+  const human = body.data.length === 0 ? "No workflow states.\n" : table(
+    ["NAME", "TYPE", "COLOR", "ID"],
+    body.data.map((state) => [
+      str2(state["name"]),
+      str2(state["type"]),
+      str2(state["color"]) || "-",
+      str2(state["id"])
+    ])
+  );
+  return { json: body.data, human };
+}
+async function userList(ctx) {
+  const body = await ctx.client.get("/api/v1/users");
+  const human = body.data.length === 0 ? "No users.\n" : table(
+    ["NAME", "EMAIL", "ID"],
+    body.data.map((user) => [str2(user["name"]), str2(user["email"]), str2(user["id"])])
+  );
+  return { json: body.data, human };
+}
+async function teamRename(ctx, key, name) {
+  if (key === void 0 || name === void 0) {
+    throw new UsageError("usage: harness team rename <key> --name <name>");
+  }
+  const body = await ctx.client.patch(`/api/v1/teams/${encodeURIComponent(key)}`, { name });
+  return { json: body.data, human: `Renamed ${str2(body.data["key"])} to ${clean(body.data["name"])}
+` };
+}
+async function teamSetDefault(ctx, key) {
+  if (key === void 0) throw new UsageError("usage: harness team set-default <key>");
+  const body = await ctx.client.put(`/api/v1/teams/${encodeURIComponent(key)}/default`, {});
+  return {
+    json: body.data,
+    human: `${str2(body.data["key"])} is now the default filing target
+`
+  };
+}
+async function stateAdd(ctx, opts) {
+  const key = requiredTeam({ client: ctx.client, config: ctx.config }, opts.team);
+  if (opts.name === void 0 || opts.type === void 0) {
+    throw new UsageError("usage: harness state add --name <name> --type <type> [--color <color>] [--team <key>]");
+  }
+  let payload = { name: opts.name, type: opts.type };
+  payload = putOpt2(payload, "color", opts.color);
+  const body = await ctx.client.post(`/api/v1/teams/${key}/workflow_states`, payload);
+  return { json: body.data, human: `Added ${clean(body.data["name"])} to ${key}
+` };
+}
+async function stateUpdate(ctx, id, opts) {
+  const key = requiredTeam({ client: ctx.client, config: ctx.config }, opts.team);
+  if (id === void 0) throw new UsageError("usage: harness state update <id> [--name <name>] [--type <type>] [--color <color>]");
+  if (opts.name === void 0 && opts.type === void 0 && opts.color === void 0) {
+    throw new UsageError("nothing to change \u2014 pass at least one of --name, --type, --color");
+  }
+  let payload = {};
+  payload = putOpt2(payload, "name", opts.name);
+  payload = putOpt2(payload, "type", opts.type);
+  payload = putOpt2(payload, "color", opts.color);
+  const body = await ctx.client.patch(`/api/v1/teams/${key}/workflow_states/${encodeURIComponent(id)}`, payload);
+  return { json: body.data, human: `Updated ${clean(body.data["name"])}
+` };
+}
+async function stateOrder(ctx, ids, opts) {
+  const key = requiredTeam({ client: ctx.client, config: ctx.config }, opts.team);
+  if (ids === void 0) {
+    throw new UsageError("usage: harness state order <id,id,id> [--team <key>] \u2014 every state id, in the order you want");
+  }
+  const state_ids = ids.split(",").map((id) => id.trim()).filter((id) => id !== "");
+  if (state_ids.length === 0) throw new UsageError("no state ids given");
+  const body = await ctx.client.put(`/api/v1/teams/${key}/workflow_states/order`, { state_ids });
+  const human = table(
+    ["NAME", "TYPE"],
+    body.data.map((state) => [str2(state["name"]), str2(state["type"])])
+  );
+  return { json: body.data, human };
+}
+async function stateDelete(ctx, id, opts) {
+  const key = requiredTeam({ client: ctx.client, config: ctx.config }, opts.team);
+  if (id === void 0) throw new UsageError("usage: harness state delete <id> --yes [--team <key>]");
+  requireYes("state delete", id, opts.yes);
+  await ctx.client.delete(`/api/v1/teams/${key}/workflow_states/${encodeURIComponent(id)}`);
+  return { json: { deleted: id }, human: `Deleted workflow state ${id}
+` };
+}
+async function labelUpdate(ctx, id, opts) {
+  if (id === void 0) throw new UsageError("usage: harness label update <id> [--name <name>] [--color <color>]");
+  if (opts.name === void 0 && opts.color === void 0) {
+    throw new UsageError("nothing to change \u2014 pass --name, --color, or both");
+  }
+  let payload = {};
+  payload = putOpt2(payload, "name", opts.name);
+  payload = putOpt2(payload, "color", opts.color);
+  const body = await ctx.client.patch(`/api/v1/labels/${encodeURIComponent(id)}`, payload);
+  return { json: body.data, human: `Updated label ${clean(body.data["name"])}
+` };
+}
+async function labelDelete(ctx, id, opts) {
+  if (id === void 0) throw new UsageError("usage: harness label delete <id> --yes");
+  requireYes("label delete", id, opts.yes);
+  await ctx.client.delete(`/api/v1/labels/${encodeURIComponent(id)}`);
+  return { json: { deleted: id }, human: `Deleted label ${id}
+` };
+}
+async function memberList(ctx) {
+  const body = await ctx.client.get("/api/v1/members");
+  const human = body.data.length === 0 ? "No members.\n" : table(
+    ["NAME", "EMAIL", "RANK", "STANDING", "ID"],
+    body.data.map((member) => [
+      str2(field(member, "user", "name")),
+      str2(field(member, "user", "email")),
+      str2(member["role"]) || "-",
+      str2(member["standing"]),
+      str2(field(member, "user", "id"))
+    ])
+  );
+  return { json: body.data, human };
+}
+async function memberAdd(ctx, opts) {
+  if (opts.email === void 0 || opts.role === void 0) {
+    throw new UsageError("usage: harness member add --email <email> --role <admin|staff|collaborator>");
+  }
+  const body = await ctx.client.post("/api/v1/members", { email: opts.email, role: opts.role });
+  return {
+    json: body.data,
+    human: `Added ${str2(field(body.data, "user", "email"))} as ${str2(body.data["role"])}
+`
+  };
+}
+async function memberSetRole(ctx, userId, opts) {
+  if (userId === void 0 || opts.role === void 0) {
+    throw new UsageError("usage: harness member set-role <user-id> --role <admin|staff|collaborator|none>");
+  }
+  const body = await ctx.client.put(`/api/v1/members/${encodeURIComponent(userId)}/role`, { role: opts.role });
+  const rank = str2(body.data["role"]);
+  const human = rank === "" ? `Revoked the rank for ${str2(field(body.data, "user", "email"))}
+` : `${str2(field(body.data, "user", "email"))} is now ${rank}
+`;
+  return { json: body.data, human };
+}
+function requireYes(command, id, yes) {
+  if (yes !== true) throw new UsageError(`${command} ${id} is destructive \u2014 pass --yes to confirm`);
+}
+async function upload(ctx, path) {
+  return attachFile(ctx, path);
+}
+function indent(text) {
+  return cleanMultiline(text).split("\n").map((line) => "  " + line).join("\n");
+}
+
+// src/commands/operator-catalog.ts
+var SCHEMA_VIEWS = ["input", "result"];
+var MAX_QUERY_BYTES = 200;
+var MAX_CATALOG_PAGES = 200;
+var MAX_SCHEMA_PAGES = 1e3;
+var SCHEMA_ENCODING = "json_fragments_v1";
+var CAPABILITY_ID_FORMAT = /^[A-Za-z0-9_.:-]{1,200}$/;
+var APPROVAL_NOTE = "Write and send capabilities, and any proposal, need a person's approval in the app before they take effect.\n";
+var REFUSALS = {
+  operator_disabled: "nothing here works until it is switched back on",
+  operator_not_permitted: "this account has no admin or member role in the organization the credential is bound to",
+  actor_required: `this credential acts as no person: sign in with \`${invokedName()} login\`, or use an API token minted for a user`,
+  run_bound_credential: "a run-bound credential can't read Operator's catalog",
+  forbidden: "Operator needs the operator:read scope (aone_ API tokens must be minted with it) and an admin or member role"
+};
+async function toolsList(ctx, opts) {
+  requireToolsOpts(opts);
+  const { items, meta } = await capabilityPages(ctx, {}, opts);
+  return {
+    json: items,
+    human: items.length === 0 ? "Operator can use no capabilities here.\n" : capabilitiesTable(items, false),
+    notice: pagingNotice(items, meta, opts, "capabilities")
+  };
+}
+async function toolsSearch(ctx, query, opts) {
+  requireSearchQuery(query);
+  requireToolsOpts(opts);
+  const { items, meta } = await capabilityPages(ctx, { q: query }, opts);
+  return {
+    json: items,
+    human: items.length === 0 ? `No capability Operator can use matches "${clean(query)}".
+` : capabilitiesTable(items, true),
+    notice: pagingNotice(items, meta, opts, "matches")
+  };
+}
+async function toolsDomains(ctx) {
+  const body = await operatorRequest(() => ctx.client.get("/api/v1/operator/capabilities/domains"));
+  const domains = records(body.data, "domains");
+  return {
+    json: domains,
+    human: domains.length === 0 ? "Operator can use no capabilities here.\n" : table(
+      ["DOMAIN", "CAPABILITIES"],
+      domains.map((domain) => [str3(domain["domain"]), str3(domain["count"])])
+    )
+  };
+}
+async function toolShow(ctx, id, opts) {
+  requireCapabilityId(id);
+  const view = requireSchemaView(opts.schema);
+  const fragments = [];
+  let capability = {};
+  let fragmentCount = null;
+  for (let page = 1; ; page++) {
+    const body = await operatorRequest(
+      () => ctx.client.get(`/api/v1/operator/capabilities/${id}`, { schema: view, page }),
+      `Operator can't use a capability ${id} here: it doesn't exist, or it is disabled or switched off`
+    );
+    const data = body.data;
+    if (!isRecord(data)) throw new CommandError("The capability response carried no capability.");
+    if (data["id"] !== id || data["schema"] !== view || data["page"] !== page) {
+      throw new CommandError(
+        `The capability response is not page ${page} of ${id}'s ${view} schema (it says page ${clean(data["page"])} of ${clean(data["id"])}'s ${clean(data["schema"])} schema).`
+      );
+    }
+    if (data["schema_encoding"] !== SCHEMA_ENCODING) {
+      throw new CommandError(
+        `The capability's schema comes in an encoding this CLI does not read (${clean(data["schema_encoding"])}) \u2014 upgrade the CLI.`
+      );
+    }
+    const count = data["fragment_count"];
+    if (typeof count !== "number" || !Number.isInteger(count) || count < 1) {
+      throw new CommandError(`The capability's schema page ${page} carries no valid fragment count.`);
+    }
+    if (fragmentCount !== null && count !== fragmentCount) {
+      throw new CommandError(
+        `The capability's schema pages disagree on the fragment count (${fragmentCount}, then ${count} on page ${page}).`
+      );
+    }
+    fragmentCount = count;
+    const pageFragments = data["fragments"];
+    if (!Array.isArray(pageFragments) || !pageFragments.every((fragment) => typeof fragment === "string")) {
+      throw new CommandError(`The capability's schema page ${page} carried no fragments.`);
+    }
+    fragments.push(...pageFragments);
+    capability = data;
+    const next = data["next_page"];
+    if (next === null || next === void 0) break;
+    if (next !== page + 1 || next > MAX_SCHEMA_PAGES) {
+      throw new CommandError(`The capability's schema page ${page} names an invalid next page (${clean(next)}).`);
+    }
+  }
+  if (fragments.length !== fragmentCount) {
+    throw new CommandError(
+      `The capability's schema came back incomplete: ${fragments.length} of ${fragmentCount} fragments.`
+    );
+  }
+  let schema;
+  try {
+    schema = JSON.parse(fragments.join(""));
+  } catch {
+    throw new CommandError("The capability's schema fragments do not join into valid JSON.");
+  }
+  const shown = { ...withoutSchemaPaging(capability), [`${view}_schema`]: schema };
+  return { json: shown, human: capabilityDetail(shown, view, schema) };
+}
+async function skillsList(ctx) {
+  const body = await operatorRequest(() => ctx.client.get("/api/v1/operator/skills"));
+  const skills = records(body.data, "skills").map((skill) => ({
+    id: skill["id"],
+    title: skill["title"],
+    invocation_name: skill["invocation_name"],
+    content_sha256: skill["content_sha256"]
+  }));
+  return {
+    json: skills,
+    human: skills.length === 0 ? "No skills are assigned to Operator in this organization.\n" : table(
+      ["INVOCATION", "TITLE", "SHA-256", "ID"],
+      skills.map((skill) => [
+        str3(skill.invocation_name),
+        truncate(skill.title),
+        str3(skill.content_sha256),
+        str3(skill.id)
+      ])
+    )
+  };
+}
+function requireCapabilityId(id) {
+  if (!CAPABILITY_ID_FORMAT.test(id) || /^\.+$/.test(id)) {
+    throw new UsageError(`not a capability id: ${clean(id)} (e.g. crm.party.search)`);
+  }
+  if (id === "domains") {
+    throw new UsageError(`domains is not a capability id \u2014 \`${invokedName()} tools domains\` lists the domains`);
+  }
+}
+function requireSearchQuery(query) {
+  if (query.trim() === "") throw new UsageError("the search query is empty \u2014 say what to search for");
+  if (Buffer.byteLength(query, "utf8") > MAX_QUERY_BYTES) {
+    throw new UsageError(`the search query is over ${MAX_QUERY_BYTES} bytes \u2014 shorten it`);
+  }
+}
+function requireToolsOpts(opts) {
+  if (opts.domain !== void 0 && opts.domain.trim() === "") {
+    throw new UsageError("the domain is empty \u2014 name one, or leave it out for every domain");
+  }
+  if (opts.cursor !== void 0 && opts.cursor.trim() === "") {
+    throw new UsageError("the cursor is empty \u2014 pass a page's cursor, or leave it out for the first page");
+  }
+}
+function requireSchemaView(view) {
+  if (view === void 0) return "input";
+  if (SCHEMA_VIEWS.includes(view)) return view;
+  throw new UsageError(`--schema must be input or result, not ${clean(view)}`);
+}
+async function capabilityPages(ctx, base, opts) {
+  const params = { ...base, domain: opts.domain };
+  let page = await capabilityPage(ctx, { ...params, cursor: opts.cursor }, CALLER_CURSOR);
+  const items = [...page.items];
+  if (opts.all === true) {
+    const seen = new Set(opts.cursor === void 0 ? [] : [opts.cursor]);
+    let pages = 1;
+    while (page.nextCursor !== null) {
+      if (seen.has(page.nextCursor)) throw new CommandError("The capabilities response repeated a cursor.");
+      if (pages >= MAX_CATALOG_PAGES) {
+        throw new CommandError(`The capabilities listing ran past ${MAX_CATALOG_PAGES} pages; stopped there.`);
+      }
+      seen.add(page.nextCursor);
+      page = await capabilityPage(ctx, { ...params, cursor: page.nextCursor }, WALK_CURSOR);
+      pages++;
+      items.push(...page.items);
+    }
+  }
+  return { items: dedupeById(items), meta: page.meta };
+}
+var CALLER_CURSOR = "start again without the cursor";
+var WALK_CURSOR = "the listing changed or its cursor expired while following pages; run it again";
+async function capabilityPage(ctx, params, staleCursor) {
+  const body = await operatorRequest(
+    () => ctx.client.get("/api/v1/operator/capabilities", params),
+    void 0,
+    staleCursor
+  );
+  const items = records(body.data, "capabilities");
+  const meta = body.meta;
+  if (!isRecord(meta)) throw new CommandError("The capabilities response has no pagination metadata.");
+  const nextCursor = meta.next_cursor;
+  if (nextCursor !== null && (typeof nextCursor !== "string" || nextCursor === "")) {
+    throw new CommandError("The capabilities response has an invalid next_cursor.");
+  }
+  if (nextCursor !== null && items.length === 0) {
+    throw new CommandError("The capabilities response says there are more pages but holds no capabilities.");
+  }
+  return { items, meta, nextCursor };
+}
+async function operatorRequest(send, notFound2 = "this Harness server has no Operator API yet", staleCursor = CALLER_CURSOR) {
+  try {
+    return await send();
+  } catch (error) {
+    throw explain(error, notFound2, staleCursor);
+  }
+}
+function explain(error, notFound2, staleCursor) {
+  if (!(error instanceof HttpError)) return error;
+  const code = typeof error.body["error"] === "string" ? error.body["error"] : "";
+  let hint;
+  if (error.status === 403) hint = Object.hasOwn(REFUSALS, code) ? REFUSALS[code] : void 0;
+  else if (error.status === 404) hint = notFound2;
+  else if (error.status === 400 && code === "invalid_cursor") hint = staleCursor;
+  else if (error.status === 400 && /\bdomain\b/.test(error.message)) {
+    hint = "no such domain; listing without one shows each capability's domain";
+  }
+  if (hint === void 0) return error;
+  return new HttpError(error.status, `${error.message} \u2014 ${hint}`, error.body, error.retryAfter);
+}
+function capabilitiesTable(items, search2) {
+  const headers = ["ID", "KIND", "DOMAIN", "SUMMARY"];
+  const rows = items.map((item) => [
+    str3(item["id"]),
+    kindName(item),
+    str3(item["domain"]),
+    truncate(item["summary"])
+  ]);
+  const table2 = search2 ? table(
+    ["SCORE", ...headers],
+    rows.map((row, index) => [str3(items[index]["score"]), ...row])
+  ) : table(headers, rows);
+  return table2 + (items.some(needsApproval) ? "\n" + APPROVAL_NOTE : "");
+}
+function pagingNotice(items, meta, opts, noun) {
+  if (opts.all === true || typeof meta.next_cursor !== "string") return void 0;
+  const of = typeof meta.count === "number" ? ` of ${meta.count}` : "";
+  return `harness: showing ${items.length}${of} ${noun} \u2014 pass --all for every page, or --cursor ${clean(meta.next_cursor)} for the next one.
+`;
+}
+function capabilityDetail(capability, view, schema) {
+  const kind = kindName(capability);
+  const line = (label, value) => `  ${(label + ":").padEnd(10)}${clean(value)}
+`;
+  const description = cleanMultiline(str3(capability["description"]));
+  return `${clean(capability["id"])}
+` + line("Domain", str3(capability["domain"])) + line("Kind", kind === "send" ? "send \u2014 delivered beyond the platform" : kind) + line("Mode", `${str3(capability["mode"])} (effect: ${str3(capability["effect"])})`) + line("Summary", str3(capability["summary"])) + line("Approval", approval(capability)) + (description === "" ? "" : `
+Description:
+${indent2(description)}
+`) + `
+${view === "input" ? "Input" : "Result"} schema:
+${indent2(cleanMultiline(JSON.stringify(schema, null, 2)))}
+`;
+}
+function needsApproval(capability) {
+  return capability["kind"] === "write" || capability["kind"] === "send" || capability["mode"] === "proposal";
+}
+function approval(capability) {
+  if (needsApproval(capability)) return "a person approves it in the app before it takes effect";
+  if (capability["kind"] === "read") return "not needed for a read";
+  const kind = kindName(capability);
+  return kind === "unknown" ? "unknown: the server named no kind" : `unknown for a capability of kind ${kind}`;
+}
+function kindName(capability) {
+  const kind = capability["kind"];
+  return typeof kind === "string" && kind.trim() !== "" ? kind : "unknown";
+}
+var SCHEMA_PAGING_FIELDS = /* @__PURE__ */ new Set(["schema", "schema_encoding", "fragments", "fragment_count", "page", "next_page"]);
+function withoutSchemaPaging(capability) {
+  return Object.fromEntries(Object.entries(capability).filter(([key]) => !SCHEMA_PAGING_FIELDS.has(key)));
+}
+function records(value, what) {
+  if (!Array.isArray(value) || !value.every(isRecord)) {
+    throw new CommandError(`The ${what} response carried no list.`);
+  }
+  return value;
+}
+function dedupeById(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seen.has(item["id"])) return false;
+    seen.add(item["id"]);
+    return true;
+  });
+}
+function indent2(text) {
+  return text.split("\n").map((line) => "  " + line).join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str3(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+
+// src/commands/operator-jobs.ts
+var JOB_STATES = [
+  "draft",
+  "planning",
+  "ready",
+  "running",
+  "waiting_for_approval",
+  "waiting_for_human",
+  "paused",
+  "failed",
+  "needs_reconciliation",
+  "completed",
+  "cancelled"
+];
+var JOB_STATUS_ALIASES = ["open", "waiting", "done"];
+var JOBS_MAX_LIMIT = 50;
+var JOBS_MAX_PAGES = 100;
+var EVENTS_PAGE_LIMIT = 200;
+var WATCH_INTERVAL_MS = 2e3;
+var WATCH_WAITING_INTERVAL_MS = 1e4;
+var WATCH_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+var RETRY_AFTER_CAP_MS = 3e5;
+var EXIT_WAITING_FOR_PERSON = 4;
+var EXIT_JOB_ENDED = 5;
+var EXIT_INTERRUPTED = 130;
+var INTERRUPTED = "interrupted";
+var READER_GONE = "reader-gone";
+var ENDED_STATES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var CHANGE_SET_FIELDS = [
+  "manifest_id",
+  "version",
+  "digest",
+  "status",
+  "plan_version",
+  "max_effect_count",
+  "actions"
+];
+var CHANGE_SET_ACTION_FIELDS = [
+  "id",
+  "action_type",
+  "action_version",
+  "display_order",
+  "effect_count",
+  "required_capability_ids",
+  "digest"
+];
+var WITHHELD_FIELDS = /* @__PURE__ */ new Set([
+  "objective",
+  "objective_text",
+  "instruction",
+  "instructions",
+  "description",
+  "result",
+  "results",
+  "outputs",
+  "investigation",
+  "read_material",
+  "public_research",
+  "source_review",
+  "review_actions",
+  "manifest_actions",
+  "recipe",
+  "lua",
+  "lua_source"
+]);
+var CODE = /^[a-z0-9_.:-]{1,64}$/;
+var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function requireJobsArgs(opts) {
+  if (opts.status !== void 0) normalizeStatus(opts.status);
+  if (opts.limit !== void 0 && (!Number.isInteger(opts.limit) || opts.limit < 1 || opts.limit > JOBS_MAX_LIMIT)) {
+    throw new UsageError(`--limit takes an integer from 1 to ${JOBS_MAX_LIMIT}`);
+  }
+}
+function normalizeStatus(status) {
+  const tokens = status.split(",").map((token) => token.trim().toLowerCase()).filter((token) => token !== "");
+  const known = [...JOB_STATES, ...JOB_STATUS_ALIASES];
+  const unknown = tokens.filter((token) => !known.includes(token));
+  if (tokens.length === 0 || unknown.length > 0) {
+    throw new UsageError(
+      `${tokens.length === 0 ? "--status is empty" : `unknown job status: ${unknown.join(", ")}`} \u2014 pass job states (${JOB_STATES.join(", ")}) or ${JOB_STATUS_ALIASES.join(", ")}, comma-separated`
+    );
+  }
+  return tokens.join(",");
+}
+async function jobsList(ctx, opts) {
+  requireJobsArgs(opts);
+  const params = {
+    status: opts.status === void 0 ? void 0 : normalizeStatus(opts.status),
+    mine: opts.mine === true ? true : void 0,
+    // Reading everything: full pages, so the walk takes as few requests as it can.
+    limit: opts.limit ?? (opts.all === true ? JOBS_MAX_LIMIT : void 0)
+  };
+  let page = await jobsPage(ctx, params, void 0);
+  let jobs = page.jobs;
+  if (opts.all !== true) {
+    if (!page.hasMore) return { json: jobs, human: jobsTable(jobs) };
+    if (jobs.length === 0) {
+      return {
+        json: jobs,
+        human: "No Operator jobs you can see on this page.\n",
+        notice: "harness: older jobs may exist past this page \u2014 pass --all to read on.\n"
+      };
+    }
+    return {
+      json: jobs,
+      human: jobsTable(jobs),
+      notice: `harness: showing the newest ${plural(jobs.length, "Operator job")} \u2014 pass --all for older ones.
+`
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let pages = 1;
+  while (page.hasMore && pages < JOBS_MAX_PAGES) {
+    const cursor = page.nextCursor;
+    if (seen.has(cursor)) throw new CommandError("The jobs response repeated a cursor.");
+    seen.add(cursor);
+    page = await jobsPage(ctx, params, cursor);
+    pages += 1;
+    jobs = [...jobs, ...page.jobs];
+  }
+  jobs = uniqueById(jobs);
+  if (!page.hasMore) return { json: jobs, human: jobsTable(jobs) };
+  return {
+    json: jobs,
+    human: jobsTable(jobs),
+    notice: `harness: stopped after ${JOBS_MAX_PAGES} pages (${plural(jobs.length, "job")}) without reaching the end \u2014 narrow the list with --status or --mine.
+`,
+    exitCode: 1
+  };
+}
+async function jobsPage(ctx, params, before) {
+  const body = await explained(
+    () => ctx.client.get("/api/v1/operator/jobs", { ...params, before }),
+    { notFound: "this Harness server has no Operator API yet" }
+  );
+  const jobs = objects(body.data, "jobs").map(withheld);
+  const meta = body.meta;
+  if (typeof meta !== "object" || meta === null || typeof meta["has_more"] !== "boolean") {
+    throw new CommandError("The jobs response has no paging metadata.");
+  }
+  if (meta["has_more"] !== true) return { jobs, hasMore: false, nextCursor: null };
+  const cursor = meta["next_cursor"];
+  if (typeof cursor !== "string" || cursor === "") {
+    throw new CommandError("The jobs response says more exist but gives no cursor.");
+  }
+  return { jobs, hasMore: true, nextCursor: cursor };
+}
+function requireJobId(id) {
+  if (!isUuid(id)) throw new UsageError(`not an Operator job id: ${id} (expected the job's UUID)`);
+}
+async function jobShow(ctx, id, opts = {}) {
+  requireJobId(id);
+  const body = await explained(() => ctx.client.get(`/api/v1/operator/jobs/${id}`), {
+    notFound: missingJob(id)
+  });
+  if (!isRecord2(body.data)) throw new CommandError("The job response carried no job.");
+  const job = withheld(body.data);
+  if (opts.changes !== true && opts.people !== true) return { json: job, human: jobDetail(job) };
+  const document = Object.fromEntries(
+    ["id", "state", "waiting_on", "url", "approval_url"].map((key) => [key, job[key] ?? null])
+  );
+  const sections = [];
+  let notice;
+  if (opts.changes === true) {
+    const changeSet = await jobChangeSet(ctx, id);
+    document["change_set"] = changeSet;
+    sections.push(changesText(id, job, changeSet));
+    notice = changeSetRace(job, changeSet);
+  }
+  if (opts.people === true) {
+    const people = jobPeople(job);
+    document["people"] = people;
+    sections.push(peopleText(id, people));
+  }
+  return { json: document, human: sections.join("\n"), ...notice === void 0 ? {} : { notice } };
+}
+function changeSetRace(job, changeSet) {
+  const pending = field2(job, "pending_approval", "manifest_id");
+  if (typeof pending !== "string") return void 0;
+  const read = changeSet === null ? null : changeSet["manifest_id"];
+  if (read === pending) return void 0;
+  return `harness: the job waits for approval of change set ${clean(pending)}, but the change set read next is ${read === null ? "none" : clean(read)}: the job changed between the two reads, so run it again.
+`;
+}
+async function jobChangeSet(ctx, id) {
+  const body = await explained(() => ctx.client.get(`/api/v1/operator/jobs/${id}/changes`), {
+    notFound: missingJob(id)
+  });
+  if (body.data === null) return null;
+  if (!isRecord2(body.data)) throw new CommandError("The change set response carried no change set.");
+  return {
+    ...pick(body.data, CHANGE_SET_FIELDS),
+    actions: records2(body.data["actions"]).map((action) => pick(action, CHANGE_SET_ACTION_FIELDS))
+  };
+}
+function jobPeople(job) {
+  const participants = records2(field2(job, "people", "participants"));
+  const owner = isRecord2(job["owner"]) ? job["owner"] : null;
+  const names = /* @__PURE__ */ new Map();
+  for (const named2 of owner === null ? participants : [...participants, owner]) {
+    if (typeof named2["user_id"] === "string" && typeof named2["name"] === "string" && named2["name"] !== "") {
+      if (!names.has(named2["user_id"])) names.set(named2["user_id"], named2["name"]);
+    }
+  }
+  const person = (userId) => typeof userId === "string" && userId !== "" ? { user_id: userId, name: names.get(userId) ?? null } : null;
+  const some = (people) => people.filter((entry) => entry !== null);
+  const approvers = field2(job, "people", "approver_user_ids");
+  return {
+    requester: person(job["requester_user_id"]),
+    execution_principal: person(job["execution_principal_user_id"]),
+    owner: owner === null ? null : person(owner["user_id"]),
+    approvers: some((Array.isArray(approvers) ? approvers : []).map(person)),
+    collaborators: some(participants.filter((entry) => entry["role"] === "collaborator").map((entry) => person(entry["user_id"])))
+  };
+}
+async function jobWatch(ctx, id, opts) {
+  requireJobId(id);
+  if (opts.after !== void 0 && (!Number.isInteger(opts.after) || opts.after < 0)) {
+    throw new UsageError("--after takes a non-negative event sequence");
+  }
+  const emit = opts.onLine ?? (() => {
+  });
+  const sleep = opts.sleep ?? abortableSleep;
+  const signal = opts.signal;
+  let after = opts.after ?? 0;
+  const events = [];
+  let job = null;
+  let shown = null;
+  let shownApprovalUrl = null;
+  const document = (outcome, extra = {}) => ({
+    id,
+    outcome,
+    ...extra,
+    job: job === null ? null : jobStateJson(job),
+    ...opts.collectEvents === true ? { events } : {},
+    next_after: after
+  });
+  const stopped = (reason) => reason === READER_GONE ? (
+    // Nobody is reading any more: end quietly.
+    { json: document("stopped"), human: "", exitCode: 0 }
+  ) : { json: document("interrupted"), human: "", notice: resumeLine(id, after), exitCode: EXIT_INTERRUPTED };
+  for (; ; ) {
+    if (aborted(signal)) return stopped(signal?.reason);
+    let page;
+    try {
+      page = await withRetries(() => eventsPage(ctx, id, after), sleep, signal);
+    } catch (error) {
+      if (aborted(signal)) return stopped(signal?.reason);
+      if (!transient(error)) throw error;
+      const message = failureMessage(error);
+      return {
+        json: document("error", {
+          error: { message, status: error instanceof HttpError ? error.status : null }
+        }),
+        human: "",
+        notice: `harness: ${message}
+` + resumeLine(id, after),
+        exitCode: error instanceof TransportError ? 3 : 1
+      };
+    }
+    for (const event of page.events) {
+      if (opts.collectEvents === true) events.push(eventJson(event));
+      emit(eventLine(event));
+    }
+    after = page.nextAfter;
+    job = page.job;
+    if (page.hasMore) continue;
+    const state = str4(job["state"]);
+    const waitingOn = typeof job["waiting_on"] === "string" ? job["waiting_on"] : null;
+    if (shown === null || shown.state !== state || shown.waitingOn !== waitingOn) {
+      emit(stateLine(shown?.state ?? null, state, waitingOn));
+      shown = { state, waitingOn };
+    }
+    const approvalUrl = typeof job["approval_url"] === "string" ? job["approval_url"] : null;
+    if (opts.throughWaits === true && approvalUrl !== null && approvalUrl !== shownApprovalUrl) {
+      emit(`approve in the app: ${clean(approvalUrl)}
+`);
+    }
+    shownApprovalUrl = approvalUrl;
+    let outcome = null;
+    if (ENDED_STATES.has(state)) outcome = state;
+    else if (waitingOn !== null && opts.throughWaits !== true) outcome = "waiting";
+    if (outcome !== null) {
+      return {
+        json: document(outcome),
+        human: outcomeText(id, outcome, job),
+        exitCode: outcome === "completed" ? 0 : outcome === "waiting" ? EXIT_WAITING_FOR_PERSON : EXIT_JOB_ENDED
+      };
+    }
+    if (aborted(signal)) return stopped(signal?.reason);
+    await sleep(waitingOn !== null || state === "paused" ? WATCH_WAITING_INTERVAL_MS : WATCH_INTERVAL_MS, signal);
+  }
+}
+function resumeLine(id, after) {
+  const name = invokedName();
+  return `${name}: stopped watching job ${id}; resume with: ${name} watch ${id} --after ${after}
+`;
+}
+function watchStopSignal(stdout = process.stdout, signals = process) {
+  const controller = new AbortController();
+  const readerGone = () => controller.abort(READER_GONE);
+  stdout.once("error", readerGone);
+  stdout.once("close", readerGone);
+  signals.once("SIGINT", () => controller.abort(INTERRUPTED));
+  return controller.signal;
+}
+function aborted(signal) {
+  return signal?.aborted === true;
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (aborted(signal)) {
+      resolve();
+      return;
+    }
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function transient(error) {
+  if (error instanceof TransportError) return true;
+  return error instanceof HttpError && !(error instanceof UpgradeRequiredError) && (error.status >= 500 || error.status === 429);
+}
+async function withRetries(send, sleep, signal) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await send();
+    } catch (error) {
+      if (attempt >= WATCH_RETRIES || !transient(error) || aborted(signal)) throw error;
+      await sleep(retryDelay(error, attempt), signal);
+      if (aborted(signal)) throw error;
+    }
+  }
+}
+function retryDelay(error, attempt) {
+  const backoff = RETRY_BASE_MS * 2 ** attempt;
+  const asked = error instanceof HttpError ? retryAfterMs(error.retryAfter) : null;
+  return asked === null ? backoff : Math.max(backoff, Math.min(asked, RETRY_AFTER_CAP_MS));
+}
+function retryAfterMs(header) {
+  if (header === null) return null;
+  const value = header.trim();
+  if (/^\d+$/.test(value)) return Number.parseInt(value, 10) * 1e3;
+  const at = Date.parse(value);
+  return Number.isNaN(at) ? null : Math.max(0, at - Date.now());
+}
+function failureMessage(error) {
+  if (error instanceof TransportError) return `cannot reach the API: ${clean(error.message)}`;
+  return `${clean(error.message)} (HTTP ${error.status})${errorDetails(error.body)}`;
+}
+async function eventsPage(ctx, id, after) {
+  const body = await explained(
+    () => ctx.client.get(`/api/v1/operator/jobs/${id}/events`, {
+      after,
+      limit: EVENTS_PAGE_LIMIT
+    }),
+    { notFound: missingJob(id) }
+  );
+  const events = objects(body.data, "events");
+  const meta = body.meta;
+  if (typeof meta !== "object" || meta === null) throw new CommandError("The events response has no metadata.");
+  const nextAfter = meta["next_after"];
+  const hasMore = meta["has_more"];
+  const job = meta["job"];
+  if (typeof nextAfter !== "number" || !Number.isInteger(nextAfter) || nextAfter < after) {
+    throw new CommandError("The events response has an invalid next_after.");
+  }
+  if (typeof hasMore !== "boolean") throw new CommandError("The events response has an invalid has_more.");
+  if (!isRecord2(job) || typeof job["state"] !== "string") {
+    throw new CommandError("The events response does not carry the job's state.");
+  }
+  if (hasMore && nextAfter === after) {
+    throw new CommandError("The events response says more exist but did not move its cursor.");
+  }
+  return { events, nextAfter, hasMore, job };
+}
+var REFUSAL_HINTS = {
+  operator_disabled: "nothing can be read until Operator is switched back on for this organization",
+  operator_not_permitted: "only the organization's admins and members use Operator; guests and people outside it cannot",
+  actor_required: `the credential acts as no person: sign in with \`${invokedName()} login\`, or use an API token a person created`,
+  forbidden: `the credential lacks the operator:read scope (\`${invokedName()} login\` carries it; an aone_ token must be created with it, bound to this organization), or you are a guest or outside the organization`,
+  run_bound_credential: `a run-bound credential cannot read Operator jobs; sign in with \`${invokedName()} login\``
+};
+function missingJob(id) {
+  return `no Operator job ${id} you can see: it does not exist, is in another organization, or is not shared with you (or this Harness server has no Operator API yet)`;
+}
+async function explained(send, why) {
+  try {
+    return await send();
+  } catch (error) {
+    if (!(error instanceof HttpError)) throw error;
+    const code = error.body["error"];
+    let hint;
+    if (error.status === 403 && typeof code === "string") hint = REFUSAL_HINTS[code];
+    if (error.status === 404) hint = why.notFound;
+    if (error.status === 400 && code === "invalid_cursor") hint = "run the list again from the start";
+    if (hint === void 0) throw error;
+    throw new HttpError(error.status, `${error.message} \u2014 ${hint}`, error.body, error.retryAfter);
+  }
+}
+function jobsTable(jobs) {
+  if (jobs.length === 0) return "No Operator jobs.\n";
+  const rows = jobs.map((job) => [
+    str4(job["id"]),
+    str4(job["state"]) || "-",
+    str4(job["waiting_on"]) || "-",
+    str4(job["objective_kind"]) || "-",
+    personName(job["owner"]),
+    str4(field2(job, "plan_step", "issue")) || "-",
+    str4(job["updated_at"]) || "-"
+  ]);
+  const table2 = table(["ID", "STATE", "WAITING ON", "KIND", "OWNER", "PLAN STEP", "UPDATED"], rows);
+  const approvals = jobs.filter((job) => typeof job["approval_url"] === "string");
+  if (approvals.length === 0) return table2;
+  return table2 + "\nWaiting for approval. Approve in the app; the CLI cannot:\n" + approvals.map((job) => `  ${clean(job["id"])}  ${clean(job["approval_url"])}
+`).join("");
+}
+function jobDetail(job) {
+  const waitingOn = str4(job["waiting_on"]);
+  const header = `Operator job ${clean(job["id"])} \xB7 ${clean(job["state"])}` + (waitingOn === "" ? "" : ` \xB7 waiting on ${clean(waitingOn)}`) + "\n";
+  const people = records2(field2(job, "people", "participants"));
+  const fields = [
+    ["Kind", str4(job["objective_kind"]) || "-"],
+    ["Role", str4(job["viewer_role"]) || null],
+    ["Owner", isRecord2(job["owner"]) ? personName(job["owner"]) : null],
+    ["Plan step", planStepLine(job["plan_step"])],
+    ["Plan", planLine(job["plan"])],
+    ["Progress", progressLine(job["progress"])],
+    ["Window", windowLine(job["window"])],
+    ["Spend", spendLine(job["spend"])],
+    ["Verification", str4(field2(job, "verification", "status")) || null],
+    ["Effects", effectsLine(job["effects"])],
+    ["Skill", skillLine(job["skill"])],
+    ["Grant", grantLine(job["grant"], people)],
+    ["Created", str4(job["inserted_at"]) || null],
+    ["Updated", str4(job["updated_at"]) || null],
+    ["Workbench", str4(job["url"]) || null]
+  ];
+  return header + labelled(fields) + approvalSection(job["pending_approval"], people) + listSection("Blockers", records2(job["blockers"]), (item) => `${str4(item["kind"])}: ${str4(item["state"])}`) + listSection("Artifacts", records2(job["artifacts"]), (item) => `${str4(item["id"])}  ${str4(item["url"])}`) + peopleSection(people) + listSection(
+    "Procedures",
+    records2(job["procedures"]),
+    (procedure) => `${str4(procedure["name"])}  v${str4(procedure["current_version"])}  ${str4(procedure["id"])}`
+  ) + controlsLine(job["viewer_can"]) + "\nThe objective's text is not shown: the API never returns it, because it can quote what Operator read. Open the workbench link to read it.\n";
+}
+function labelled(fields, width = 15) {
+  return fields.filter((entry) => entry[1] !== null).map(([label, value]) => `  ${(label + ":").padEnd(width)}${clean(value)}
+`).join("");
+}
+function planStepLine(step) {
+  if (!isRecord2(step)) return null;
+  return `${str4(step["issue"])} (plan ${str4(step["plan_id"])})`;
+}
+function planLine(plan) {
+  if (!isRecord2(plan)) return "none yet";
+  const count = plan["capability_count"];
+  return `version ${str4(plan["version"])} \xB7 instructions v${str4(plan["instruction_version"])} \xB7 ${str4(count)} capabilit${count === 1 ? "y" : "ies"}`;
+}
+function progressLine(progress) {
+  if (!isRecord2(progress)) return null;
+  const parts = [str4(progress["stage"]), str4(progress["situation"])].filter((part) => part !== "");
+  if (progress["needs_viewer"] === true) parts.push("needs you");
+  return parts.length === 0 ? null : parts.join(" \xB7 ");
+}
+function windowLine(window) {
+  if (!isRecord2(window)) return null;
+  const left = duration(window["remaining_ms"]);
+  const budget = duration(window["budget_ms"]);
+  const sequence = window["sequence"];
+  return `${left ?? "?"} left${budget === null ? "" : ` of ${budget}`} \xB7 ${str4(window["state"])}` + (typeof sequence === "number" ? ` (window ${sequence})` : "");
+}
+function spendLine(spend) {
+  if (!isRecord2(spend)) return null;
+  const spent = `${str4(spend["spent_cents"]) || "0"} cents spent`;
+  if (typeof spend["plan_budget_cents"] !== "number") return spent;
+  const remaining = spend["plan_remaining_cents"];
+  return `${spent} \xB7 plan budget ${spend["plan_budget_cents"]} cents` + (typeof remaining === "number" ? `, ${remaining} cents left` : "");
+}
+function effectsLine(effects) {
+  if (!isRecord2(effects)) return null;
+  return ["staged", "succeeded", "failed", "unknown"].map((key) => `${str4(effects[key]) || "0"} ${key}`).join(" \xB7 ");
+}
+function skillLine(skill) {
+  if (!isRecord2(skill)) return null;
+  return `${str4(skill["title"])} (${str4(skill["invocation_name"])}) \xB7 sha256 ${str4(skill["content_sha256"])} \xB7 pinned ${str4(skill["pinned_at"])}`;
+}
+function grantLine(grant, people) {
+  if (!isRecord2(grant)) return null;
+  const approvedAt = str4(grant["approved_at"]);
+  const expiresAt = str4(grant["expires_at"]);
+  return `${str4(grant["status"])} v${str4(grant["version"])} \xB7 approved by ${nameOf(grant["approver_user_id"], people)}` + (approvedAt === "" ? "" : ` at ${approvedAt}`) + ` \xB7 ${expiresAt === "" ? "no expiry" : `expires ${expiresAt}`}`;
+}
+function approvalSection(pending, people) {
+  if (!isRecord2(pending)) return "";
+  const approvers = Array.isArray(pending["approver_user_ids"]) ? pending["approver_user_ids"].map((id) => nameOf(id, people)).join(", ") : "";
+  const canApprove = pending["viewer_can_approve"] === true ? "you can approve" : "you cannot approve it";
+  return "\nWaiting for approval. Approve it in the app; the CLI cannot:\n" + labelled([
+    [
+      "Change set",
+      `${str4(pending["manifest_id"])} v${str4(pending["version"])} \xB7 ${str4(pending["action_count"])} actions \xB7 up to ${str4(pending["max_effect_count"])} effects \xB7 plan version ${str4(pending["plan_version"])}`
+    ],
+    ["Digest", str4(pending["digest"]) || null],
+    ["Approvers", approvers === "" ? canApprove : `${approvers} \xB7 ${canApprove}`],
+    ["Approve at", str4(pending["url"]) || null]
+  ]);
+}
+function peopleSection(people) {
+  if (people.length === 0) return "";
+  const rows = people.map((person) => [
+    str4(person["name"]) || "(no name)",
+    str4(person["role"]),
+    str4(person["user_id"])
+  ]);
+  const lines = table(["", "", ""], rows).split("\n").slice(1, -1);
+  return "\nPeople:\n" + lines.map((line) => `  ${line}
+`).join("");
+}
+function changesText(id, job, changeSet) {
+  if (changeSet === null) return `No pending change set: Operator has proposed nothing for job ${id} yet.
+`;
+  const approvalUrl = str4(job["approval_url"]);
+  const rows = records2(changeSet["actions"]).map((action) => [
+    str4(action["display_order"]) || "-",
+    str4(action["action_type"]),
+    str4(action["action_version"]),
+    str4(action["effect_count"]),
+    (Array.isArray(action["required_capability_ids"]) ? action["required_capability_ids"].map(str4).join(", ") : "") || "-",
+    str4(action["digest"]),
+    str4(action["id"])
+  ]);
+  const actions = rows.length === 0 ? "\nActions: none\n" : "\nActions:\n" + table(["#", "ACTION", "VERSION", "EFFECTS", "CAPABILITIES", "DIGEST", "ID"], rows).split("\n").slice(0, -1).map((line) => `  ${line}
+`).join("");
+  return `Change set of Operator job ${id} \xB7 ${clean(changeSet["status"])}
+` + labelled([
+    [
+      "Change set",
+      `${str4(changeSet["manifest_id"])} v${str4(changeSet["version"])} \xB7 plan version ${str4(changeSet["plan_version"])} \xB7 up to ${str4(changeSet["max_effect_count"])} effects`
+    ],
+    ["Digest", str4(changeSet["digest"]) || null],
+    approvalUrl === "" ? ["Workbench", str4(job["url"]) || null] : ["Approve at", approvalUrl]
+  ]) + actions + "\nValues and targets are not shown: review them in the app at the " + (approvalUrl === "" ? "workbench link.\n" : "approval link. The CLI cannot approve.\n");
+}
+function peopleText(id, people) {
+  const one = (entry) => isRecord2(entry) ? str4(entry["name"]) || str4(entry["user_id"]) : "-";
+  const many = (entries) => (Array.isArray(entries) ? entries.map(one).join(", ") : "") || "none";
+  return `People on Operator job ${id}:
+` + labelled(
+    [
+      ["Requester", one(people["requester"])],
+      ["Execution principal", one(people["execution_principal"])],
+      ["Owner", one(people["owner"])],
+      ["Approvers", many(people["approvers"])],
+      ["Collaborators", many(people["collaborators"])]
+    ],
+    22
+  );
+}
+function listSection(title, items, line) {
+  if (items.length === 0) return "";
+  return `
+${title}:
+` + items.map((item) => `  ${clean(line(item))}
+`).join("");
+}
+function controlsLine(viewerCan) {
+  const controls = isRecord2(viewerCan) ? ["steer", "cancel", "continue", "pause", "save_procedure"].filter((key) => viewerCan[key] === true) : [];
+  return `
+You can, in the workbench: ${controls.length === 0 ? "nothing right now" : controls.join(", ")}
+`;
+}
+function eventLine(event) {
+  const actor = isRecord2(event["actor"]) ? event["actor"] : {};
+  const actorKind = safeValue(actor["kind"]) || "?";
+  const actorId = safeValue(actor["delegated_grant_id"] ?? actor["user_id"]);
+  const data = isRecord2(event["data"]) ? Object.entries(event["data"]).map(([key, value]) => `${clean(key)}=${safeValue(value) || "\u2026"}`) : [];
+  return `#${clean(event["sequence"])}  ${clean(event["occurred_at"])}  ${clean(event["kind"])}  ${actorId === "" ? actorKind : `${actorKind} ${actorId}`}` + (data.length === 0 ? "" : `  ${data.join(" ")}`) + "\n";
+}
+function eventJson(event) {
+  const actor = isRecord2(event["actor"]) ? event["actor"] : {};
+  const data = isRecord2(event["data"]) ? event["data"] : {};
+  return {
+    sequence: typeof event["sequence"] === "number" ? event["sequence"] : null,
+    kind: safeValue(event["kind"]) || null,
+    occurred_at: typeof event["occurred_at"] === "string" && TIMESTAMP.test(event["occurred_at"]) ? event["occurred_at"] : null,
+    actor: Object.fromEntries(
+      ["kind", "user_id", "delegated_grant_id"].filter((key) => key in actor && (actor[key] === null || safeValue(actor[key]) !== "")).map((key) => [key, actor[key]])
+    ),
+    data: Object.fromEntries(Object.entries(data).filter(([key, value]) => CODE.test(key) && safeValue(value) !== ""))
+  };
+}
+function jobStateJson(job) {
+  return Object.fromEntries(
+    ["state", "waiting_on", "updated_at", "url", "approval_url"].filter((key) => key in job).map((key) => [key, job[key]])
+  );
+}
+function stateLine(previous, state, waitingOn) {
+  const now = clean(state) + (waitingOn === null ? "" : `, waiting on ${clean(waitingOn)}`);
+  return previous === null || previous === state ? `state: ${now}
+` : `state: ${clean(previous)} \u2192 ${now}
+`;
+}
+function outcomeText(id, outcome, job) {
+  const url = clean(job["url"]);
+  switch (outcome) {
+    case "completed":
+      return `Job ${id} completed.
+  Workbench: ${url}
+`;
+    case "failed":
+      return `Job ${id} failed.
+  Workbench: ${url}
+`;
+    case "cancelled":
+      return `Job ${id} was cancelled.
+  Workbench: ${url}
+`;
+    case "waiting": {
+      const waitingOn = job["waiting_on"];
+      if (waitingOn === "approval") {
+        const link = clean(job["approval_url"]) || url;
+        return `Job ${id} is waiting for approval. Approve it in the app; the CLI cannot:
+  ${link}
+`;
+      }
+      const what = waitingOn === "person" ? "a person" : clean(waitingOn);
+      return `Job ${id} is waiting on ${what}; a person has to act in the workbench:
+  ${url}
+`;
+    }
+  }
+}
+function withheld(job) {
+  return Object.fromEntries(
+    Object.entries(job).filter(([key]) => !WITHHELD_FIELDS.has(key) && !key.startsWith("knowledge"))
+  );
+}
+function pick(record, keys) {
+  return Object.fromEntries(keys.filter((key) => key in record).map((key) => [key, record[key]]));
+}
+function objects(value, what) {
+  if (!Array.isArray(value) || !value.every(isRecord2)) {
+    throw new CommandError(`The ${what} response data is not a list of objects.`);
+  }
+  return value;
+}
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function uniqueById(jobs) {
+  const seen = /* @__PURE__ */ new Set();
+  return jobs.filter((job) => {
+    const id = str4(job["id"]);
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+function personName(person) {
+  if (!isRecord2(person)) return "-";
+  return str4(person["name"]) || str4(person["user_id"]) || "-";
+}
+function nameOf(userId, people) {
+  const id = str4(userId);
+  const person = people.find((candidate) => candidate["user_id"] === id);
+  return (person === void 0 ? "" : str4(person["name"])) || id || "?";
+}
+function duration(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return null;
+  const seconds = Math.max(0, Math.floor(ms / 1e3));
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const rest = seconds % 60;
+  if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m ${String(rest).padStart(2, "0")}s`;
+  return `${rest}s`;
+}
+function safeValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "string" && CODE.test(value)) return value;
+  return "";
+}
+function field2(record, ...keys) {
+  let current = record;
+  for (const key of keys) {
+    if (!isRecord2(current)) return null;
+    current = current[key];
+  }
+  return current ?? null;
+}
+function records2(value) {
+  return Array.isArray(value) ? value.filter(isRecord2) : [];
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str4(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+
+// src/commands/operator-write.ts
+var ACCESS_HINTS = {
+  ...REFUSAL_HINTS,
+  operator_disabled: "nothing can be changed until Operator is switched back on for this organization",
+  actor_required: "the credential acts as no person: use a browser login, or an API token a person created",
+  forbidden: "the credential lacks the operator:write scope (a browser login carries it; an aone_ token must be created with it, bound to this organization), or you are a guest or outside the organization",
+  run_bound_credential: "a run-bound credential cannot change Operator jobs; use a browser login"
+};
+var BAD_REQUEST_HINT = "nothing changed: the server refused a field this CLI sent, so this CLI and the server disagree about the request \u2014 update the CLI";
+var NEVER_SENT = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EAI_FAIL",
+  "ECONNREFUSED",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "EHOSTDOWN",
+  "EADDRNOTAVAIL",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "CERT_HAS_EXPIRED",
+  "CERT_NOT_YET_VALID",
+  "CERT_REVOKED",
+  "CERT_UNTRUSTED",
+  "CERT_REJECTED",
+  "HOSTNAME_MISMATCH",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "ERR_SSL_WRONG_VERSION_NUMBER"
+]);
+function neverSent(error) {
+  return !(error instanceof MalformedResponseError) && error.code !== null && NEVER_SENT.has(error.code);
+}
+function outcomeUnknown(why, write2) {
+  return new CommandError(
+    `Outcome unknown: ${why}, so ${write2.mayHave}. It is not retried; check ${write2.check} before trying again.`
+  );
+}
+async function sendOnce(ctx, path, body, write2) {
+  try {
+    return await ctx.client.post(path, body, { actor: false });
+  } catch (error) {
+    if (error instanceof TransportError) {
+      if (neverSent(error)) {
+        throw new TransportError(
+          `${error.message} \u2014 the request never reached the server, so nothing changed`,
+          error.code
+        );
+      }
+      throw outcomeUnknown(
+        error instanceof MalformedResponseError ? `the answer could not be read (${error.message})` : `the request failed (${error.message}) after it may have reached the server`,
+        write2
+      );
+    }
+    if (error instanceof HttpError && !(error instanceof UpgradeRequiredError) && error.status >= 500) {
+      throw new HttpError(
+        error.status,
+        `${error.message} \u2014 outcome unknown: ${write2.mayHave}. It is not retried; check ${write2.check} before trying again`,
+        error.body,
+        error.retryAfter
+      );
+    }
+    throw error;
+  }
+}
+function explainRefusal(error, notFound2, hints2) {
+  if (!(error instanceof HttpError) || error instanceof UpgradeRequiredError) return error;
+  const code = typeof error.body["error"] === "string" ? error.body["error"] : "";
+  const own = Object.hasOwn(hints2, code) ? hints2[code] : void 0;
+  let hint;
+  if (error.status >= 500) hint = own;
+  else if (error.status === 404) hint = notFound2;
+  else if (own !== void 0) hint = own;
+  else if (error.status === 403 && Object.hasOwn(ACCESS_HINTS, code)) hint = ACCESS_HINTS[code];
+  else if (error.status === 400 && code === "bad_request") hint = BAD_REQUEST_HINT;
+  if (hint === void 0) return error;
+  const message = error.status < 500 ? error.message : typeof error.body["message"] === "string" ? error.body["message"] : own !== void 0 ? `The server answered ${error.status}` : error.message;
+  return new HttpError(error.status, `${message} \u2014 ${hint}`, error.body, error.retryAfter);
+}
+
+// src/commands/operator-run.ts
+var OUTCOME_MAX_CHARACTERS = 1e4;
+var BUDGET_MAX_DOLLARS = 1e6;
+var SKILL = /^\/?[a-z0-9]+(-[a-z0-9]+)*$/;
+var SKILL_MAX_CHARACTERS = 65;
+var BUDGET = /^\d+(\.\d{1,2})?$/;
+function prepareRun(outcome, opts = {}, surface = CLI_SURFACE) {
+  const trimmed = outcome.trim();
+  if (trimmed === "") throw new UsageError(`the outcome is empty \u2014 say what the job should achieve${surface.outcomeHint}`);
+  const length = graphemeLength(trimmed);
+  if (length > OUTCOME_MAX_CHARACTERS) {
+    throw new UsageError(
+      `the outcome is ${length} characters once trimmed; a job takes at most ${OUTCOME_MAX_CHARACTERS}`
+    );
+  }
+  const body = { outcome: trimmed };
+  if (opts.budget !== void 0) {
+    const budget = opts.budget.trim();
+    const amount = BUDGET.test(budget) ? Number(budget) : NaN;
+    if (!(amount > 0) || amount > BUDGET_MAX_DOLLARS) {
+      throw new UsageError(
+        `${surface.budget} takes a positive amount in US dollars with at most two decimals, up to ${BUDGET_MAX_DOLLARS}`
+      );
+    }
+    body["budget"] = amount;
+  }
+  if (opts.skill !== void 0) {
+    const skill = opts.skill.trim();
+    if (skill.length > SKILL_MAX_CHARACTERS || !SKILL.test(skill)) {
+      throw new UsageError(
+        `${surface.skill} takes a skill's invocation name, like /summarize-lps (${surface.skills} lists them)`
+      );
+    }
+    body["skill"] = skill;
+  }
+  return { body };
+}
+var CLI_SURFACE = {
+  budget: "--budget",
+  skill: "--skill",
+  outcomeHint: ': run "<outcome>"',
+  skills: "`skills`",
+  look: "`jobs --mine` for the new job",
+  again: "run again"
+};
+var MCP_SURFACE = {
+  budget: "budget",
+  skill: "skill",
+  outcomeHint: "",
+  skills: "`skills_list`",
+  look: "`jobs_list` with mine for the new job",
+  again: "call again"
+};
+async function startRun(ctx, request, surface = CLI_SURFACE) {
+  const write2 = { mayHave: "a job may have been started", check: surface.look };
+  let data;
+  try {
+    data = (await sendOnce(ctx, "/api/v1/operator/jobs", request.body, write2)).data;
+  } catch (error) {
+    throw explainRefusal(error, "this Harness server has no Operator API for starting jobs yet", hints(error, surface));
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw outcomeUnknown("the answer named no job", write2);
+  }
+  const record = data;
+  const jobId = record["job_id"];
+  if (typeof jobId !== "string" || jobId === "") throw outcomeUnknown("the answer named no job", write2);
+  const text = (value) => typeof value === "string" ? value : "";
+  return {
+    job_id: jobId,
+    state: text(record["state"]),
+    workbench_url: text(record["workbench_url"]),
+    approval_url: text(record["approval_url"]) === "" ? null : text(record["approval_url"])
+  };
+}
+function hints(error, surface) {
+  const retryAfter = error instanceof HttpError ? error.retryAfter : null;
+  return {
+    budget_not_permitted: `nothing was started: only the organization's admins, who manage its Operator budget, can pass ${surface.budget} \u2014 ${surface.again} without it`,
+    budget_exceeded: `nothing was started: the organization's monthly Operator budget has less than ${surface.budget} left this month \u2014 pass a smaller budget, or ask an admin`,
+    concurrent_change: `nothing was started: Operator or your access changed while the job started \u2014 check that you can still use Operator, then ${surface.again}`,
+    invalid_outcome: `nothing was started: pass the outcome as text of 1 to ${OUTCOME_MAX_CHARACTERS} characters once trimmed, without control characters`,
+    invalid_budget: `nothing was started: ${surface.budget} takes a positive amount in US dollars with at most two decimals, up to ${BUDGET_MAX_DOLLARS}`,
+    unknown_skill: `nothing was started: no Operator skill of that name that you may run in the organization (${surface.skills} lists them)`,
+    rate_limited: "nothing was started: you can start 30 jobs an hour this way" + (retryAfter === null ? "" : `; try again in ${clean(retryAfter)} s`),
+    service_unavailable: "nothing was started; try again later"
+  };
+}
+function startedText(job) {
+  return `Started Operator job ${clean(job.job_id)}.
+` + labelled([
+    ["State", clean(job.state) || null],
+    ["Workbench", clean(job.workbench_url) || null],
+    ["Approve at", job.approval_url === null ? null : clean(job.approval_url)]
+  ]) + (job.approval_url === null ? "" : "\nApproving happens in the app; the CLI cannot approve.\n");
+}
+async function run(ctx, request, opts = {}) {
+  const job = await startRun(ctx, request);
+  if (opts.watch !== true) return { json: job, human: startedText(job) };
+  const json = opts.json === true;
+  if (!json) opts.onLine?.(startedText(job) + "\n");
+  let watched;
+  try {
+    watched = await jobWatch(ctx, job.job_id, {
+      throughWaits: true,
+      collectEvents: json,
+      onLine: json ? void 0 : opts.onLine,
+      signal: opts.signal,
+      sleep: opts.sleep
+    });
+  } catch (error) {
+    const follow = ` \u2014 the job was started: follow it with \`watch ${job.job_id}\``;
+    if (error instanceof HttpError) {
+      throw new HttpError(error.status, `${error.message}${follow}`, error.body, error.retryAfter);
+    }
+    if (error instanceof TransportError) throw new TransportError(`${error.message}${follow}`, error.code);
+    if (error instanceof CommandError) throw new CommandError(`${error.message}${follow}`);
+    throw error;
+  }
+  return { ...watched, json: { ...job, watch: watched.json } };
+}
+
+// src/commands/operator-continue.ts
+async function jobContinue(ctx, id) {
+  requireJobId(id);
+  const write2 = { mayHave: "the job may have been continued", check: `\`job ${id}\`` };
+  let data;
+  try {
+    data = (await sendOnce(ctx, `/api/v1/operator/jobs/${id}/continue`, {}, write2)).data;
+  } catch (error) {
+    throw explainRefusal(error, notFound(id), refusals(id));
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw outcomeUnknown("the answer carried no job", write2);
+  }
+  const job = withheld(data);
+  return { json: job, human: `Continued Operator job ${id}.
+
+` + jobDetail(job) };
+}
+function notFound(id) {
+  return `${missingJob(id)}. If you could see the job until now, it may have gone out of sight just as it was continued: check \`job ${id}\` before continuing it again`;
+}
+function refusals(id) {
+  return {
+    principal_required: "only the person the job runs as (its execution principal) can continue it",
+    invalid_state: `the job has nothing to continue in its current state; \`job ${id}\` shows where it stands`,
+    reconciliation_required: "reconcile its partial effects in the app first, from the job's workbench link",
+    principal_inactive: "the person the job runs as lost the rights to run it, so it can't continue until those are restored",
+    deliveries_unsettled: `a delivery is still sending, or its outcome is unknown: if \`job ${id}\` shows it waiting on delivery, settle it in the app; otherwise continue it once the delivery has sent`
+  };
+}
+
+// src/core/textinput.ts
+import { readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { isatty } from "tty";
+var STDIN_PATH = "-";
+var MAX_TEXT_BYTES = 1e6;
+var TEXT_LIMIT = { bytes: MAX_TEXT_BYTES, why: "that is not prose; check the path" };
+var DOCUMENT_LIMIT = { bytes: 8e6, why: "larger than the API accepts in one request" };
+function flagOf(name) {
+  return name.replace(/[A-Z]/g, (upper) => `-${upper.toLowerCase()}`);
+}
+function resolveTextSources(sources) {
+  const resolved = {};
+  const toRead = [];
+  let stdinClaimedBy;
+  for (const { name, inline, file } of sources) {
+    if (inline !== void 0 && file !== void 0) {
+      throw new UsageError(
+        `--${flagOf(name)} and --${flagOf(name)}-file both given \u2014 pass one; there is no precedence between them`
+      );
+    }
+    if (file === void 0) {
+      if (inline !== void 0) resolved[name] = inline;
+      continue;
+    }
+    if (file === STDIN_PATH) {
+      if (isatty(0)) {
+        throw new UsageError(
+          `--${flagOf(name)}-file - reads stdin, but stdin is a terminal \u2014 pipe something in or pass a path`
+        );
+      }
+      if (stdinClaimedBy !== void 0) {
+        throw new UsageError(
+          `--${flagOf(name)}-file and --${flagOf(stdinClaimedBy)}-file both read stdin \u2014 there is only one stream, so only one may be "-"`
+        );
+      }
+      stdinClaimedBy = name;
+    }
+    if (file !== STDIN_PATH) checkReadable(file, `--${flagOf(name)}-file`);
+    toRead.push({ name, file });
+  }
+  for (const { name, file } of [...toRead].sort(byStdinLast)) {
+    resolved[name] = stripOneTrailingNewline(readTextFile(file, `--${flagOf(name)}-file`));
+  }
+  return resolved;
+}
+function readFileOption(flag, path) {
+  if (path === STDIN_PATH) {
+    if (isatty(0)) {
+      throw new UsageError(`${flag} - reads stdin, but stdin is a terminal \u2014 pipe something in or pass a path`);
+    }
+  } else {
+    checkReadable(path, flag, DOCUMENT_LIMIT);
+  }
+  return readTextFile(path, flag, DOCUMENT_LIMIT);
+}
+function readTextFile(path, option, limit = TEXT_LIMIT) {
+  if (path === STDIN_PATH) {
+    let piped;
+    try {
+      piped = readFileSync2(0);
+    } catch (error) {
+      throw new UsageError(`${option} -: cannot read stdin (${describe(error)})`);
+    }
+    if (piped.length > limit.bytes) {
+      throw new UsageError(oversize(`${option} -`, limit));
+    }
+    return decodeUtf8(piped, `${option} -`);
+  }
+  const flag = `${option} ${path}`;
+  let bytes;
+  try {
+    bytes = readFileSync2(path);
+  } catch (error) {
+    throw new UsageError(`${flag}: ${describe(error)}`);
+  }
+  if (bytes.length > limit.bytes) throw new UsageError(oversize(flag, limit));
+  return decodeUtf8(bytes, flag);
+}
+function decodeUtf8(bytes, flag) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new UsageError(`${flag}: not valid UTF-8 \u2014 convert it first`);
+  }
+}
+function oversize(what, limit) {
+  return `${what}: over ${limit.bytes / 1e6} MB \u2014 ${limit.why}`;
+}
+function checkReadable(path, option, limit = TEXT_LIMIT) {
+  const flag = `${option} ${path}`;
+  let stats3;
+  try {
+    stats3 = statSync3(path);
+  } catch (error) {
+    throw new UsageError(`${flag}: ${describe(error)}`);
+  }
+  if (!stats3.isFile()) {
+    throw new UsageError(
+      `${flag}: ${stats3.isDirectory() ? "is a directory" : "not a regular file"}`
+    );
+  }
+  if (stats3.size > limit.bytes) throw new UsageError(oversize(flag, limit));
+}
+function byStdinLast(a, b) {
+  return Number(a.file === STDIN_PATH) - Number(b.file === STDIN_PATH);
+}
+function stripOneTrailingNewline(text) {
+  if (text.endsWith("\r\n")) return text.slice(0, -2);
+  if (text.endsWith("\n")) return text.slice(0, -1);
+  return text;
+}
+function describe(error) {
+  const code = error?.code;
+  if (code === "ENOENT") return "no such file";
+  if (code === "EISDIR") return "is a directory";
+  if (code === "EACCES") return "permission denied";
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/operator-controls.ts
+var STEER_MAX_CHARACTERS = 1e4;
+var DONE = { steer: "steered", cancel: "cancelled", pause: "paused" };
+function requireInstruction(instruction) {
+  const trimmed = instruction.trim();
+  if (trimmed === "") throw new UsageError("the instruction is empty \u2014 say what the job should change");
+  const length = graphemeLength(trimmed);
+  if (length > STEER_MAX_CHARACTERS) {
+    throw new UsageError(
+      `the instruction is ${length} characters once trimmed; a job takes at most ${STEER_MAX_CHARACTERS}`
+    );
+  }
+  return trimmed;
+}
+function instructionFrom(words, file) {
+  if (file === void 0) return requireInstruction(words.join(" "));
+  if (words.length > 0) {
+    throw new UsageError(
+      "instruction words and --instruction-file both given \u2014 pass one; there is no precedence between them"
+    );
+  }
+  return requireInstruction(resolveTextSources([{ name: "instruction", inline: void 0, file }])["instruction"] ?? "");
+}
+async function jobSteer(ctx, id, instruction) {
+  requireJobId(id);
+  const job = await control(ctx, id, "steer", { instruction: requireInstruction(instruction) });
+  return {
+    json: job,
+    human: `Steered Operator job ${id}: the instruction is posted in its room, attributed to you. Work it changes needs a fresh approval (earlier approvals no longer apply), and a run in progress stops to take it.
+
+` + jobDetail(job)
+  };
+}
+async function jobCancel(ctx, id) {
+  requireJobId(id);
+  const job = await control(ctx, id, "cancel", {});
+  const effects = effectsLine(job["effects"]);
+  return {
+    json: job,
+    human: `Cancelled Operator job ${id}. ` + (effects === null ? "Committed effects stay committed; the answer carried no counts.\n" : `Committed effects stay committed: ${clean(effects)} (staged effects that never ran count as unknown).
+`) + "\n" + jobDetail(job)
+  };
+}
+async function jobPause(ctx, id) {
+  requireJobId(id);
+  const job = await control(ctx, id, "pause", {});
+  return {
+    json: job,
+    human: `Paused Operator job ${id}. Its active-time budget is kept; continue it to run again.
+
+` + jobDetail(job)
+  };
+}
+async function control(ctx, id, verb, body) {
+  const write2 = { mayHave: `the job may have been ${DONE[verb]}`, check: `\`job ${id}\`` };
+  let data;
+  try {
+    data = (await sendOnce(ctx, `/api/v1/operator/jobs/${id}/${verb}`, body, write2)).data;
+  } catch (error) {
+    throw explained2(error, id, verb);
+  }
+  if (!isRecord3(data)) throw outcomeUnknown("the answer carried no job", write2);
+  return withheld(data);
+}
+function explained2(error, id, verb) {
+  if (!(error instanceof HttpError) || error.status >= 500) return error;
+  const hint = refusalHint(error, id, verb);
+  if (hint === void 0) return error;
+  return new HttpError(error.status, `${error.message} \u2014 ${hint}`, error.body, error.retryAfter);
+}
+function refusalHint(error, id, verb) {
+  const code = typeof error.body["error"] === "string" ? error.body["error"] : "";
+  const job = `\`job ${id}\``;
+  switch (error.status) {
+    case 400:
+      return code === "bad_request" ? BAD_REQUEST_HINT : void 0;
+    case 403:
+      if (code !== "principal_required") return ACCESS_HINTS[code];
+      return verb === "pause" ? "only the job's execution principal may pause it; as its owner or a collaborator you can steer it instead, which stops its current run" : `only the job's execution principal may ${verb} it; ask them to`;
+    case 404:
+      return missingJob(id);
+    case 409:
+      return conflictHint(code, verb, job);
+    case 422:
+      if (code === "invalid_instruction") {
+        return `pass the instruction as text of 1 to ${STEER_MAX_CHARACTERS} characters once trimmed`;
+      }
+      return code === "validation_error" && verb === "steer" ? "the job's room refused the instruction, so nothing was posted" : void 0;
+    default:
+      return void 0;
+  }
+}
+function conflictHint(code, verb, job) {
+  switch (code) {
+    case "invalid_state":
+      return {
+        steer: `the app doesn't offer Steer for the job now: it has finished, failed, waits for approval or needs reconciliation \u2014 ${job} shows where it stands`,
+        cancel: `the job has already ended \u2014 ${job} shows how`,
+        pause: `only a running job can be paused \u2014 ${job} shows where it stands`
+      }[verb];
+    case "reconciliation_required":
+      return `its partial effects need reconciling first: reconcile them in the app (${job} has the workbench link)`;
+    case "deliveries_unsettled":
+      return `a delivery is still sending, or its outcome is unknown: if ${job} shows it waiting on delivery, settle that in the app (the workbench link is there); otherwise ${verb} it again once the delivery has sent`;
+    case "principal_inactive":
+      return "nothing changed: the job's execution principal needs their admin or member role back first";
+    case "cancellation_scope_changed":
+      return `the job was not cancelled; read it with ${job} and decide again`;
+    default:
+      return void 0;
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/commands/operator-procedures.ts
+var PROCEDURE_FIELDS = [
+  "id",
+  "name",
+  "job_id",
+  "job_url",
+  "current_version",
+  "parameter_schema",
+  "versions",
+  "inserted_at",
+  "updated_at"
+];
+var PROCEDURE_VERSION_FIELDS = [
+  "version",
+  "recipe_digest",
+  "capability_ids",
+  "action_roster",
+  "inserted_at"
+];
+var RUN_NOTE = "A run is a new job: fresh inputs, your current rights and a change set that needs its own approval. Nothing of the saved job carries over. Approving happens in the app; the CLI cannot approve.\n";
+function requireProcedureId(id) {
+  if (!isUuid(id)) throw new UsageError(`not an Operator procedure id: ${id} (expected the procedure's UUID)`);
+}
+function missingProcedure(id) {
+  return `no Operator procedure ${id} you can see: it does not exist or was deleted, is in another organization, was saved from a job you can't see, or was saved for the whole organization rather than a job (or this Harness server has no procedures API yet)`;
+}
+function requireProcedureName(name) {
+  if (name === void 0 || name.trim() === "") {
+    throw new UsageError('a procedure needs a name: procedure save <job-id> --name "\u2026"');
+  }
+  return name;
+}
+async function procedureSave(ctx, jobId, name) {
+  requireJobId(jobId);
+  const named2 = requireProcedureName(name);
+  const write2 = {
+    mayHave: "a procedure may have been saved",
+    check: `the job's procedures with \`job ${jobId}\``
+  };
+  let data;
+  try {
+    data = (await sendOnce(ctx, `/api/v1/operator/jobs/${jobId}/procedures`, { name: named2 }, write2)).data;
+  } catch (error) {
+    throw explainRefusal(error, missingJob(jobId), {
+      owner_required: "only the job's owner can save it as a procedure; ask them to save it",
+      not_saveable: "only a job that completed with its work verified, and has work to repeat, can be saved",
+      validation_error: "the name must be plain text, without control characters"
+    });
+  }
+  if (!isRecord4(data) || typeof data["id"] !== "string" || data["id"] === "") {
+    throw outcomeUnknown("the answer named no procedure", write2);
+  }
+  const saved = `Saved job ${jobId} as procedure ${clean(data["id"])}`;
+  if (!Array.isArray(data["versions"])) {
+    return {
+      json: pick2(data, ["id", "url"]),
+      human: `${saved}, but it can't be read back as you.
+` + labelled([["Workbench", str5(data["url"]) || null]])
+    };
+  }
+  const procedure = procedureJson(data);
+  return { json: procedure, human: `${saved}.
+
+` + procedureDetail(procedure) };
+}
+async function procedureShow(ctx, id) {
+  requireProcedureId(id);
+  const body = await explained(() => ctx.client.get(`/api/v1/operator/procedures/${id}`), {
+    notFound: missingProcedure(id)
+  });
+  if (!isRecord4(body.data)) throw new CommandError("The procedure response carried no procedure.");
+  const procedure = procedureJson(body.data);
+  return { json: procedure, human: procedureDetail(procedure) };
+}
+function prepareProcedureRun(id, opts) {
+  requireProcedureId(id);
+  const body = {};
+  const version2 = runVersion(opts.version);
+  if (version2 !== void 0) body["version"] = version2;
+  const given = [
+    opts.param !== void 0 && opts.param.length > 0 ? "--param" : null,
+    opts.paramsFile !== void 0 ? "--params-file" : null,
+    opts.parameters !== void 0 ? "parameters" : null
+  ].filter((source) => source !== null);
+  if (given.length > 1) {
+    throw new UsageError(`${given.join(" and ")} both given \u2014 pass the parameters one way; there is no precedence`);
+  }
+  if (opts.parameters !== void 0 && !isRecord4(opts.parameters)) {
+    throw new UsageError("parameters must be one object of names and values");
+  }
+  const fromFlags = opts.param !== void 0 && opts.param.length > 0 ? parseParams(opts.param) : void 0;
+  if (opts.group !== void 0) body["group_id"] = bareId(opts.group, "--group");
+  if (opts.source !== void 0) body["source_resource_id"] = bareId(opts.source, "--source");
+  const parameters = fromFlags ?? opts.parameters ?? (opts.paramsFile === void 0 ? void 0 : readParamsFile(opts.paramsFile));
+  if (parameters !== void 0) body["parameters"] = parameters;
+  return { id, body };
+}
+async function startProcedureRun(ctx, request) {
+  const { id } = request;
+  const write2 = { mayHave: "a job may have been started", check: "`jobs` for the new job" };
+  let data;
+  try {
+    data = (await sendOnce(ctx, `/api/v1/operator/procedures/${id}/runs`, request.body, write2)).data;
+  } catch (error) {
+    throw explainRefusal(error, missingProcedure(id), {
+      version_conflict: `the procedure has a newer current version (\`procedure show ${id}\` names it): run that one, or run without a version to take the current one`,
+      concurrent_change: `read the procedure again (\`procedure show ${id}\`) before running it again`,
+      invalid_rerun: `check the parameters against the procedure's parameter schema (\`procedure show ${id}\`), and that your current rights cover the run`,
+      // The server refuses with it before the run starts.
+      service_unavailable: "nothing was started; try again later"
+    });
+  }
+  if (!isRecord4(data) || typeof data["id"] !== "string" || data["id"] === "") {
+    throw outcomeUnknown("the answer named no job", write2);
+  }
+  const started = `Started Operator job ${clean(data["id"])} from procedure ${id}`;
+  if (typeof data["state"] !== "string") {
+    return {
+      json: pick2(data, ["id", "url"]),
+      human: `${started}, but it can't be read back as you.
+` + labelled([["Workbench", str5(data["url"]) || null]]) + "\n" + RUN_NOTE
+    };
+  }
+  const job = withheld(data);
+  const waitingOn = str5(job["waiting_on"]);
+  return {
+    json: job,
+    human: `${started}.
+` + labelled([
+      ["State", str5(job["state"]) + (waitingOn === "" ? "" : ` \xB7 waiting on ${waitingOn}`)],
+      ["Workbench", str5(job["url"]) || null],
+      ["Approve at", str5(job["approval_url"]) || null]
+    ]) + "\n" + RUN_NOTE
+  };
+}
+async function procedureRun(ctx, id, opts) {
+  return startProcedureRun(ctx, prepareProcedureRun(id, opts));
+}
+function runVersion(version2) {
+  if (version2 === void 0) return void 0;
+  const text = String(version2).trim();
+  const parsed = typeof version2 === "number" ? version2 : /^\d+$/.test(text) ? Number(text) : Number.NaN;
+  if (!Number.isSafeInteger(parsed) || parsed < 1) {
+    throw new UsageError(`--version takes a positive integer, the version expected to be current (got ${text})`);
+  }
+  return parsed;
+}
+function parseParams(entries) {
+  const parsed = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const equals = entry.indexOf("=");
+    if (equals === -1) throw new UsageError(`--param ${entry}: expected name=value, or name:=<json> for a JSON value`);
+    const typed = equals > 0 && entry[equals - 1] === ":";
+    const name = entry.slice(0, typed ? equals - 1 : equals);
+    const raw = entry.slice(equals + 1);
+    if (name.trim() === "") throw new UsageError(`--param ${entry}: the parameter has no name`);
+    if (name !== name.trim()) {
+      throw new UsageError(`--param ${entry}: the name starts or ends with whitespace \u2014 write it without`);
+    }
+    if (names.has(name)) throw new UsageError(`--param ${name} given twice \u2014 pass each parameter once`);
+    names.add(name);
+    parsed.push([name, typed ? jsonValue(raw, `--param ${entry}`) : raw]);
+  }
+  return Object.fromEntries(parsed);
+}
+function jsonValue(text, what) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new UsageError(`${what}: not valid JSON after := (${firstLine(error)}); quote a string as name=value`);
+  }
+}
+function readParamsFile(path) {
+  const text = readFileOption("--params-file", path);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new UsageError(`--params-file ${path}: not valid JSON (${firstLine(error)})`);
+  }
+  if (!isRecord4(parsed)) {
+    throw new UsageError(`--params-file ${path}: the parameters are one JSON object of names and values`);
+  }
+  return parsed;
+}
+function bareId(value, flag) {
+  if (value.trim() === "") throw new UsageError(`${flag} is empty`);
+  if (value !== value.trim()) throw new UsageError(`${flag} starts or ends with whitespace \u2014 pass the id alone`);
+  return value;
+}
+function procedureJson(data) {
+  const procedure = pick2(data, PROCEDURE_FIELDS);
+  if ("versions" in procedure) {
+    procedure["versions"] = records3(procedure["versions"]).map((version2) => pick2(version2, PROCEDURE_VERSION_FIELDS));
+  }
+  return procedure;
+}
+function procedureDetail(procedure) {
+  const current = procedure["current_version"];
+  const versions = records3(procedure["versions"]).map(
+    (version2) => `  ${clean(`v${str5(version2["version"])}${version2["version"] === current ? " (current)" : ""}  ${str5(version2["inserted_at"])}  recipe ${str5(version2["recipe_digest"])}`)}
+      ${"Capabilities:".padEnd(15)}${clean(list2(version2["capability_ids"]))}
+      ${"Actions:".padEnd(15)}${clean(list2(version2["action_roster"]))}
+`
+  );
+  return `Procedure ${clean(procedure["name"])} \xB7 v${clean(current)} \xB7 ${clean(procedure["id"])}
+` + labelled([
+    ["Saved from", `job ${str5(procedure["job_id"])}`],
+    ["Workbench", str5(procedure["job_url"]) || null],
+    ["Created", str5(procedure["inserted_at"]) || null],
+    ["Updated", str5(procedure["updated_at"]) || null]
+  ]) + (versions.length === 0 ? "\nVersions: none\n" : "\nVersions:\n" + versions.join("")) + parametersSection(procedure["parameter_schema"]) + "\n" + RUN_NOTE;
+}
+function parametersSection(schema) {
+  if (!isRecord4(schema) || Object.keys(schema).length === 0) return "\nParameters a run takes: none\n";
+  const lines = JSON.stringify(schema, null, 2).split("\n").map((line) => `  ${clean(line)}
+`).join("");
+  const scoped = isRecord4(schema["scoped_inputs"]) ? schema["scoped_inputs"]["required"] : void 0;
+  const scopes = Array.isArray(scoped) ? scoped.map(str5) : [];
+  let needs = "";
+  if (scopes.includes("contact_reconciliation")) {
+    needs = "Its runs also need --group <contact-group-id> and --source <uploaded-file-id> (contact_reconciliation).\n";
+  } else if (scopes.length > 0) {
+    needs = `Its runs also need inputs resolved afresh: ${clean(scopes.join(", "))}.
+`;
+  }
+  return "\nParameters a run takes (JSON schema):\n" + lines + needs;
+}
+function list2(value) {
+  return (Array.isArray(value) ? value.map(str5).join(", ") : "") || "none";
+}
+function pick2(record, keys) {
+  return Object.fromEntries(keys.filter((key) => key in record).map((key) => [key, record[key]]));
+}
+function records3(value) {
+  return Array.isArray(value) ? value.filter(isRecord4) : [];
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str5(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function firstLine(error) {
+  return (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
+}
+
+// src/commands/plans.ts
+import { extname as extname2 } from "path";
+import { parseDocument } from "yaml";
+var PLAN_EXECUTORS = ["none", "operator"];
+var CONDITION_KINDS = ["not_before", "gate", "event"];
+var GATE_OWNER_ROLES = ["gp", "compliance_officer", "valuer", "accountant", "auditor", "counsel"];
+var PLAN_STATUSES = ["held", "released", "running", "completed", "needs_attention"];
+var PLAN_LIST_MAX_LIMIT = 100;
+var PLAN_LIST_DEFAULT_LIMIT = 50;
+function parsePlanDocument(text, source) {
+  const parsed = extname2(source).toLowerCase() === ".json" ? parseJson(text, source) : parseYamlDocument(text, source);
+  if (!isRecord5(parsed)) {
+    throw new UsageError(`${source}: a plan file holds one object (a mapping), not a list or a scalar`);
+  }
+  return parsed;
+}
+function parseJson(text, source) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new UsageError(`${source}: not valid JSON (${firstLine2(error)})`);
+  }
+}
+function parseYamlDocument(text, source) {
+  const document = parseDocument(text, { resolveKnownTags: false });
+  const problem = document.errors[0] ?? document.warnings[0];
+  if (problem !== void 0) throw new UsageError(`${source}: not valid YAML (${firstLine2(problem)})`);
+  let value;
+  try {
+    value = document.toJS();
+  } catch (error) {
+    throw new UsageError(`${source}: not valid YAML (${firstLine2(error)})`);
+  }
+  if (!jsonSafe(value)) {
+    throw new UsageError(`${source}: holds a value JSON cannot carry (.inf or .nan) \u2014 write a number or a string`);
+  }
+  return value;
+}
+function jsonSafe(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(jsonSafe);
+  if (typeof value === "object" && value !== null) return Object.values(value).every(jsonSafe);
+  return true;
+}
+function firstLine2(error) {
+  return (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
+}
+function readPlanFile(path, flag = "--file") {
+  return parsePlanDocument(readFileOption(flag, path), path);
+}
+async function planCreate(ctx, plan, opts) {
+  requireDocument(plan, "a plan is one object: the root's fields and its steps");
+  const team = requiredTeam(ctx, opts.team);
+  validateIdempotencyKey(opts.idempotencyKey);
+  let body;
+  try {
+    body = await ctx.client.post(`/api/v1/teams/${team}/plans`, plan, { idempotencyKey: opts.idempotencyKey });
+  } catch (error) {
+    throw explainMissing(error, `no team ${team} here, or this Harness server has no plan API yet`);
+  }
+  const created = body.data;
+  const id = str6(created["id"]);
+  return {
+    json: created,
+    human: `Created plan ${clean(id)} (${clean(created["status"]) || "held"})
+
+` + planDetail(created) + `
+Nothing runs until it is released: ${invokedName()} plan release ${clean(id)}
+`
+  };
+}
+function requirePlanListArgs(opts) {
+  if (opts.status !== void 0 && !PLAN_STATUSES.includes(opts.status)) {
+    throw new UsageError(`status must be one of: ${PLAN_STATUSES.join(", ")}`);
+  }
+  if (opts.limit !== void 0 && (!Number.isInteger(opts.limit) || opts.limit < 1 || opts.limit > PLAN_LIST_MAX_LIMIT)) {
+    throw new UsageError(`--limit takes 1 to ${PLAN_LIST_MAX_LIMIT}: the server returns at most ${PLAN_LIST_MAX_LIMIT} plans`);
+  }
+}
+async function planList(ctx, opts) {
+  requirePlanListArgs(opts);
+  const team = requiredTeam(ctx, opts.team);
+  let body;
+  try {
+    body = await ctx.client.get(`/api/v1/teams/${team}/plans`, { status: opts.status, limit: opts.limit });
+  } catch (error) {
+    throw explainMissing(error, `no team ${team} here, or this Harness server cannot list plans yet`);
+  }
+  if (!Array.isArray(body.data)) throw new CommandError("The plan list response carried no list.");
+  const list3 = body.data.filter(isRecord5);
+  const limit = opts.limit ?? PLAN_LIST_DEFAULT_LIMIT;
+  let notice;
+  if (list3.length >= limit) {
+    notice = limit < PLAN_LIST_MAX_LIMIT ? `harness: showing the newest ${list3.length} plans \u2014 pass --limit (up to ${PLAN_LIST_MAX_LIMIT}) for older ones.
+` : `harness: showing the newest ${list3.length} plans, the most one list returns \u2014 narrow it with --status.
+`;
+  }
+  const what = opts.status === void 0 ? "plans" : `${opts.status} plans`;
+  const human = list3.length === 0 ? `No ${what} in team ${team}.
+` : plansTable(list3);
+  return notice === void 0 ? { json: body.data, human } : { json: body.data, human, notice };
+}
+async function planShow(ctx, id) {
+  requirePlanRef(id);
+  const plan = await planRequest(id, () => ctx.client.get(`/api/v1/plans/${id}`));
+  return { json: plan, human: planDetail(plan) };
+}
+async function planEdit(ctx, id, edits) {
+  requirePlanRef(id);
+  requireDocument(edits, "a plan edit is one object: steps to change and budgets");
+  const plan = await planRequest(id, () => ctx.client.patch(`/api/v1/plans/${id}`, edits));
+  const held = Array.isArray(plan["held_steps"]) && plan["held_steps"].length > 0;
+  return {
+    json: plan,
+    human: `Updated plan ${clean(id)}
+
+` + planDetail(plan) + (held ? `
+Only Operator steps are held until the next release; release the plan again to take in the changes: ${invokedName()} plan release ${clean(id)}
+` : "")
+  };
+}
+async function planRelease(ctx, id, opts) {
+  requirePlanRef(id);
+  const body = {};
+  if (opts.collaborators !== void 0 && opts.collaborators.length > 0) body["collaborators"] = opts.collaborators;
+  if (opts.retryBudget !== void 0) body["retry_budget"] = opts.retryBudget;
+  if (opts.spendBudgetCents !== void 0) body["spend_budget_cents"] = opts.spendBudgetCents;
+  const plan = await planRequest(id, () => ctx.client.post(`/api/v1/plans/${id}/release`, body));
+  const revision = plan["revision"] ?? {};
+  const ready2 = Array.isArray(plan["steps"]) ? plan["steps"].filter((step) => isRecord5(step) && step["ready"] === true).length : 0;
+  return {
+    json: plan,
+    human: `Released plan ${clean(id)} as revision ${clean(revision["number"]) || "?"}: ${ready2} ${ready2 === 1 ? "step" : "steps"} ready now
+`
+  };
+}
+async function planHold(ctx, id) {
+  requirePlanRef(id);
+  const plan = await planRequest(id, () => ctx.client.post(`/api/v1/plans/${id}/hold`));
+  return {
+    json: plan,
+    human: `Held plan ${clean(id)}: none of its steps is ready until it is released again
+`
+  };
+}
+async function gateSet(ctx, issue, gate, satisfied) {
+  requireIdentifiers([issue]);
+  const wanted = gate.trim();
+  if (wanted === "") throw new UsageError("name the gate by its key, its label or its condition id");
+  const expert = isExpertToken(ctx.config.token);
+  let list3 = null;
+  if (!isUuid(wanted)) {
+    try {
+      list3 = await readConditions(ctx, issue, expert);
+    } catch (error) {
+      if (error instanceof HttpError && error.status === 403) {
+        throw new HttpError(
+          error.status,
+          `${error.message} \u2014 find the gate by its condition id; only Harness staff can list an issue's conditions`,
+          error.body,
+          error.retryAfter
+        );
+      }
+      throw error;
+    }
+  }
+  const target = list3 === null ? { id: wanted.toLowerCase(), label: wanted.toLowerCase() } : findGate(list3, issue, wanted, expert);
+  const id = str6(target["id"]);
+  let body;
+  try {
+    body = await ctx.client.put(`/api/v1/issues/${issue}/conditions/${id}/satisfaction`, { satisfied });
+  } catch (error) {
+    throw await explainNotGateOwner(ctx, error, target, issue, satisfied, list3 !== null);
+  }
+  const others = list3?.filter((condition) => condition["id"] !== id && condition["satisfied"] !== true).length ?? 0;
+  let tail = "";
+  if (satisfied && list3 !== null && expert) {
+    tail = others > 0 ? ` \u2014 ${others} other gate${others === 1 ? "" : "s"} of yours on it ${others === 1 ? "is" : "are"} open` : "";
+  } else if (satisfied && list3 !== null) {
+    tail = others > 0 ? ` \u2014 it still waits on ${others} other condition${others === 1 ? "" : "s"}` : " \u2014 no other wait condition holds it";
+  }
+  const label = list3 === null && isRecord5(body.data) ? body.data["label"] ?? id : target["label"];
+  return {
+    json: body.data,
+    human: `${satisfied ? "Satisfied" : "Un-satisfied"} gate "${clean(label)}" on ${issue}${tail}
+`
+  };
+}
+async function conditionList(ctx, issue) {
+  requireIdentifiers([issue]);
+  const expert = isExpertToken(ctx.config.token);
+  const list3 = await readConditions(ctx, issue, expert);
+  let human;
+  if (list3.length === 0) {
+    human = expert ? `You own no gate on ${issue}.
+` : `No wait conditions on ${issue}.
+`;
+  } else {
+    human = (expert ? `Your gates on ${issue}:
+` : `Wait conditions on ${issue}:
+`) + list3.map((condition) => `  ${conditionLine(condition, { expertView: expert })}
+`).join("");
+  }
+  return { json: list3, human };
+}
+async function readConditions(ctx, issue, expert) {
+  let conditions;
+  try {
+    conditions = (await ctx.client.get(`/api/v1/issues/${issue}/conditions`)).data;
+  } catch (error) {
+    throw explainMissing(
+      error,
+      expert ? `no step ${issue} assigned to you: a pxc_ credential reads only its own steps` : `no issue ${issue} here, or this Harness server has no wait conditions yet`
+    );
+  }
+  if (!Array.isArray(conditions)) throw new CommandError("The conditions response carried no list.");
+  return conditions.filter(isRecord5);
+}
+function requirePlanRef(id) {
+  if (!isUuid(id) && !isIdentifier(id)) {
+    throw new UsageError(`not a plan: ${id} (expected the plan's id or its root issue's identifier, e.g. FR-1)`);
+  }
+}
+function requireDocument(value, what) {
+  if (!isRecord5(value)) throw new UsageError(what);
+}
+async function planRequest(id, send) {
+  try {
+    return (await send()).data;
+  } catch (error) {
+    throw explainMissing(
+      error,
+      isUuid(id) ? `no plan ${id} in this organization, or this Harness server has no plan API yet` : `${id} roots no plan in this organization (${invokedName()} show ${id} names the plan an issue belongs to, by its root), or this Harness server opens plans by their id only`
+    );
+  }
+}
+function explainMissing(error, why) {
+  if (!(error instanceof HttpError) || error.status !== 404) return error;
+  return new HttpError(404, `${error.message} \u2014 ${why}`, error.body, error.retryAfter);
+}
+async function explainNotGateOwner(ctx, error, gate, issue, satisfied, allowLookup) {
+  if (!(error instanceof HttpError) || error.status !== 403 || error.body["reason"] !== "not_gate_owner") return error;
+  let current;
+  let currentOwner = error.body["owner"];
+  if (allowLookup && currentOwner !== null && !isRecord5(currentOwner)) {
+    try {
+      const fresh = (await ctx.client.get(`/api/v1/issues/${issue}/conditions`)).data;
+      if (Array.isArray(fresh)) current = fresh.filter(isRecord5).find((condition) => condition["id"] === gate["id"]);
+    } catch {
+    }
+    currentOwner = current?.["owner"];
+  }
+  const owner = isRecord5(currentOwner) ? ownerText(currentOwner) : "";
+  const subject = `its owner${owner === "" ? "" : `, ${owner},`}`;
+  const named2 = `gate "${clean((current ?? gate)["label"])}" on ${issue}`;
+  const message = satisfied ? `Cannot satisfy ${named2}: only ${subject} can tick it` : `Cannot un-satisfy ${named2}: only ${subject} or Harness staff can untick it`;
+  return new HttpError(error.status, message, error.body, error.retryAfter);
+}
+var gateLabel = (condition) => str6(condition["label"]).trim();
+var gateKey = (condition) => str6(condition["key"]);
+function exactMatches(conditions, wanted) {
+  return conditions.filter(
+    (condition) => condition["kind"] === "gate" && (gateKey(condition) !== "" && gateKey(condition) === wanted || gateLabel(condition) === wanted)
+  );
+}
+function ambiguous(conditions, issue, wanted, matches) {
+  const listed = matches.map((condition) => {
+    const what = condition["kind"] === "gate" ? `gate ${gateName({ label: gateLabel(condition), key: gateKey(condition) })}` : `${clean(condition["kind"])} condition`;
+    return `${clean(condition["id"])} (${what})`;
+  }).join(", ");
+  return new CommandError(
+    `several gates on ${issue} match "${wanted}": ${listed} \u2014 pass the condition id of the one you mean`
+  );
+}
+function findGate(conditions, issue, wanted, expert = false) {
+  const exact = exactMatches(conditions, wanted);
+  if (exact.length > 1) throw ambiguous(conditions, issue, wanted, exact);
+  if (exact.length === 1) {
+    const only = exact[0];
+    return only;
+  }
+  const gates = conditions.filter((condition) => condition["kind"] === "gate");
+  const folded = wanted.toLowerCase();
+  const loose = gates.filter(
+    (condition) => gateLabel(condition).toLowerCase() === folded || gateKey(condition) !== "" && gateKey(condition) === folded
+  );
+  if (loose.length > 1) throw ambiguous(conditions, issue, wanted, loose);
+  if (loose.length === 1) return loose[0];
+  const none = expert ? `No gate of yours on ${issue}` : `No gate on ${issue}`;
+  if (gates.length === 0) {
+    throw new CommandError(`${none} matches "${wanted}" \u2014 ${expert ? "you own no gate on it" : "it has no gates"}`);
+  }
+  const names = gates.map((condition) => gateName({ label: gateLabel(condition), key: gateKey(condition) })).join(", ");
+  throw new CommandError(`${none} matches "${wanted}". ${expert ? "Your" : "Its"} gates: ${names}`);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str6(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+
+// src/commands/expert.ts
+async function assignments(ctx) {
+  const data = (await ctx.client.get(EXPERT_ASSIGNMENTS_PATH)).data;
+  if (!isRecord6(data) || !Array.isArray(data["assignments"])) {
+    throw new CommandError("The assignments response carried no list.");
+  }
+  const steps = data["assignments"].filter(isRecord6);
+  const expert = isRecord6(data["expert"]) ? data["expert"] : {};
+  const plan = isRecord6(data["plan"]) ? { id: data["plan"]["id"], status: data["plan"]["status"] } : null;
+  const header = expertSummary({ role: expert["role"], plan, assigned_steps: steps.length });
+  return { json: data, human: `${header}
+${expertAssignments(steps)}` };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  MAX_IDEMPOTENCY_KEY_BYTES,
+  IDEMPOTENCY_KEY_FORMAT,
+  requireIdentifiers,
+  ready,
+  requireReadyClaimArgs,
+  blocked,
+  list,
+  search,
+  show,
+  ACTIVITY_MAX_LIMIT,
+  activity,
+  stats2 as stats,
+  prime,
+  version,
+  create,
+  validateIdempotencyKey,
+  update,
+  requireCloseArgs,
+  close,
+  archive,
+  comments,
+  dep,
+  RELATION_CREATE_TYPES,
+  RELATION_UPDATE_TYPES,
+  relationList,
+  relationAdd,
+  relationUpdate,
+  relationRm,
+  comment,
+  editComment,
+  deleteComment,
+  requireCommentId,
+  attachImage,
+  requiredTeam,
+  projectList,
+  projectShow,
+  projectCreate,
+  projectUpdate,
+  milestoneList,
+  milestoneCreate,
+  docList,
+  docShow,
+  docCreate,
+  docUpdate,
+  linkList,
+  linkAdd,
+  linkUpdate,
+  linkRm,
+  labelList,
+  labelCreate,
+  teamCreate,
+  teamList,
+  workflowStates,
+  userList,
+  teamRename,
+  teamSetDefault,
+  stateAdd,
+  stateUpdate,
+  stateOrder,
+  stateDelete,
+  labelUpdate,
+  labelDelete,
+  memberList,
+  memberAdd,
+  memberSetRole,
+  upload,
+  toolsList,
+  toolsSearch,
+  toolsDomains,
+  toolShow,
+  skillsList,
+  requireCapabilityId,
+  requireSearchQuery,
+  requireToolsOpts,
+  requireSchemaView,
+  JOB_STATES,
+  JOB_STATUS_ALIASES,
+  JOBS_MAX_LIMIT,
+  JOBS_MAX_PAGES,
+  EXIT_WAITING_FOR_PERSON,
+  EXIT_JOB_ENDED,
+  EXIT_INTERRUPTED,
+  requireJobsArgs,
+  jobsList,
+  requireJobId,
+  jobShow,
+  jobWatch,
+  watchStopSignal,
+  OUTCOME_MAX_CHARACTERS,
+  BUDGET_MAX_DOLLARS,
+  prepareRun,
+  MCP_SURFACE,
+  startRun,
+  run,
+  jobContinue,
+  resolveTextSources,
+  STEER_MAX_CHARACTERS,
+  instructionFrom,
+  jobSteer,
+  jobCancel,
+  jobPause,
+  requireProcedureId,
+  requireProcedureName,
+  procedureSave,
+  procedureShow,
+  prepareProcedureRun,
+  startProcedureRun,
+  procedureRun,
+  PLAN_EXECUTORS,
+  CONDITION_KINDS,
+  GATE_OWNER_ROLES,
+  PLAN_STATUSES,
+  PLAN_LIST_MAX_LIMIT,
+  readPlanFile,
+  planCreate,
+  requirePlanListArgs,
+  planList,
+  planShow,
+  planEdit,
+  planRelease,
+  planHold,
+  gateSet,
+  conditionList,
+  requirePlanRef,
+  assignments
+};