@allocator-one/harness-cli 1.15.1 → 1.17.0

package/dist/{chunk-L2OWOZ4N.js → chunk-CEEQW6ZV.js}

@@ -1,989 +1,40 @@
 #!/usr/bin/env node
 import {
-  CLI_PACKAGE,
+  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-FQWV5MIC.js";
-
-// src/core/errors.ts
-var HttpError = class extends Error {
-  constructor(status, message, body = {}, retryAfter = null) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.retryAfter = retryAfter;
-    this.name = "HttpError";
-  }
-  status;
-  body;
-  retryAfter;
-};
-var UpgradeRequiredError = class extends HttpError {
-  constructor(message, body = {}) {
-    super(426, message, body);
-    this.name = "UpgradeRequiredError";
-  }
-};
-var TransportError = class extends Error {
-  constructor(message, code = null) {
-    super(message);
-    this.code = code;
-    this.name = "TransportError";
-  }
-  code;
-};
-var MalformedResponseError = class extends TransportError {
-  constructor(message) {
-    super(message);
-    this.name = "MalformedResponseError";
-  }
-};
-var UsageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UsageError";
-  }
-};
-var LocalError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "LocalError";
-  }
-};
-var CommandError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CommandError";
-  }
-};
-
-// src/core/expert.ts
-var EXPERT_TOKEN_PREFIX = "pxc_";
-var EXPERT_ASSIGNMENTS_PATH = "/api/v1/expert/assignments";
-function isExpertToken(token) {
-  return token.startsWith(EXPERT_TOKEN_PREFIX);
-}
-var EXPERT_REACH = "an outside expert's pxc_ credential only lists its own assignments and reads and ticks the gates it owns on them: assignments, conditions <issue> and gate satisfy|unsatisfy (assignment_list, condition_list and gate_set over MCP)";
-var EXPERT_LAPSED = "the pxc_ credential is not valid here: it has expired (it lasts at most 30 days) or was revoked, its seat was revoked or has ended, the account is suspended, its TOTP enrolment changed, or it was minted for another host. If your seat is still open, mint a new one in your expert view";
-var NOT_AN_EXPERT = "this credential is a member's login or an API token, not an outside expert's pxc_ credential";
-function explainExpertRefusal(error, token) {
-  if (!(error instanceof HttpError) || error instanceof UpgradeRequiredError) return error;
-  const code = error.body["error"];
-  let hint;
-  if (error.status === 403 && code === "expert_bound_credential") hint = EXPERT_REACH;
-  else if (error.status === 403 && code === "expert_credential_required") hint = NOT_AN_EXPERT;
-  else if (error.status === 401 && isExpertToken(token)) hint = EXPERT_LAPSED;
-  if (hint === void 0) return error;
-  return new HttpError(error.status, `${error.message} \u2014 ${hint}`, error.body, error.retryAfter);
-}
-
-// src/core/client.ts
-var RECEIVE_TIMEOUT_MS = 3e4;
-var UPLOAD_RECEIVE_TIMEOUT_MS = 6e4;
-var UPLOAD_FLOOR_BYTES_PER_MS = 100;
-function uploadTimeoutMs(bodyBytes) {
-  return UPLOAD_RECEIVE_TIMEOUT_MS + Math.ceil(bodyBytes / UPLOAD_FLOOR_BYTES_PER_MS);
-}
-var DEFAULT_MESSAGES = {
-  401: "Missing or invalid token (check HARNESS_API_TOKEN)",
-  403: "Token not permitted (scope or admin gate)",
-  404: "Not found",
-  409: "Conflict",
-  422: "Validation error",
-  426: `CLI too old for this API \u2014 upgrade: npm i -g ${CLI_PACKAGE}@latest`,
-  429: "Rate limited \u2014 retry later"
-};
-var API_VERSION_HEADER = "x-harness-api-version";
-var STATS_PATH = "/api/v1/stats";
-var SESSION_PATH = "/api/v1/session";
-function isLoginCredential(token) {
-  return !token.startsWith("aone_") && !isExpertToken(token);
-}
-var Client = class {
-  constructor(config) {
-    this.config = config;
-    this.fetchImpl = config.fetchImpl ?? globalThis.fetch;
-  }
-  config;
-  fetchImpl;
-  get cliVersion() {
-    return CLI_VERSION;
-  }
-  get baseUrl() {
-    return this.config.baseUrl;
-  }
-  async get(path2, params) {
-    return this.json(await this.raw("GET", path2, { params }));
-  }
-  /**
-   * `actor: false` keeps a configured actor out of the body, for endpoints
-   * whose body is closed: they refuse a field they do not name, and record
-   * the credential's own person instead.
-   */
-  async post(path2, body = {}, options = {}) {
-    return this.json(
-      await this.raw("POST", path2, {
-        json: options.actor === false ? body : this.withActor(body),
-        idempotencyKey: options.idempotencyKey
-      })
-    );
-  }
-  async patch(path2, body) {
-    return this.json(await this.raw("PATCH", path2, { json: this.withActor(body) }));
-  }
-  async put(path2, body) {
-    return this.json(await this.raw("PUT", path2, { json: this.withActor(body) }));
-  }
-  async delete(path2) {
-    return this.json(await this.raw("DELETE", path2, {}));
-  }
-  /**
-   * Posts multipart/form-data — the one endpoint that does not take JSON.
-   * Shares auth, the version header, and error mapping with the JSON verbs,
-   * but never the actor: there is no JSON body to carry an `actor` field,
-   * and the server's file contract is the form itself.
-   */
-  async postMultipart(path2, form, bodyBytes = 0) {
-    return this.json(await this.raw("POST", path2, { form, timeoutMs: uploadTimeoutMs(bodyBytes) }));
-  }
-  /** Binary download (attachments); non-2xx still maps through the JSON error envelope. */
-  async getBytes(path2) {
-    const response = await this.raw("GET", path2, {});
-    if (!response.ok) throw await this.toHttpError(response);
-    try {
-      return new Uint8Array(await response.arrayBuffer());
-    } catch (error) {
-      throw new TransportError(transportMessage(error), transportCode(error));
-    }
-  }
-  /**
-   * A GET that also hands back the server's API version header, so a probe
-   * that verifies a credential reports the version without a second
-   * request. Errors map as for `get`.
-   */
-  async getVersioned(path2) {
-    const response = await this.raw("GET", path2, {});
-    const apiVersion = response.headers.get(API_VERSION_HEADER);
-    return { envelope: await this.json(response), apiVersion };
-  }
-  /**
-   * The server's API version, for `version`'s server side. The header rides
-   * on every response of a route the server has — the versioning plug runs
-   * before auth — so even a 401 answers. Each credential probes a route it
-   * reaches, so the probe is never a refusal in the server's log: a pxc_
-   * credential its assignments, a login credential of either kind (the
-   * Operator-only one reaches no tracker read) GET /api/v1/session, and an
-   * aone_ token the stats. A server older than GET /api/v1/session answers
-   * that route's 404 without the header, so the stats answer then.
-   */
-  async serverVersion() {
-    const token = this.config.token;
-    const path2 = isExpertToken(token) ? EXPERT_ASSIGNMENTS_PATH : isLoginCredential(token) ? SESSION_PATH : STATS_PATH;
-    const version2 = (await this.raw("GET", path2, {})).headers.get(API_VERSION_HEADER);
-    if (version2 !== null || path2 !== SESSION_PATH) return version2 ?? "unknown";
-    return (await this.raw("GET", STATS_PATH, {})).headers.get(API_VERSION_HEADER) ?? "unknown";
-  }
-  // Only an explicitly configured actor is sent, and never over one the
-  // caller already put in the body.
-  withActor(body) {
-    if (this.config.actor === null || "actor" in body) return body;
-    return { ...body, actor: this.config.actor };
-  }
-  async raw(method, path2, options) {
-    const url = new URL(this.config.baseUrl + path2);
-    for (const [key, value] of Object.entries(options.params ?? {})) {
-      if (value !== void 0) url.searchParams.set(key, String(value));
-    }
-    const headers = {
-      authorization: `Bearer ${this.config.token}`,
-      "x-harness-cli-version": CLI_VERSION
-    };
-    if (options.idempotencyKey !== void 0) {
-      headers["idempotency-key"] = options.idempotencyKey;
-    }
-    let body;
-    if (options.json !== void 0) {
-      headers["content-type"] = "application/json";
-      body = JSON.stringify(options.json);
-    } else if (options.form !== void 0) {
-      body = options.form;
-    }
-    try {
-      return await this.fetchImpl(url, {
-        method,
-        headers,
-        body,
-        signal: AbortSignal.timeout(options.timeoutMs ?? RECEIVE_TIMEOUT_MS),
-        redirect: "manual"
-      });
-    } catch (error) {
-      throw new TransportError(transportMessage(error), transportCode(error));
-    }
-  }
-  async json(response) {
-    if (!response.ok) throw await this.toHttpError(response);
-    let text;
-    try {
-      text = await response.text();
-    } catch (error) {
-      throw new TransportError(transportMessage(error), transportCode(error));
-    }
-    if (text === "") return { data: void 0 };
-    let parsed;
-    try {
-      parsed = JSON.parse(text);
-    } catch {
-      throw new MalformedResponseError(`the API answered with a non-JSON body (HTTP ${response.status})`);
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new MalformedResponseError(`the API answered with an invalid JSON envelope (HTTP ${response.status})`);
-    }
-    return parsed;
-  }
-  async toHttpError(response) {
-    let parsed = {};
-    try {
-      const candidate = JSON.parse(await response.text());
-      if (typeof candidate === "object" && candidate !== null) {
-        parsed = candidate;
-      }
-    } catch {
-    }
-    const fromBody = typeof parsed["message"] === "string" ? parsed["message"] : null;
-    const message = fromBody ?? DEFAULT_MESSAGES[response.status] ?? `HTTP ${response.status}`;
-    if (response.status === 426) return new UpgradeRequiredError(message, parsed);
-    return new HttpError(response.status, message, parsed, response.headers.get("retry-after"));
-  }
-};
-function transportCode(error) {
-  const cause = error instanceof Error ? error.cause : void 0;
-  if (typeof cause !== "object" || cause === null) return null;
-  const code = cause.code;
-  if (typeof code === "string") return code;
-  const errors = cause.errors;
-  if (!Array.isArray(errors)) return null;
-  const codes = new Set(errors.map((inner) => inner?.code));
-  const [only] = codes;
-  return codes.size === 1 && typeof only === "string" ? only : null;
-}
-function transportMessage(error) {
-  if (error instanceof Error) {
-    if (error.name === "TimeoutError" || error.name === "AbortError") return "request timed out";
-    const cause = error.cause;
-    if (cause instanceof Error && cause.message !== "") return cause.message;
-    return error.message;
-  }
-  return String(error);
-}
-
-// src/core/output.ts
-var TITLE_WIDTH = 70;
-var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function graphemes(text) {
-  return [...segmenter.segment(text)].map((piece) => piece.segment);
-}
-function graphemeLength(text) {
-  return graphemes(text).length;
-}
-function padGraphemes(text, width) {
-  const shortfall = width - graphemeLength(text);
-  return shortfall > 0 ? text + " ".repeat(shortfall) : text;
-}
-function clean(value) {
-  if (value === null || value === void 0) return "";
-  return String(value).replace(/[\x00-\x1F\x7F\u0080-\u009F]/gu, "");
-}
-function json(term) {
-  return JSON.stringify(term) + "\n";
-}
-var OPERATOR_TEAM_KEY = /^OPERATOR\d*$/;
-var OPERATOR_TEAM_NAME = "Operator";
-var AGENT_MARK = "[agent]";
-var AGENT_LEGEND = `
-${AGENT_MARK} Operator runs this step for its plan; only the plan driver claims it.
-`;
-function isAgentStep(issue) {
-  return OPERATOR_TEAM_KEY.test(str(path(issue, "team", "key"))) && str(path(issue, "team", "name")) === OPERATOR_TEAM_NAME;
-}
-function issuesTable(issues, options = {}) {
-  if (issues.length === 0) return "No issues.\n";
-  let marked = false;
-  const rows = issues.map((issue) => {
-    const agentStep = options.markAgentSteps === true && isAgentStep(issue);
-    if (agentStep) marked = true;
-    return [
-      str(issue["identifier"]),
-      str(path(issue, "state", "name")) || "-",
-      str(issue["priority_label"]) || "-",
-      str(path(issue, "assignee", "name")) || "-",
-      agentStep ? truncate(`${AGENT_MARK} ${clean(issue["title"])}`) : truncate(issue["title"])
-    ];
-  });
-  const rendered = table(["ID", "STATE", "PRIORITY", "ASSIGNEE", "TITLE"], rows);
-  return marked ? rendered + AGENT_LEGEND : rendered;
-}
-function issueDetail(issue, images = []) {
-  const header = `${str(issue["identifier"])} \xB7 ${clean(issue["title"])}
-`;
-  const fields = [
-    ["State", path(issue, "state", "name")],
-    ["Priority", issue["priority_label"]],
-    ["Assignee", path(issue, "assignee", "name")],
-    ["Team", path(issue, "team", "key")],
-    ["Labels", labelsLine(issue["labels"])],
-    ["Blocked", blockedLine(issue)],
-    ["Waiting", waitingLine(issue)],
-    ["Due", issue["due_date"]],
-    ["Updated", issue["updated_at"]]
-  ];
-  const fieldLines = fields.filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([label, value]) => `  ${(label + ":").padEnd(12)}${clean(value)}
-`).join("");
-  const sections = [
-    ["Description", issue["description"]],
-    ["Design", issue["design"]],
-    ["Acceptance criteria", issue["acceptance_criteria"]],
-    ["Notes", issue["notes"]]
-  ];
-  const sectionText = sections.filter(([, text]) => text !== null && text !== void 0 && text !== "").map(([title, text]) => `
-${title}:
-${indent(String(text))}
-`).join("");
-  return header + fieldLines + sectionText + conditionsSection(issue["conditions"]) + relationsSection(issue["relations"]) + childrenSection(issue["children"]) + commentsSection(issue["comments"]) + imagesSection(images);
-}
-function activityEntries(entries) {
-  if (entries.length === 0) return "No activity.\n";
-  return entries.map(activityEntry).join("\n");
-}
-function activityEntry(entry) {
-  switch (entry["kind"]) {
-    case "comment":
-      return activityComment(entry);
-    case "state_event":
-      return activityStateEvent(entry);
-    case "assignee_event":
-      return activityAssigneeEvent(entry);
-    case "condition_event":
-      return activityConditionEvent(entry);
-    case "field_event":
-      return activityFieldEvent(entry);
-    default:
-      throw new CommandError(`Unknown activity entry kind: ${clean(entry["kind"])}`);
-  }
-}
-function activityComment(entry) {
-  const comment2 = requiredRecord(entry["comment"], "activity comment");
-  const authorValue = comment2["author"];
-  const author = authorValue === null ? "unknown" : optionalLabel(requiredRecord(authorValue, "comment author")["name"], "unknown", "comment author name");
-  const deleted = comment2["deleted"];
-  if (typeof deleted !== "boolean") throw new CommandError("Invalid comment deleted flag.");
-  const body = activityCommentBody(comment2["body"], deleted);
-  const text = cleanMultiline(body).split("\n").map((line) => "  " + line).join("\n");
-  return `[${occurredAt(entry)}] ${clean(author)} (${clean(requiredString(comment2["id"], "comment id"))}):
-${text}
-`;
-}
-function activityCommentBody(value, deleted) {
-  if (deleted) return "[deleted comment]";
-  if (value === null || value === "") return "[comment has no text]";
-  return requiredString(value, "comment body");
-}
-function activityStateEvent(entry) {
-  const actor = activityWho(entry);
-  const provenance = activityProvenance(requiredRecord(entry["provenance"], "activity provenance"));
-  let description;
-  switch (entry["action"]) {
-    case "created":
-      description = `${actor} created the issue in ${stateName(entry["to_state"], "created to_state")}`;
-      break;
-    case "transition":
-      description = `${actor} moved the issue from ${nullableStateName(entry["from_state"], "transition from_state")} to ${stateName(entry["to_state"], "transition to_state")}`;
-      break;
-    case "milestone":
-      description = `${actor} recorded the ${stateName(entry["to_state"], "milestone to_state")} milestone`;
-      break;
-    default:
-      throw new CommandError(`Unknown activity action: ${clean(entry["action"])}`);
-  }
-  return `[${occurredAt(entry)}] ${description} \xB7 ${provenance}
-`;
-}
-function activityAssigneeEvent(entry) {
-  const actor = activityWho(entry);
-  const provenance = activityProvenance(requiredRecord(entry["provenance"], "activity provenance"));
-  let description;
-  switch (entry["action"]) {
-    case "assigned":
-      description = `${actor} assigned the issue to ${assigneeName(entry["to_assignee"])}`;
-      break;
-    case "reassigned":
-      description = `${actor} reassigned the issue from ${assigneeName(entry["from_assignee"])} to ${assigneeName(entry["to_assignee"])}`;
-      break;
-    case "unassigned":
-      description = `${actor} unassigned the issue from ${assigneeName(entry["from_assignee"])}`;
-      break;
-    default:
-      throw new CommandError(`Unknown activity action: ${clean(entry["action"])}`);
-  }
-  return `[${occurredAt(entry)}] ${description} - ${provenance}
-`;
-}
-function activityConditionEvent(entry) {
-  const actor = activityWho(entry);
-  const provenance = activityProvenance(requiredRecord(entry["provenance"], "activity provenance"));
-  const condition = conditionSubject(requiredRecord(entry["condition"], "activity condition"));
-  let description;
-  switch (entry["action"]) {
-    case "added":
-      description = `${actor} added ${condition}`;
-      break;
-    case "changed":
-      description = `${actor} changed ${condition}`;
-      break;
-    case "removed":
-      description = `${actor} removed ${condition}`;
-      break;
-    case "satisfied":
-      description = `${actor} satisfied ${condition}`;
-      break;
-    case "unsatisfied":
-      description = `${actor} marked ${condition} unsatisfied`;
-      break;
-    default:
-      throw new CommandError(`Unknown activity action: ${clean(entry["action"])}`);
-  }
-  return `[${occurredAt(entry)}] ${description} \xB7 ${provenance}
-`;
-}
-function conditionSubject(condition) {
-  const label = clean(condition["label"]);
-  switch (condition["kind"]) {
-    case "gate":
-      return label === "" ? "the gate" : `the gate "${label}"`;
-    case "not_before": {
-      const at = clean(condition["not_before"]);
-      return at === "" ? "the not-before date" : `the not-before date ${at}`;
-    }
-    case "event":
-      return label === "" ? "the wait condition" : `the system event "${label}"`;
-    default:
-      return "the wait condition";
-  }
-}
-function activityFieldEvent(entry) {
-  const actor = activityWho(entry);
-  const provenance = activityProvenance(requiredRecord(entry["provenance"], "activity provenance"));
-  const change = fieldChange(requiredString(entry["field"], "activity field"), entry["from"], entry["to"]);
-  return `[${occurredAt(entry)}] ${actor} ${change} \xB7 ${provenance}
-`;
-}
-function fieldChange(field3, from, to) {
-  switch (field3) {
-    case "priority":
-      return `changed priority from ${priorityName(from)} to ${priorityName(to)}`;
-    case "title":
-      return `renamed the issue from \u201C${activityTitle(from)}\u201D to \u201C${activityTitle(to)}\u201D`;
-    case "description":
-      return "edited the description";
-    case "labels":
-      return labelsChange(to);
-    case "parent":
-      return parentChange(from, to);
-    case "archived":
-      if (typeof to !== "boolean") throw new CommandError("Invalid activity archived value.");
-      return to ? "archived the issue" : "unarchived the issue";
-    default:
-      return `changed the ${clean(field3)} field`;
-  }
-}
-var ACTIVITY_PRIORITIES = {
-  0: "No priority",
-  1: "Urgent",
-  2: "High",
-  3: "Medium",
-  4: "Low"
-};
-function priorityName(value) {
-  if (typeof value !== "number" || !Number.isInteger(value)) throw new CommandError("Invalid activity priority.");
-  return ACTIVITY_PRIORITIES[value] ?? String(value);
-}
-function activityTitle(value) {
-  if (typeof value !== "string") throw new CommandError("Invalid activity title.");
-  return clean(value);
-}
-function labelsChange(to) {
-  const change = requiredRecord(to, "activity labels");
-  const added = labelNames(change["added"]);
-  const removed = labelNames(change["removed"]);
-  const parts = [
-    ...added.length > 0 ? [`added ${labelList(added)}`] : [],
-    ...removed.length > 0 ? [`removed ${labelList(removed)}`] : []
-  ];
-  return parts.length === 0 ? "changed the labels" : parts.join(" and ");
-}
-function labelNames(value) {
-  if (!Array.isArray(value)) throw new CommandError("Invalid activity labels.");
-  return value.map((label) => clean(requiredString(requiredRecord(label, "activity labels")["name"], "activity labels")));
-}
-function labelList(names) {
-  return `${names.length === 1 ? "label" : "labels"} ${names.join(", ")}`;
-}
-function parentChange(from, to) {
-  if (from === null && to === null) return "changed the parent";
-  if (from === null) return `set the parent to ${parentName(to)}`;
-  if (to === null) return `removed the parent ${parentName(from)}`;
-  return `changed the parent from ${parentName(from)} to ${parentName(to)}`;
-}
-function parentName(value) {
-  const parent = requiredRecord(value, "activity parent");
-  return optionalLabel(parent["identifier"], "an unknown issue", "activity parent identifier");
-}
-function activityWho(entry) {
-  const actor = activityActor(requiredRecord(entry["actor"], "activity actor"));
-  const label = entry["actor_label"];
-  if (label === void 0 || label === null || label === "") return actor;
-  if (typeof label !== "string") throw new CommandError("Invalid activity actor label.");
-  const cleaned = clean(label);
-  return cleaned === "" ? actor : `${actor} via \u201C${cleaned}\u201D`;
-}
-function occurredAt(entry) {
-  return clean(requiredString(entry["occurred_at"], "activity occurrence time"));
-}
-function assigneeName(value) {
-  const assignee = requiredRecord(value, "activity assignee");
-  if (assignee["kind"] === "unknown") return "Unknown assignee";
-  return activityActor(assignee);
-}
-function activityActor(actor) {
-  switch (actor["kind"]) {
-    case "user":
-      return optionalLabel(actor["name"], "Unknown actor", "activity actor name");
-    case "system":
-      return "System";
-    case "deleted_user":
-      return "Deleted user";
-    case "unknown":
-      return "Unknown actor";
-    default:
-      throw new CommandError(`Unknown activity actor kind: ${clean(actor["kind"])}`);
-  }
-}
-function activityProvenance(provenance) {
-  switch (provenance["kind"]) {
-    case "live":
-    case "import":
-    case "backfill":
-      return String(provenance["kind"]);
-    default:
-      throw new CommandError(`Unknown activity provenance: ${clean(provenance["kind"])}`);
-  }
-}
-function stateName(value, field3) {
-  return optionalLabel(requiredRecord(value, field3)["name"], "Unknown state", `${field3} name`);
-}
-function nullableStateName(value, field3) {
-  return value === null ? "Unknown state" : stateName(value, field3);
-}
-function optionalLabel(value, fallback, field3) {
-  if (value === null || value === "") return fallback;
-  return clean(requiredString(value, field3));
-}
-function requiredRecord(value, field3) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new CommandError(`Invalid ${field3}.`);
-  }
-  return value;
-}
-function requiredString(value, field3) {
-  if (typeof value !== "string" || value === "") throw new CommandError(`Invalid ${field3}.`);
-  return value;
-}
-function stats(data) {
-  const teams = data["teams"] ?? [];
-  const totals = data["totals"] ?? {};
-  const rows = teams.map((team) => [
-    str(path(team, "team", "key")),
-    str(team["open"]),
-    str(team["started"]),
-    str(team["blocked"]),
-    str(team["ready"]),
-    str(team["closed"])
-  ]);
-  const totalsRow = ["TOTAL", ...["open", "started", "blocked", "ready", "closed"].map((key) => str(totals[key]))];
-  return table(["TEAM", "OPEN", "STARTED", "BLOCKED", "READY", "CLOSED"], [...rows, totalsRow]);
-}
-function table(headers, rows) {
-  const all = [headers, ...rows.map((row) => row.map((cell) => clean(cell)))];
-  const widths = headers.map((_, column) => Math.max(...all.map((row) => graphemeLength(row[column] ?? ""))));
-  return all.map(
-    (row) => row.map((cell, column) => padGraphemes(cell, widths[column] ?? 0)).join("  ").replace(/\s+$/, "") + "\n"
-  ).join("");
-}
-function records(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter(
-    (entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry)
-  );
-}
-function waitingLine(issue) {
-  if (issue["waiting_on_condition"] !== true) return null;
-  const conditions = records(issue["conditions"]);
-  const open = conditions.filter((condition) => condition["satisfied"] !== true).length;
-  return `yes, on ${open} of ${conditions.length} wait condition${conditions.length === 1 ? "" : "s"}`;
-}
-function conditionsSection(conditions) {
-  const list3 = records(conditions);
-  if (list3.length === 0) return "";
-  return "\nWait conditions:\n" + list3.map((condition) => `  ${conditionLine(condition)}
-`).join("");
-}
-function conditionLine(condition, options = {}) {
-  const satisfied = condition["satisfied"] === true;
-  let what;
-  switch (condition["kind"]) {
-    case "gate": {
-      const owner = condition["owner"];
-      let ownedBy = "";
-      if (typeof owner === "object" && owner !== null) {
-        const record = owner;
-        ownedBy = options.expertView === true && record["kind"] === "expert" ? "you" : ownerText(record);
-      }
-      what = `gate ${gateName(condition)}${ownedBy === "" ? "" : ` owned by ${ownedBy}`}`;
-      break;
-    }
-    case "not_before":
-      what = `not before ${clean(condition["not_before"])}`;
-      break;
-    case "event":
-      what = "system event";
-      break;
-    default:
-      what = clean(condition["kind"]) || "condition";
-  }
-  let when = "";
-  if (satisfied && typeof condition["satisfied_at"] === "string") {
-    let by = clean(path(condition, "satisfied_by", "name"));
-    if (by === "" && condition["satisfied_by_kind"] === "expert") by = "an outside expert";
-    let role = typeof condition["satisfied_as_role"] === "string" ? roleName(condition["satisfied_as_role"]) : "";
-    switch (path(condition, "satisfied_by", "kind")) {
-      case "you":
-        by = "you";
-        break;
-      case "role": {
-        const as = path(condition, "satisfied_by", "role");
-        if (typeof as === "string" && as !== "") role = roleName(as);
-        break;
-      }
-      case "expert":
-        by = "an outside expert";
-        break;
-      case "member":
-        by = "a member";
-        break;
-    }
-    when = ` (satisfied ${clean(condition["satisfied_at"])}${by === "" ? "" : ` by ${by}`}${role === "" ? "" : ` as ${role}`})`;
-  }
-  return `${satisfied ? "[x]" : "[ ]"} ${what}${when} \xB7 ${clean(condition["id"])}`;
-}
-function gateName(gate) {
-  const key = clean(gate["key"]);
-  return `"${clean(gate["label"])}"${key === "" ? "" : ` [${key}]`}`;
-}
-function ownerText(owner) {
-  const label = clean(owner["label"]) || (owner["kind"] === "role" && typeof owner["role"] === "string" ? roleName(owner["role"]) : "");
-  const ref = clean(owner["ref"]);
-  if (owner["kind"] === "expert") {
-    const email = label || ref.replace(/^expert:/, "");
-    return email === "" ? "" : `${email} (expert)`;
-  }
-  if (label === "") return ref;
-  return ref === "" || ref === label ? label : `${label} (${ref})`;
-}
-function expertSummary(seat) {
-  const role = typeof seat.role === "string" && seat.role !== "" ? roleName(seat.role) : "Outside expert";
-  const status = clean(seat.plan?.status);
-  const plan = seat.plan === null ? ", no plan" : ` on plan ${clean(seat.plan.id)}${status === "" ? "" : ` (${status})`}`;
-  const steps = seat.assigned_steps;
-  const count = steps === 0 ? "no assigned steps" : `${steps} assigned step${steps === 1 ? "" : "s"}`;
-  return `${role}${plan} \xB7 ${count}`;
-}
-function expertAssignments(steps) {
-  return steps.map((step) => "\n" + assignedStep(step)).join("");
-}
-function assignedStep(step) {
-  const blockers = typeof step["open_blockers"] === "number" ? step["open_blockers"] : 0;
-  const fields = [
-    ["State", path(step, "state", "name")],
-    ["Due", step["due_date"]],
-    ["Blocked", blockers > 0 ? `yes, by ${blockers} open issue${blockers === 1 ? "" : "s"}` : null]
-  ];
-  const fieldLines = fields.filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([label, value]) => `  ${(label + ":").padEnd(12)}${clean(value)}
-`).join("");
-  const gates = records(step["gates"]);
-  const gateLines = gates.length === 0 ? "  Gates:      none of yours\n" : "  Gates:\n" + gates.map((gate) => `    ${conditionLine(gate, { expertView: true })}
-`).join("");
-  const description = step["description"];
-  const descriptionLines = typeof description === "string" && description !== "" ? "  Description:\n" + indent(indent(description)) + "\n" : "";
-  return `${clean(step["identifier"])} \xB7 ${clean(step["title"])}
-${fieldLines}${gateLines}${descriptionLines}`;
-}
-var ROLE_NAMES = { gp: "GP" };
-function roleName(role) {
-  const slug = clean(role);
-  if (Object.hasOwn(ROLE_NAMES, slug)) return ROLE_NAMES[slug];
-  const words = slug.replace(/_/g, " ");
-  return words.charAt(0).toUpperCase() + words.slice(1);
-}
-var LIVE_PLAN_STATUSES = ["released", "running", "needs_attention"];
-function planDetail(plan) {
-  const steps = records(plan["steps"]);
-  const fields = [
-    ["Root", planRootLine(plan["root"])],
-    ["Revision", planRevisionLine(plan)],
-    ["Budgets", planBudgetsLine(plan)],
-    ["Estimate", planEstimateLine(plan["estimate"])]
-  ];
-  const fieldLines = fields.filter((field3) => field3[1] !== null).map(([label, value]) => `  ${(label + ":").padEnd(12)}${value}
-`).join("");
-  return `Plan ${clean(plan["id"])} \xB7 ${clean(plan["status"])}
-` + fieldLines + planStepsSection(steps, str(plan["status"])) + planEdgesSection(plan["edges"]) + planConditionsSection(steps) + planWaitingSection(steps) + planHeldSection(plan["held_steps"]);
-}
-function planRootLine(root) {
-  if (typeof root !== "object" || root === null) return null;
-  const record = root;
-  return `${clean(record["identifier"])} \xB7 ${clean(record["title"])}`;
-}
-function planRevisionLine(plan) {
-  const revision = plan["revision"];
-  if (typeof revision !== "object" || revision === null) return "none yet (never released)";
-  const number = clean(revision["number"]);
-  const by = clean(path(plan, "released_by", "name"));
-  const at = clean(plan["released_at"]);
-  if (by === "" && at === "") return number;
-  return `${number} \xB7 released${by === "" ? "" : ` by ${by}`}${at === "" ? "" : ` at ${at}`}`;
-}
-function planBudgetsLine(plan) {
-  const retries = plan["retry_budget"];
-  const retryText = typeof retries === "number" ? `${retries} ${retries === 1 ? "retry" : "retries"} per failed Operator step` : null;
-  const spend = plan["spend_budget_cents"];
-  const spendText = typeof spend === "number" ? `spend budget ${spend} cents` : "no spend budget";
-  return [retryText, spendText].filter((part) => part !== null).join(" \xB7 ");
-}
-function planEstimateLine(estimate) {
-  if (typeof estimate !== "object" || estimate === null) return null;
-  const record = estimate;
-  const ceiling = record["ceiling_cents"];
-  if (typeof ceiling !== "number") return null;
-  const minimum = record["minimum_budget_cents"];
-  return `up to ${ceiling} cents${typeof minimum === "number" ? ` (minimum budget ${minimum} cents)` : ""}`;
-}
-function planStepsSection(steps, planStatus) {
-  if (steps.length === 0) return "";
-  const depths = stepDepths(steps);
-  const rows = steps.map((step) => [
-    "  ".repeat(depths.get(str(step["identifier"])) ?? 0) + str(step["identifier"]),
-    str(step["key"]) || "-",
-    str(step["executor"]) || "-",
-    str(path(step, "state", "name")) || "-",
-    stepStatus(step, planStatus),
-    truncate(step["title"])
-  ]);
-  const rendered = table(["STEP", "KEY", "EXECUTOR", "STATE", "STATUS", "TITLE"], rows);
-  return "\nSteps:\n" + indentLines(rendered);
-}
-function stepDepths(steps) {
-  const parents = new Map(steps.map((step) => [str(step["identifier"]), str(step["parent"])]));
-  const depths = /* @__PURE__ */ new Map();
-  for (const identifier of parents.keys()) {
-    let depth = 0;
-    let parent = parents.get(identifier) ?? "";
-    const seen = /* @__PURE__ */ new Set([identifier]);
-    while (parent !== "" && parents.has(parent) && !seen.has(parent)) {
-      seen.add(parent);
-      depth += 1;
-      parent = parents.get(parent) ?? "";
-    }
-    depths.set(identifier, depth);
-  }
-  return depths;
-}
-function stepStatus(step, planStatus) {
-  const stateType = path(step, "state", "type");
-  if (step["archived"] === true) return "archived";
-  if (stateType === "completed") return "done";
-  if (stateType === "canceled") return "cancelled";
-  if (step["container"] === true) return "container";
-  if (step["ready"] === true) return "ready";
-  if (step["held"] === true) return "held";
-  if (step["in_revision"] === false && LIVE_PLAN_STATUSES.includes(planStatus)) return "not in revision";
-  if (records(step["conditions"]).some((condition) => condition["satisfied"] !== true)) return "waiting";
-  return "-";
-}
-function planEdgesSection(edges) {
-  const list3 = records(edges);
-  if (list3.length === 0) return "";
-  return "\nEdges (blocker \u2192 blocked):\n" + list3.map((edge) => `  ${clean(edge["from"])} \u2192 ${clean(edge["to"])}
-`).join("");
-}
-function planConditionsSection(steps) {
-  const lines = steps.flatMap(
-    (step) => records(step["conditions"]).map((condition) => [clean(step["identifier"]), conditionLine(condition)])
-  );
-  if (lines.length === 0) return "";
-  const width = Math.max(...lines.map(([identifier]) => graphemeLength(identifier)));
-  return "\nWait conditions:\n" + lines.map(([identifier, line]) => `  ${padGraphemes(identifier, width)}  ${line}
-`).join("");
-}
-function planWaitingSection(steps) {
-  const lines = steps.flatMap(
-    (step) => records(step["waiting_for"]).map((wait) => [clean(step["identifier"]), waitLine(wait)])
-  );
-  if (lines.length === 0) return "";
-  const width = Math.max(...lines.map(([identifier]) => graphemeLength(identifier)));
-  return "\nWaiting for:\n" + lines.map(([identifier, line]) => `  ${padGraphemes(identifier, width)}  ${line}
-`).join("");
-}
-function waitLine(wait) {
-  const name = gateName(wait);
-  const owner = wait["owner"];
-  if (typeof owner !== "object" || owner === null) return `${name} \xB7 no owner, anyone with standing can tick`;
-  const holders = wait["holders"];
-  let who;
-  if (!Array.isArray(holders)) who = "who can tick is not known";
-  else if (holders.length === 0) who = "nobody can tick";
-  else who = `can tick: ${records(holders).map(holderText).join(", ")}`;
-  return `${name} \xB7 ${ownerText(owner)} \xB7 ${who}`;
-}
-function holderText(holder) {
-  const name = clean(holder["name"]);
-  if (holder["kind"] !== "expert") return name;
-  const organization = clean(holder["organization"]);
-  return `${name} (expert${organization === "" ? "" : `, ${organization}`})`;
-}
-function planHeldSection(heldSteps) {
-  if (!Array.isArray(heldSteps) || heldSteps.length === 0) return "";
-  return `
-Held by an edit until the plan is released again: ${heldSteps.map((step) => clean(step)).join(", ")}
-`;
-}
-function indentLines(text) {
-  return text.split("\n").map((line) => line === "" ? line : "  " + line).join("\n");
-}
-function errorDetails(body) {
-  return changesetDetails(body["details"]) + violationDetails(body["violations"]);
-}
-function changesetDetails(details) {
-  if (typeof details !== "object" || details === null || Array.isArray(details)) return "";
-  return Object.entries(details).map(([field3, messages]) => {
-    const text = Array.isArray(messages) ? messages.map(String).join("; ") : String(messages);
-    return `
-  ${clean(field3)}: ${clean(text)}`;
-  }).join("");
-}
-function violationDetails(violations) {
-  return records(violations).map((violation) => {
-    const code = clean(violation["code"]);
-    const message = clean(violation["message"]) || code || "invalid";
-    return `
-  ${violationSubject(violation)}: ${message}${code === "" ? "" : ` [${code}]`}`;
-  }).join("");
-}
-function violationSubject(violation) {
-  const key = typeof violation["key"] === "string" ? clean(violation["key"]) : null;
-  const index = typeof violation["index"] === "number" ? `steps[${violation["index"]}]` : null;
-  const issue = typeof violation["issue"] === "string" ? clean(violation["issue"]) : null;
-  if (key !== null) {
-    const where = index ?? issue;
-    return where === null ? `step "${key}"` : `step "${key}" (${where})`;
-  }
-  return issue ?? index ?? "plan";
-}
-function relationsSection(relations) {
-  if (!Array.isArray(relations) || relations.length === 0) return "";
-  const lines = relations.map((relation) => `  ${str(relation["direction"]).padEnd(14)}${str(relation["other_issue"])}
-`).join("");
-  return "\nRelations:\n" + lines;
-}
-function childrenSection(children) {
-  if (!Array.isArray(children) || children.length === 0) return "";
-  const lines = children.map((child) => {
-    const state = str(path(child, "state", "name")) || "-";
-    return `  ${str(child["identifier"])}  [${state}]  ${truncate(child["title"])}
-`;
-  }).join("");
-  return "\nSub-issues:\n" + lines;
-}
-function commentsSection(comments2) {
-  if (!Array.isArray(comments2) || comments2.length === 0) return "";
-  const lines = comments2.map((comment2) => {
-    const author = clean(path(comment2, "author", "name") ?? "unknown");
-    return `  [${str(comment2["inserted_at"])}] ${author}: ${truncate(comment2["body"])}
-`;
-  }).join("");
-  return "\nComments:\n" + lines;
-}
-function imagesSection(images) {
-  if (images.length === 0) return "";
-  const lines = images.map((image) => `  [${image["source"]}] ${clean(image["path"])}
-`).join("");
-  return "\nImages (attachments downloaded locally \u2014 read them, they are part of the issue):\n" + lines;
-}
-function labelsLine(labels) {
-  if (!Array.isArray(labels) || labels.length === 0) return null;
-  return labels.map((label) => clean(label["name"])).join(", ");
-}
-function blockedLine(issue) {
-  if (issue["blocked"] === true && Array.isArray(issue["blocked_by"])) {
-    const notes = blockerNotes(issue["blockers"]);
-    const blockers = issue["blocked_by"].map((blocker) => {
-      const identifier = String(blocker);
-      const note = notes.get(identifier);
-      return note === void 0 ? identifier : `${identifier} (${note})`;
-    });
-    return `yes, by ${blockers.join(", ")}`;
-  }
-  return null;
-}
-function blockerNotes(blockers) {
-  const notes = /* @__PURE__ */ new Map();
-  if (!Array.isArray(blockers)) return notes;
-  for (const blocker of blockers) {
-    if (typeof blocker !== "object" || blocker === null) continue;
-    const record = blocker;
-    if (typeof record["identifier"] !== "string") continue;
-    const reasons = [];
-    if (record["state_type"] === "canceled") reasons.push("cancelled");
-    if (record["archived"] === true) reasons.push("archived");
-    if (reasons.length > 0) notes.set(record["identifier"], reasons.join(", "));
-  }
-  return notes;
-}
-function indent(text) {
-  return cleanMultiline(text).split("\n").map((line) => "  " + line).join("\n");
-}
-function cleanMultiline(text) {
-  return text.split("\n").map((line) => clean(line)).join("\n");
-}
-function truncate(text) {
-  if (text === null || text === void 0) return "";
-  const cleaned = clean(text);
-  const pieces = graphemes(cleaned);
-  if (pieces.length > TITLE_WIDTH) {
-    return pieces.slice(0, TITLE_WIDTH - 1).join("") + "\u2026";
-  }
-  return cleaned;
-}
-function str(value) {
-  return value === null || value === void 0 ? "" : String(value);
-}
-function path(record, ...keys) {
-  let current = record;
-  for (const key of keys) {
-    if (typeof current !== "object" || current === null) return null;
-    current = current[key];
-  }
-  return current ?? null;
-}
+} from "./chunk-5THYIKLW.js";
 
 // src/commands/issues.ts
 import { openAsBlob, openSync, closeSync, readFileSync, statSync as statSync2 } from "fs";
@@ -1051,14 +102,14 @@ async function fetchImages(client, issue, cacheDir) {
   return { images, failures };
 }
 async function download(client, ref, cacheDir) {
-  const path2 = join(cacheDir, hostSegment(client.baseUrl), ref.attachmentId, ref.file);
+  const path = join(cacheDir, hostSegment(client.baseUrl), ref.attachmentId, ref.file);
   try {
-    if (statSync(path2).size > 0) return { ok: true, path: path2 };
+    if (statSync(path).size > 0) return { ok: true, path };
   } catch {
   }
   const bytes = await fetchBytes(client, ref);
   if (!bytes.ok) return bytes;
-  return write(path2, bytes.bytes);
+  return write(path, bytes.bytes);
 }
 function hostSegment(baseUrl) {
   let host = "unknown-host";
@@ -1098,25 +149,25 @@ function isImage(bytes) {
   return false;
 }
 var partialCounter = 0;
-function write(path2, bytes) {
-  const partial = `${path2}.partial.${process.pid}.${++partialCounter}`;
+function write(path, bytes) {
+  const partial = `${path}.partial.${process.pid}.${++partialCounter}`;
   try {
-    mkdirSync(dirname(path2), { recursive: true });
-    chmodSync(dirname(path2), 448);
+    mkdirSync(dirname(path), { recursive: true });
+    chmodSync(dirname(path), 448);
     writeFileSync(partial, bytes);
     chmodSync(partial, 384);
-    renameSync(partial, path2);
-    return { ok: true, path: path2 };
+    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 ${path2}: ${detail}` };
+    return { ok: false, message: `cannot write ${path}: ${detail}` };
   }
 }
 
 // src/core/pagination.ts
-function notices(meta, requestedPageSize, records5) {
-  return capNotice(meta, requestedPageSize) + truncationNotice(meta, records5);
+function notices(meta, requestedPageSize, records4) {
+  return capNotice(meta, requestedPageSize) + truncationNotice(meta, records4);
 }
 function capNotice(meta, requestedPageSize) {
   const served = meta?.page_size;
@@ -1126,12 +177,12 @@ function capNotice(meta, requestedPageSize) {
   }
   return "";
 }
-function truncationNotice(meta, records5) {
+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 = records5.length;
+  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.
 `;
@@ -1142,20 +193,20 @@ async function fetchEveryPage(fetchPage) {
   const first = await fetchPage(1);
   const totalPages = pageCount(first.meta);
   if (totalPages === null) return first.data;
-  let records5 = first.data;
+  let records4 = first.data;
   for (let page = 2; page <= totalPages; page++) {
     const body = await fetchPage(page);
-    records5 = dedupe([...records5, ...body.data]);
+    records4 = dedupe([...records4, ...body.data]);
   }
-  return records5;
+  return records4;
 }
 function pageCount(meta) {
   const total = meta?.total_pages;
   return typeof total === "number" && total > 0 ? total : null;
 }
-function dedupe(records5) {
+function dedupe(records4) {
   const seen = /* @__PURE__ */ new Set();
-  return records5.filter((record) => {
+  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;
@@ -1185,6 +236,9 @@ var UUID_FORMAT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
 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) {
@@ -1194,9 +248,9 @@ function requireIdentifiers(identifiers) {
 async function ready(ctx, opts) {
   if (opts.claim === true) return claimNext(ctx, opts);
   const params = { ...listParams(ctx, opts), ready: true };
-  const { records: records5, notice } = await fetchIssues(ctx, params, opts);
+  const { records: records4, notice } = await fetchIssues(ctx, params, opts);
   const rank = (issue) => PRIORITY_RANK[issue["priority"]] ?? 4;
-  const sorted = markAgentSteps([...records5].sort((a, b) => rank(a) - rank(b)));
+  const sorted = markAgentSteps([...records4].sort((a, b) => rank(a) - rank(b)));
   return { json: sorted, human: issuesTable(sorted, { markAgentSteps: true }), notice };
 }
 function markAgentSteps(issues) {
@@ -1240,7 +294,7 @@ async function claimNext(ctx, opts) {
   if (!isIssueRecord(claimed)) throw unreadable("carried neither an issue nor null");
   return {
     json: claimed,
-    human: `Claimed ${str2(claimed["identifier"])}: ${clean(claimed["title"])}
+    human: `Claimed ${str(claimed["identifier"])}: ${clean(claimed["title"])}
 `
   };
 }
@@ -1251,13 +305,13 @@ function isIssueRecord(value) {
 }
 async function blocked(ctx, opts) {
   const params = { ...listParams(ctx, opts), blocked: true };
-  const { records: records5, notice } = await fetchIssues(ctx, params, opts);
-  return { json: records5, human: issuesTable(records5), notice };
+  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: records5, notice } = await fetchIssues(ctx, params, opts);
-  return { json: records5, human: issuesTable(records5), notice };
+  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>");
@@ -1281,11 +335,11 @@ async function show(ctx, identifier, opts) {
   if (opts.images !== false) {
     ({ images, failures } = await fetchImages(ctx.client, issue, ctx.config.cacheDir));
   }
-  const json2 = images.length === 0 ? issue : { ...issue, local_images: images };
+  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: json2, human } : { json: json2, human, notice };
+  return notice === "" ? { json, human } : { json, human, notice };
 }
 var ACTIVITY_MAX_LIMIT = 100;
 var ACTIVITY_INCLUDE = "condition_events,field_events";
@@ -1375,7 +429,7 @@ async function stats2(ctx) {
 async function prime(ctx) {
   const statsBody = await ctx.client.get("/api/v1/stats");
   const ready2 = markAgentSteps(await mostImportantReady(ctx));
-  const json2 = { stats: statsBody.data, ready: ready2 };
+  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
@@ -1384,7 +438,7 @@ 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: json2, human };
+  return { json, human };
 }
 async function mostImportantReady(ctx) {
   try {
@@ -1431,7 +485,7 @@ async function create(ctx, opts) {
   const issue = created.data;
   return {
     json: issue,
-    human: `Created ${str2(issue["identifier"])}: ${clean(issue["title"])}
+    human: `Created ${str(issue["identifier"])}: ${clean(issue["title"])}
 `
   };
 }
@@ -1484,7 +538,7 @@ async function update(ctx, identifier, opts) {
   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 : `${str2(existing)}
+    const combined = existing === null || existing === void 0 || existing === "" ? opts.appendNotes : `${str(existing)}
 
 ${opts.appendNotes}`;
     patch["notes"] = combined;
@@ -1508,24 +562,48 @@ ${opts.appendNotes}`;
   if (issue === null) {
     throw new UsageError("usage: harness update <id> --claim | --title \u2026 | --state <name> | \u2026");
   }
-  const human = wrote ? `Updated ${str2(issue["identifier"])}
-` : `Labels already up to date for ${str2(issue["identifier"])}
+  const human = wrote ? `Updated ${str(issue["identifier"])}
+` : `Labels already up to date for ${str(issue["identifier"])}
 `;
   return { json: issue, human };
 }
 var CLAIM_REFUSAL_HINTS = {
-  // The edit holds a released step, so the plan needs releasing again before
-  // the step is claimable.
-  agent_step: () => `Operator runs it for its plan; to do it yourself, set its executor to none (${invokedName()} plan edit <plan-id>) and release the plan again`,
+  // 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) : void 0;
+  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(
@@ -1562,7 +640,7 @@ async function close(ctx, identifiers, opts) {
     }
   }
   const human = results.map((result) => closeLine(result, opts.duplicateOf)).join("");
-  const json2 = results.map(
+  const json = results.map(
     (result) => result.ok ? {
       identifier: result.identifier,
       closed: true,
@@ -1573,7 +651,7 @@ async function close(ctx, identifiers, opts) {
     } : { identifier: result.identifier, closed: false, error: errorText(result.error) }
   );
   const partial = results.some((result) => !result.ok);
-  return partial ? { json: json2, human, partial: true } : { json: json2, human };
+  return partial ? { json, human, partial: true } : { json, human };
 }
 function closeLine(result, duplicateOf) {
   if (!result.ok) return `FAILED ${result.identifier}: ${errorText(result.error)}
@@ -1616,25 +694,25 @@ async function archive(ctx, identifiers, opts) {
 ` : `FAILED ${result.identifier}: ${errorText(result.error)}
 `
   ).join("");
-  const json2 = results.map(
+  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: json2, human, partial: true } : { json: json2, human };
+  return partial ? { json, human, partial: true } : { json, human };
 }
 async function comments(ctx, identifier) {
   requireIdentifiers([identifier]);
-  const records5 = await completeCommentThread(ctx, identifier);
-  if (records5.length === 0) return { json: records5, human: "No comments.\n" };
-  const human = records5.map((comment2) => {
+  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(str2(comment2["body"])).split("\n").map((line) => "  " + line).join("\n");
-    return `[${str2(comment2["inserted_at"])}] ${author} (${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: records5, human };
+  return { json: records4, human };
 }
 async function completeCommentThread(ctx, identifier) {
   const pages = [];
@@ -1648,20 +726,20 @@ async function completeCommentThread(ctx, identifier) {
     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 records5 = [];
+    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);
-      records5.push(record);
+      records4.push(record);
     }
-    pages.push(records5);
+    pages.push(records4);
     if (!page.meta.has_more) return pages.reverse().flat();
-    if (records5.length === 0) {
+    if (records4.length === 0) {
       throw new CommandError("Invalid comment pagination: has_more on an empty page; completeness unknown.");
     }
-    before = records5[0]["id"];
+    before = records4[0]["id"];
   }
 }
 async function dep(ctx, verb, issue, blocker) {
@@ -1680,7 +758,7 @@ async function dep(ctx, verb, issue, blocker) {
       (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/${str2(relation["id"])}`);
+    await ctx.client.delete(`/api/v1/issues/${issue}/relations/${str(relation["id"])}`);
     return { json: { deleted: relation["id"] }, human: `${blocker} no longer blocks ${issue}
 ` };
   }
@@ -1803,17 +881,17 @@ function requireCommentId(commentId) {
 }
 var MAX_IMAGE_BYTES = 25e6;
 var MAX_VIDEO_BYTES = 1e8;
-async function attachImage(ctx, path2) {
-  return uploadAttachment(ctx, path2, MAX_IMAGE_BYTES);
+async function attachImage(ctx, path) {
+  return uploadAttachment(ctx, path, MAX_IMAGE_BYTES);
 }
-async function attachFile(ctx, path2) {
-  const maxBytes = extname(path2).toLowerCase() === ".mp4" ? MAX_VIDEO_BYTES : MAX_IMAGE_BYTES;
-  return uploadAttachment(ctx, path2, maxBytes);
+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, path2, maxBytes) {
-  attachableFile(path2, maxBytes);
-  const file = maxBytes === MAX_VIDEO_BYTES ? new File([await openAsBlob(path2)], basename(path2)) : new File([readFileSync(path2)], basename(path2));
-  requireAttachmentSize(path2, file.size, 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);
@@ -1822,27 +900,27 @@ async function uploadAttachment(ctx, path2, maxBytes) {
   if (typeof markdown !== "string") throw new CommandError("the upload response carried no markdown reference");
   return { json: attachment, human: clean(markdown) + "\n" };
 }
-function attachableFile(path2, maxBytes) {
+function attachableFile(path, maxBytes) {
   let fileStats;
   try {
-    fileStats = statSync2(path2);
+    fileStats = statSync2(path);
   } catch (error) {
-    throw new LocalError(`cannot read ${path2}: ${posixDetail(error)}`);
+    throw new LocalError(`cannot read ${path}: ${posixDetail(error)}`);
   }
   if (!fileStats.isFile()) {
     const kind = fileStats.isDirectory() ? "directory" : "special file";
-    throw new LocalError(`${path2} is a ${kind}, not a file.`);
+    throw new LocalError(`${path} is a ${kind}, not a file.`);
   }
-  requireAttachmentSize(path2, fileStats.size, maxBytes);
+  requireAttachmentSize(path, fileStats.size, maxBytes);
   try {
-    closeSync(openSync(path2, "r"));
+    closeSync(openSync(path, "r"));
   } catch (error) {
-    throw new LocalError(`cannot read ${path2}: ${posixDetail(error)}`);
+    throw new LocalError(`cannot read ${path}: ${posixDetail(error)}`);
   }
 }
-function requireAttachmentSize(path2, size, maxBytes) {
+function requireAttachmentSize(path, size, maxBytes) {
   if (size > maxBytes) {
-    throw new LocalError(`${path2} is too large: ${size} bytes, and attachments are capped at ${maxBytes}.`);
+    throw new LocalError(`${path} is too large: ${size} bytes, and attachments are capped at ${maxBytes}.`);
   }
 }
 function posixDetail(error) {
@@ -1851,19 +929,19 @@ function posixDetail(error) {
   if (code === "EACCES") return "permission denied";
   return error instanceof Error ? error.message : String(error);
 }
-async function setState(ctx, identifier, stateName2) {
+async function setState(ctx, identifier, stateName) {
   const showBody = await ctx.client.get(`/api/v1/issues/${identifier}`);
-  const teamKey = str2((showBody.data["team"] ?? {})["key"]);
+  const teamKey = str((showBody.data["team"] ?? {})["key"]);
   const statesBody = await ctx.client.get(
     `/api/v1/teams/${teamKey}/workflow_states`
   );
-  const wanted = stateName2.toLowerCase();
+  const wanted = stateName.toLowerCase();
   const state = statesBody.data.find(
-    (candidate) => str2(candidate["name"]).toLowerCase() === wanted || str2(candidate["type"]) === wanted
+    (candidate) => str(candidate["name"]).toLowerCase() === wanted || str(candidate["type"]) === wanted
   );
   if (state === void 0) {
-    const names = statesBody.data.map((candidate) => str2(candidate["name"])).join(", ");
-    throw new CommandError(`No workflow state matches "${stateName2}". States: ${names}`);
+    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;
@@ -1894,16 +972,16 @@ function requestedLabelInputs(values) {
   });
 }
 function normalizeLabelName(value) {
-  return str2(value).trim().toLowerCase();
+  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) => str2(team["key"]).toLowerCase() === teamKey.toLowerCase()
+    (team) => str(team["key"]).toLowerCase() === teamKey.toLowerCase()
   );
   if (target === void 0) throw new CommandError(`No team matches key "${teamKey}".`);
-  const teamId = str2(target["id"]);
+  const teamId = str(target["id"]);
   if (teamId === "") throw new CommandError(`team ${teamKey} carried no id`);
   return prepareApplicableLabelIds(ctx, teamId, names);
 }
@@ -1951,7 +1029,7 @@ async function resolveOrCreateApplicableLabel(ctx, catalog, name, teamId) {
   }
 }
 function labelId(label) {
-  const id = str2(label["id"]);
+  const id = str(label["id"]);
   if (id === "") throw new CommandError("the label response carried no id");
   return id;
 }
@@ -1980,7 +1058,7 @@ async function prepareLabelUpdate(ctx, identifier, addInputs, removeInputs) {
   const ids = originalIds.filter((id) => !removed.has(id));
   if (addInputs.length > 0) {
     const team = issue["team"] ?? {};
-    const teamId = str2(team["id"]);
+    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) {
@@ -2014,15 +1092,15 @@ async function fetchIssues(ctx, params, opts) {
     throw new UsageError("--all reads every page from the first \u2014 pass --all or --page, not both");
   }
   if (opts.all === true) {
-    const records6 = await fetchEveryPage(
+    const records5 = await fetchEveryPage(
       (page) => ctx.client.get("/api/v1/issues", { ...params, page })
     );
-    return { records: records6, notice: "" };
+    return { records: records5, notice: "" };
   }
   const body = await ctx.client.get("/api/v1/issues", params);
-  const records5 = body.data;
+  const records4 = body.data;
   const requested = typeof params["page_size"] === "number" ? params["page_size"] : void 0;
-  return { records: records5, notice: notices(body.meta, requested, records5) };
+  return { records: records4, notice: notices(body.meta, requested, records4) };
 }
 function listParams(ctx, opts) {
   if (opts.type !== void 0 && opts.label !== void 0) {
@@ -2115,7 +1193,7 @@ function errorText(error) {
   if (error instanceof HttpError) return `${clean(error.message)} (HTTP ${error.status})`;
   return `cannot reach the API: ${clean(error.message)}`;
 }
-function str2(value) {
+function str(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 
@@ -2124,7 +1202,7 @@ 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 str3(value) {
+function str2(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 function field(row, ...keys) {
@@ -2143,15 +1221,15 @@ function putDate(body, key, raw) {
   if (parsed === null) return body;
   return { ...body, [key]: parsed === "clear" ? null : parsed };
 }
-async function paginatedRead(ctx, path2, params, opts) {
+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 records5 = await fetchEveryPage((page) => ctx.client.get(path2, { ...params, page }));
-    return { records: records5, notice: "" };
+    const records4 = await fetchEveryPage((page) => ctx.client.get(path, { ...params, page }));
+    return { records: records4, notice: "" };
   }
-  const body = await ctx.client.get(path2, params);
+  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) };
 }
@@ -2159,18 +1237,18 @@ 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: records5, notice } = await paginatedRead(ctx, "/api/v1/projects", params, opts);
-  const human = records5.length === 0 ? "No projects.\n" : table(
+  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"],
-    records5.map((project) => [
-      str3(project["id"]),
-      str3(project["state"]) || "-",
-      str3(field(project, "lead", "name")) || "-",
-      str3(project["target_date"]) || "-",
-      str3(project["name"])
+    records4.map((project) => [
+      str2(project["id"]),
+      str2(project["state"]) || "-",
+      str2(field(project, "lead", "name")) || "-",
+      str2(project["target_date"]) || "-",
+      str2(project["name"])
     ])
   );
-  return { json: records5, human, notice };
+  return { json: records4, human, notice };
 }
 async function projectShow(ctx, id) {
   requireSafeId("project", id);
@@ -2191,12 +1269,12 @@ async function projectShow(ctx, id) {
   ];
   const sectionText = sections.filter(([, text]) => text !== null && text !== void 0 && text !== "").map(([title, text]) => `
 ${title}:
-${indent2(String(text))}
+${indent(String(text))}
 `).join("");
   const milestones = Array.isArray(project["milestones"]) ? project["milestones"] : [];
-  const milestoneText = milestones.length === 0 ? "" : "\nMilestones:\n" + milestones.map((milestone) => `  ${(str3(milestone["target_date"]) || "-").padEnd(12)}${clean(milestone["name"])}
+  const milestoneText = milestones.length === 0 ? "" : "\nMilestones:\n" + milestones.map((milestone) => `  ${(str2(milestone["target_date"]) || "-").padEnd(12)}${clean(milestone["name"])}
 `).join("");
-  const human = `${str3(project["id"])} \xB7 ${clean(project["name"])}
+  const human = `${str2(project["id"])} \xB7 ${clean(project["name"])}
 ` + fieldLines + sectionText + milestoneText;
   return { json: project, human };
 }
@@ -2215,7 +1293,7 @@ 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"])} (${str3(project["id"])})
+  return { json: project, human: `Created project ${clean(project["name"])} (${str2(project["id"])})
 ` };
 }
 async function projectUpdate(ctx, id, opts) {
@@ -2225,7 +1303,7 @@ async function projectUpdate(ctx, id, opts) {
     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 ${str3(body.data["id"])}
+  return { json: body.data, human: `Updated project ${str2(body.data["id"])}
 ` };
 }
 async function milestoneList(ctx, project) {
@@ -2235,9 +1313,9 @@ async function milestoneList(ctx, project) {
   const human = body.data.length === 0 ? "No milestones.\n" : table(
     ["ID", "TARGET", "NAME"],
     body.data.map((milestone) => [
-      str3(milestone["id"]),
-      str3(milestone["target_date"]) || "-",
-      str3(milestone["name"])
+      str2(milestone["id"]),
+      str2(milestone["target_date"]) || "-",
+      str2(milestone["name"])
     ])
   );
   return { json: body.data, human };
@@ -2254,26 +1332,26 @@ async function milestoneCreate(ctx, opts) {
   const milestone = response.data;
   return {
     json: milestone,
-    human: `Created milestone ${clean(milestone["name"])} (${str3(milestone["id"])})
+    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: records5, notice } = await paginatedRead(ctx, "/api/v1/documents", params, opts);
-  const human = records5.length === 0 ? "No documents.\n" : table(
+  const { records: records4, notice } = await paginatedRead(ctx, "/api/v1/documents", params, opts);
+  const human = records4.length === 0 ? "No documents.\n" : table(
     ["ID", "UPDATED", "TITLE"],
-    records5.map((doc) => [str3(doc["id"]), str3(doc["updated_at"]) || "-", str3(doc["title"])])
+    records4.map((doc) => [str2(doc["id"]), str2(doc["updated_at"]) || "-", str2(doc["title"])])
   );
-  return { json: records5, human, notice };
+  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 = `${str3(doc["id"])} \xB7 ${clean(doc["title"])}
+  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 };
@@ -2285,7 +1363,7 @@ async function docCreate(ctx, opts) {
   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"])} (${str3(doc["id"])})
+  return { json: doc, human: `Created document ${clean(doc["title"])} (${str2(doc["id"])})
 ` };
 }
 async function docUpdate(ctx, id, opts) {
@@ -2298,7 +1376,7 @@ async function docUpdate(ctx, id, opts) {
     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 ${str3(response.data["id"])}
+  return { json: response.data, human: `Updated document ${str2(response.data["id"])}
 ` };
 }
 async function linkList(ctx, issue) {
@@ -2306,7 +1384,7 @@ async function linkList(ctx, 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) => [str3(link["id"]), str3(link["url"]), str3(link["title"]) || "-"])
+    body.data.map((link) => [str2(link["id"]), str2(link["url"]), str2(link["title"]) || "-"])
   );
   return { json: body.data, human };
 }
@@ -2339,7 +1417,7 @@ async function linkUpdate(ctx, issue, idOrUrl, opts) {
   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() : str3((await findLink(ctx, issue, idOrUrl))["id"]);
+  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}
@@ -2348,19 +1426,19 @@ async function linkUpdate(ctx, issue, idOrUrl, opts) {
 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/${str3(link["id"])}`);
+  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 labelList2(ctx) {
+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) => [
-      str3(label["name"]),
-      str3(label["color"]) || "-",
-      str3(label["issue_count"] ?? 0),
-      str3(label["id"])
+      str2(label["name"]),
+      str2(label["color"]) || "-",
+      str2(label["issue_count"] ?? 0),
+      str2(label["id"])
     ])
   );
   return { json: body.data, human };
@@ -2383,11 +1461,11 @@ async function teamCreate(ctx, opts) {
   }
   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/${str3(team["key"])}/workflow_states`);
-  const human = `Created team ${str3(team["key"])} \u2014 ${clean(team["name"])}
+  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) => [str3(state["name"]), str3(state["type"])])
+    states.data.map((state) => [str2(state["name"]), str2(state["type"])])
   );
   return { json: { ...team, workflow_states: states.data }, human };
 }
@@ -2396,9 +1474,9 @@ async function teamList(ctx) {
   const human = body.data.length === 0 ? "No teams.\n" : table(
     ["KEY", "NAME", "ISSUES", "DEFAULT"],
     body.data.map((team) => [
-      str3(team["key"]),
-      str3(team["name"]),
-      str3(team["issue_count"] ?? 0),
+      str2(team["key"]),
+      str2(team["name"]),
+      str2(team["issue_count"] ?? 0),
       team["is_default"] === true ? "yes" : ""
     ])
   );
@@ -2410,10 +1488,10 @@ async function workflowStates(ctx, team) {
   const human = body.data.length === 0 ? "No workflow states.\n" : table(
     ["NAME", "TYPE", "COLOR", "ID"],
     body.data.map((state) => [
-      str3(state["name"]),
-      str3(state["type"]),
-      str3(state["color"]) || "-",
-      str3(state["id"])
+      str2(state["name"]),
+      str2(state["type"]),
+      str2(state["color"]) || "-",
+      str2(state["id"])
     ])
   );
   return { json: body.data, human };
@@ -2422,7 +1500,7 @@ 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) => [str3(user["name"]), str3(user["email"]), str3(user["id"])])
+    body.data.map((user) => [str2(user["name"]), str2(user["email"]), str2(user["id"])])
   );
   return { json: body.data, human };
 }
@@ -2431,7 +1509,7 @@ async function teamRename(ctx, key, name) {
     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 ${str3(body.data["key"])} to ${clean(body.data["name"])}
+  return { json: body.data, human: `Renamed ${str2(body.data["key"])} to ${clean(body.data["name"])}
 ` };
 }
 async function teamSetDefault(ctx, key) {
@@ -2439,7 +1517,7 @@ async function teamSetDefault(ctx, key) {
   const body = await ctx.client.put(`/api/v1/teams/${encodeURIComponent(key)}/default`, {});
   return {
     json: body.data,
-    human: `${str3(body.data["key"])} is now the default filing target
+    human: `${str2(body.data["key"])} is now the default filing target
 `
   };
 }
@@ -2478,7 +1556,7 @@ async function stateOrder(ctx, ids, opts) {
   const body = await ctx.client.put(`/api/v1/teams/${key}/workflow_states/order`, { state_ids });
   const human = table(
     ["NAME", "TYPE"],
-    body.data.map((state) => [str3(state["name"]), str3(state["type"])])
+    body.data.map((state) => [str2(state["name"]), str2(state["type"])])
   );
   return { json: body.data, human };
 }
@@ -2514,11 +1592,11 @@ async function memberList(ctx) {
   const human = body.data.length === 0 ? "No members.\n" : table(
     ["NAME", "EMAIL", "RANK", "STANDING", "ID"],
     body.data.map((member) => [
-      str3(field(member, "user", "name")),
-      str3(field(member, "user", "email")),
-      str3(member["role"]) || "-",
-      str3(member["standing"]),
-      str3(field(member, "user", "id"))
+      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 };
@@ -2530,7 +1608,7 @@ async function memberAdd(ctx, opts) {
   const body = await ctx.client.post("/api/v1/members", { email: opts.email, role: opts.role });
   return {
     json: body.data,
-    human: `Added ${str3(field(body.data, "user", "email"))} as ${str3(body.data["role"])}
+    human: `Added ${str2(field(body.data, "user", "email"))} as ${str2(body.data["role"])}
 `
   };
 }
@@ -2539,19 +1617,19 @@ async function memberSetRole(ctx, userId, opts) {
     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 = str3(body.data["role"]);
-  const human = rank === "" ? `Revoked the rank for ${str3(field(body.data, "user", "email"))}
-` : `${str3(field(body.data, "user", "email"))} is now ${rank}
+  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, path2) {
-  return attachFile(ctx, path2);
+async function upload(ctx, path) {
+  return attachFile(ctx, path);
 }
-function indent2(text) {
+function indent(text) {
   return cleanMultiline(text).split("\n").map((line) => "  " + line).join("\n");
 }
 
@@ -2592,12 +1670,12 @@ async function toolsSearch(ctx, query, opts) {
 }
 async function toolsDomains(ctx) {
   const body = await operatorRequest(() => ctx.client.get("/api/v1/operator/capabilities/domains"));
-  const domains = records2(body.data, "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) => [str4(domain["domain"]), str4(domain["count"])])
+      domains.map((domain) => [str3(domain["domain"]), str3(domain["count"])])
     )
   };
 }
@@ -2662,7 +1740,7 @@ async function toolShow(ctx, id, opts) {
 }
 async function skillsList(ctx) {
   const body = await operatorRequest(() => ctx.client.get("/api/v1/operator/skills"));
-  const skills = records2(body.data, "skills").map((skill) => ({
+  const skills = records(body.data, "skills").map((skill) => ({
     id: skill["id"],
     title: skill["title"],
     invocation_name: skill["invocation_name"],
@@ -2673,10 +1751,10 @@ async function skillsList(ctx) {
     human: skills.length === 0 ? "No skills are assigned to Operator in this organization.\n" : table(
       ["INVOCATION", "TITLE", "SHA-256", "ID"],
       skills.map((skill) => [
-        str4(skill.invocation_name),
+        str3(skill.invocation_name),
         truncate(skill.title),
-        str4(skill.content_sha256),
-        str4(skill.id)
+        str3(skill.content_sha256),
+        str3(skill.id)
       ])
     )
   };
@@ -2736,7 +1814,7 @@ async function capabilityPage(ctx, params, staleCursor) {
     void 0,
     staleCursor
   );
-  const items = records2(body.data, "capabilities");
+  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;
@@ -2771,14 +1849,14 @@ function explain(error, notFound2, staleCursor) {
 function capabilitiesTable(items, search2) {
   const headers = ["ID", "KIND", "DOMAIN", "SUMMARY"];
   const rows = items.map((item) => [
-    str4(item["id"]),
+    str3(item["id"]),
     kindName(item),
-    str4(item["domain"]),
+    str3(item["domain"]),
     truncate(item["summary"])
   ]);
   const table2 = search2 ? table(
     ["SCORE", ...headers],
-    rows.map((row, index) => [str4(items[index]["score"]), ...row])
+    rows.map((row, index) => [str3(items[index]["score"]), ...row])
   ) : table(headers, rows);
   return table2 + (items.some(needsApproval) ? "\n" + APPROVAL_NOTE : "");
 }
@@ -2792,14 +1870,14 @@ function capabilityDetail(capability, view, schema) {
   const kind = kindName(capability);
   const line = (label, value) => `  ${(label + ":").padEnd(10)}${clean(value)}
 `;
-  const description = cleanMultiline(str4(capability["description"]));
+  const description = cleanMultiline(str3(capability["description"]));
   return `${clean(capability["id"])}
-` + line("Domain", str4(capability["domain"])) + line("Kind", kind === "send" ? "send \u2014 delivered beyond the platform" : kind) + line("Mode", `${str4(capability["mode"])} (effect: ${str4(capability["effect"])})`) + line("Summary", str4(capability["summary"])) + line("Approval", approval(capability)) + (description === "" ? "" : `
+` + 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:
-${indent3(description)}
+${indent2(description)}
 `) + `
 ${view === "input" ? "Input" : "Result"} schema:
-${indent3(cleanMultiline(JSON.stringify(schema, null, 2)))}
+${indent2(cleanMultiline(JSON.stringify(schema, null, 2)))}
 `;
 }
 function needsApproval(capability) {
@@ -2819,7 +1897,7 @@ var SCHEMA_PAGING_FIELDS = /* @__PURE__ */ new Set(["schema", "schema_encoding",
 function withoutSchemaPaging(capability) {
   return Object.fromEntries(Object.entries(capability).filter(([key]) => !SCHEMA_PAGING_FIELDS.has(key)));
 }
-function records2(value, what) {
+function records(value, what) {
   if (!Array.isArray(value) || !value.every(isRecord)) {
     throw new CommandError(`The ${what} response carried no list.`);
   }
@@ -2833,13 +1911,13 @@ function dedupeById(items) {
     return true;
   });
 }
-function indent3(text) {
+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 str4(value) {
+function str3(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 
@@ -3036,11 +2114,11 @@ async function jobChangeSet(ctx, id) {
   if (!isRecord2(body.data)) throw new CommandError("The change set response carried no change set.");
   return {
     ...pick(body.data, CHANGE_SET_FIELDS),
-    actions: records3(body.data["actions"]).map((action) => pick(action, CHANGE_SET_ACTION_FIELDS))
+    actions: records2(body.data["actions"]).map((action) => pick(action, CHANGE_SET_ACTION_FIELDS))
   };
 }
 function jobPeople(job) {
-  const participants = records3(field2(job, "people", "participants"));
+  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]) {
@@ -3111,7 +2189,7 @@ async function jobWatch(ctx, id, opts) {
     after = page.nextAfter;
     job = page.job;
     if (page.hasMore) continue;
-    const state = str5(job["state"]);
+    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));
@@ -3252,13 +2330,13 @@ async function explained(send, why) {
 function jobsTable(jobs) {
   if (jobs.length === 0) return "No Operator jobs.\n";
   const rows = jobs.map((job) => [
-    str5(job["id"]),
-    str5(job["state"]) || "-",
-    str5(job["waiting_on"]) || "-",
-    str5(job["objective_kind"]) || "-",
+    str4(job["id"]),
+    str4(job["state"]) || "-",
+    str4(job["waiting_on"]) || "-",
+    str4(job["objective_kind"]) || "-",
     personName(job["owner"]),
-    str5(field2(job, "plan_step", "issue")) || "-",
-    str5(job["updated_at"]) || "-"
+    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");
@@ -3267,30 +2345,30 @@ function jobsTable(jobs) {
 `).join("");
 }
 function jobDetail(job) {
-  const waitingOn = str5(job["waiting_on"]);
+  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 = records3(field2(job, "people", "participants"));
+  const people = records2(field2(job, "people", "participants"));
   const fields = [
-    ["Kind", str5(job["objective_kind"]) || "-"],
-    ["Role", str5(job["viewer_role"]) || null],
+    ["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", str5(field2(job, "verification", "status")) || null],
+    ["Verification", str4(field2(job, "verification", "status")) || null],
     ["Effects", effectsLine(job["effects"])],
     ["Skill", skillLine(job["skill"])],
     ["Grant", grantLine(job["grant"], people)],
-    ["Created", str5(job["inserted_at"]) || null],
-    ["Updated", str5(job["updated_at"]) || null],
-    ["Workbench", str5(job["url"]) || null]
+    ["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", records3(job["blockers"]), (item) => `${str5(item["kind"])}: ${str5(item["state"])}`) + listSection("Artifacts", records3(job["artifacts"]), (item) => `${str5(item["id"])}  ${str5(item["url"])}`) + peopleSection(people) + listSection(
+  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",
-    records3(job["procedures"]),
-    (procedure) => `${str5(procedure["name"])}  v${str5(procedure["current_version"])}  ${str5(procedure["id"])}`
+    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) {
@@ -3299,16 +2377,16 @@ function labelled(fields, width = 15) {
 }
 function planStepLine(step) {
   if (!isRecord2(step)) return null;
-  return `${str5(step["issue"])} (plan ${str5(step["plan_id"])})`;
+  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 ${str5(plan["version"])} \xB7 instructions v${str5(plan["instruction_version"])} \xB7 ${str5(count)} capabilit${count === 1 ? "y" : "ies"}`;
+  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 = [str5(progress["stage"]), str5(progress["situation"])].filter((part) => part !== "");
+  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 ");
 }
@@ -3317,28 +2395,28 @@ function windowLine(window) {
   const left = duration(window["remaining_ms"]);
   const budget = duration(window["budget_ms"]);
   const sequence = window["sequence"];
-  return `${left ?? "?"} left${budget === null ? "" : ` of ${budget}`} \xB7 ${str5(window["state"])}` + (typeof sequence === "number" ? ` (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 = `${str5(spend["spent_cents"]) || "0"} cents spent`;
+  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) => `${str5(effects[key]) || "0"} ${key}`).join(" \xB7 ");
+  return ["staged", "succeeded", "failed", "unknown"].map((key) => `${str4(effects[key]) || "0"} ${key}`).join(" \xB7 ");
 }
 function skillLine(skill) {
   if (!isRecord2(skill)) return null;
-  return `${str5(skill["title"])} (${str5(skill["invocation_name"])}) \xB7 sha256 ${str5(skill["content_sha256"])} \xB7 pinned ${str5(skill["pinned_at"])}`;
+  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 = str5(grant["approved_at"]);
-  const expiresAt = str5(grant["expires_at"]);
-  return `${str5(grant["status"])} v${str5(grant["version"])} \xB7 approved by ${nameOf(grant["approver_user_id"], people)}` + (approvedAt === "" ? "" : ` at ${approvedAt}`) + ` \xB7 ${expiresAt === "" ? "no expiry" : `expires ${expiresAt}`}`;
+  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 "";
@@ -3347,19 +2425,19 @@ function approvalSection(pending, people) {
   return "\nWaiting for approval. Approve it in the app; the CLI cannot:\n" + labelled([
     [
       "Change set",
-      `${str5(pending["manifest_id"])} v${str5(pending["version"])} \xB7 ${str5(pending["action_count"])} actions \xB7 up to ${str5(pending["max_effect_count"])} effects \xB7 plan version ${str5(pending["plan_version"])}`
+      `${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", str5(pending["digest"]) || null],
+    ["Digest", str4(pending["digest"]) || null],
     ["Approvers", approvers === "" ? canApprove : `${approvers} \xB7 ${canApprove}`],
-    ["Approve at", str5(pending["url"]) || null]
+    ["Approve at", str4(pending["url"]) || null]
   ]);
 }
 function peopleSection(people) {
   if (people.length === 0) return "";
   const rows = people.map((person) => [
-    str5(person["name"]) || "(no name)",
-    str5(person["role"]),
-    str5(person["user_id"])
+    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}
@@ -3368,15 +2446,15 @@ function peopleSection(people) {
 function changesText(id, job, changeSet) {
   if (changeSet === null) return `No pending change set: Operator has proposed nothing for job ${id} yet.
 `;
-  const approvalUrl = str5(job["approval_url"]);
-  const rows = records3(changeSet["actions"]).map((action) => [
-    str5(action["display_order"]) || "-",
-    str5(action["action_type"]),
-    str5(action["action_version"]),
-    str5(action["effect_count"]),
-    (Array.isArray(action["required_capability_ids"]) ? action["required_capability_ids"].map(str5).join(", ") : "") || "-",
-    str5(action["digest"]),
-    str5(action["id"])
+  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("");
@@ -3384,14 +2462,14 @@ function changesText(id, job, changeSet) {
 ` + labelled([
     [
       "Change set",
-      `${str5(changeSet["manifest_id"])} v${str5(changeSet["version"])} \xB7 plan version ${str5(changeSet["plan_version"])} \xB7 up to ${str5(changeSet["max_effect_count"])} effects`
+      `${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", str5(changeSet["digest"]) || null],
-    approvalUrl === "" ? ["Workbench", str5(job["url"]) || null] : ["Approve at", approvalUrl]
+    ["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) ? str5(entry["name"]) || str5(entry["user_id"]) : "-";
+  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(
@@ -3499,7 +2577,7 @@ function plural(count, noun) {
 function uniqueById(jobs) {
   const seen = /* @__PURE__ */ new Set();
   return jobs.filter((job) => {
-    const id = str5(job["id"]);
+    const id = str4(job["id"]);
     if (seen.has(id)) return false;
     seen.add(id);
     return true;
@@ -3507,12 +2585,12 @@ function uniqueById(jobs) {
 }
 function personName(person) {
   if (!isRecord2(person)) return "-";
-  return str5(person["name"]) || str5(person["user_id"]) || "-";
+  return str4(person["name"]) || str4(person["user_id"]) || "-";
 }
 function nameOf(userId, people) {
-  const id = str5(userId);
+  const id = str4(userId);
   const person = people.find((candidate) => candidate["user_id"] === id);
-  return (person === void 0 ? "" : str5(person["name"])) || id || "?";
+  return (person === void 0 ? "" : str4(person["name"])) || id || "?";
 }
 function duration(ms) {
   if (typeof ms !== "number" || !Number.isFinite(ms)) return null;
@@ -3538,13 +2616,13 @@ function field2(record, ...keys) {
   }
   return current ?? null;
 }
-function records3(value) {
+function records2(value) {
   return Array.isArray(value) ? value.filter(isRecord2) : [];
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function str5(value) {
+function str4(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 
@@ -3589,9 +2667,9 @@ function outcomeUnknown(why, write2) {
     `Outcome unknown: ${why}, so ${write2.mayHave}. It is not retried; check ${write2.check} before trying again.`
   );
 }
-async function sendOnce(ctx, path2, body, write2) {
+async function sendOnce(ctx, path, body, write2) {
   try {
-    return await ctx.client.post(path2, body, { actor: false });
+    return await ctx.client.post(path, body, { actor: false });
   } catch (error) {
     if (error instanceof TransportError) {
       if (neverSent(error)) {
@@ -3730,14 +2808,14 @@ function startedText(job) {
 async function run(ctx, request, opts = {}) {
   const job = await startRun(ctx, request);
   if (opts.watch !== true) return { json: job, human: startedText(job) };
-  const json2 = opts.json === true;
-  if (!json2) opts.onLine?.(startedText(job) + "\n");
+  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: json2,
-      onLine: json2 ? void 0 : opts.onLine,
+      collectEvents: json,
+      onLine: json ? void 0 : opts.onLine,
       signal: opts.signal,
       sleep: opts.sleep
     });
@@ -3829,18 +2907,18 @@ function resolveTextSources(sources) {
   }
   return resolved;
 }
-function readFileOption(flag, path2) {
-  if (path2 === STDIN_PATH) {
+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(path2, flag, DOCUMENT_LIMIT);
+    checkReadable(path, flag, DOCUMENT_LIMIT);
   }
-  return readTextFile(path2, flag, DOCUMENT_LIMIT);
+  return readTextFile(path, flag, DOCUMENT_LIMIT);
 }
-function readTextFile(path2, option, limit = TEXT_LIMIT) {
-  if (path2 === STDIN_PATH) {
+function readTextFile(path, option, limit = TEXT_LIMIT) {
+  if (path === STDIN_PATH) {
     let piped;
     try {
       piped = readFileSync2(0);
@@ -3852,10 +2930,10 @@ function readTextFile(path2, option, limit = TEXT_LIMIT) {
     }
     return decodeUtf8(piped, `${option} -`);
   }
-  const flag = `${option} ${path2}`;
+  const flag = `${option} ${path}`;
   let bytes;
   try {
-    bytes = readFileSync2(path2);
+    bytes = readFileSync2(path);
   } catch (error) {
     throw new UsageError(`${flag}: ${describe(error)}`);
   }
@@ -3872,11 +2950,11 @@ function decodeUtf8(bytes, flag) {
 function oversize(what, limit) {
   return `${what}: over ${limit.bytes / 1e6} MB \u2014 ${limit.why}`;
 }
-function checkReadable(path2, option, limit = TEXT_LIMIT) {
-  const flag = `${option} ${path2}`;
+function checkReadable(path, option, limit = TEXT_LIMIT) {
+  const flag = `${option} ${path}`;
   let stats3;
   try {
-    stats3 = statSync3(path2);
+    stats3 = statSync3(path);
   } catch (error) {
     throw new UsageError(`${flag}: ${describe(error)}`);
   }
@@ -4076,7 +3154,7 @@ async function procedureSave(ctx, jobId, name) {
     return {
       json: pick2(data, ["id", "url"]),
       human: `${saved}, but it can't be read back as you.
-` + labelled([["Workbench", str6(data["url"]) || null]])
+` + labelled([["Workbench", str5(data["url"]) || null]])
     };
   }
   const procedure = procedureJson(data);
@@ -4139,18 +3217,18 @@ async function startProcedureRun(ctx, request) {
     return {
       json: pick2(data, ["id", "url"]),
       human: `${started}, but it can't be read back as you.
-` + labelled([["Workbench", str6(data["url"]) || null]]) + "\n" + RUN_NOTE
+` + labelled([["Workbench", str5(data["url"]) || null]]) + "\n" + RUN_NOTE
     };
   }
   const job = withheld(data);
-  const waitingOn = str6(job["waiting_on"]);
+  const waitingOn = str5(job["waiting_on"]);
   return {
     json: job,
     human: `${started}.
 ` + labelled([
-      ["State", str6(job["state"]) + (waitingOn === "" ? "" : ` \xB7 waiting on ${waitingOn}`)],
-      ["Workbench", str6(job["url"]) || null],
-      ["Approve at", str6(job["approval_url"]) || null]
+      ["State", str5(job["state"]) + (waitingOn === "" ? "" : ` \xB7 waiting on ${waitingOn}`)],
+      ["Workbench", str5(job["url"]) || null],
+      ["Approve at", str5(job["approval_url"]) || null]
     ]) + "\n" + RUN_NOTE
   };
 }
@@ -4192,16 +3270,16 @@ function jsonValue(text, what) {
     throw new UsageError(`${what}: not valid JSON after := (${firstLine(error)}); quote a string as name=value`);
   }
 }
-function readParamsFile(path2) {
-  const text = readFileOption("--params-file", path2);
+function readParamsFile(path) {
+  const text = readFileOption("--params-file", path);
   let parsed;
   try {
     parsed = JSON.parse(text);
   } catch (error) {
-    throw new UsageError(`--params-file ${path2}: not valid JSON (${firstLine(error)})`);
+    throw new UsageError(`--params-file ${path}: not valid JSON (${firstLine(error)})`);
   }
   if (!isRecord4(parsed)) {
-    throw new UsageError(`--params-file ${path2}: the parameters are one JSON object of names and values`);
+    throw new UsageError(`--params-file ${path}: the parameters are one JSON object of names and values`);
   }
   return parsed;
 }
@@ -4213,24 +3291,24 @@ function bareId(value, flag) {
 function procedureJson(data) {
   const procedure = pick2(data, PROCEDURE_FIELDS);
   if ("versions" in procedure) {
-    procedure["versions"] = records4(procedure["versions"]).map((version2) => pick2(version2, PROCEDURE_VERSION_FIELDS));
+    procedure["versions"] = records3(procedure["versions"]).map((version2) => pick2(version2, PROCEDURE_VERSION_FIELDS));
   }
   return procedure;
 }
 function procedureDetail(procedure) {
   const current = procedure["current_version"];
-  const versions = records4(procedure["versions"]).map(
-    (version2) => `  ${clean(`v${str6(version2["version"])}${version2["version"] === current ? " (current)" : ""}  ${str6(version2["inserted_at"])}  recipe ${str6(version2["recipe_digest"])}`)}
+  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 ${str6(procedure["job_id"])}`],
-    ["Workbench", str6(procedure["job_url"]) || null],
-    ["Created", str6(procedure["inserted_at"]) || null],
-    ["Updated", str6(procedure["updated_at"]) || null]
+    ["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) {
@@ -4238,7 +3316,7 @@ function parametersSection(schema) {
   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(str6) : [];
+  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";
@@ -4249,18 +3327,18 @@ function parametersSection(schema) {
   return "\nParameters a run takes (JSON schema):\n" + lines + needs;
 }
 function list2(value) {
-  return (Array.isArray(value) ? value.map(str6).join(", ") : "") || "none";
+  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 records4(value) {
+function records3(value) {
   return Array.isArray(value) ? value.filter(isRecord4) : [];
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function str6(value) {
+function str5(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 function firstLine(error) {
@@ -4273,6 +3351,9 @@ 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)) {
@@ -4311,8 +3392,8 @@ function jsonSafe(value) {
 function firstLine2(error) {
   return (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
 }
-function readPlanFile(path2, flag = "--file") {
-  return parsePlanDocument(readFileOption(flag, path2), path2);
+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");
@@ -4325,7 +3406,7 @@ async function planCreate(ctx, plan, opts) {
     throw explainMissing(error, `no team ${team} here, or this Harness server has no plan API yet`);
   }
   const created = body.data;
-  const id = str7(created["id"]);
+  const id = str6(created["id"]);
   return {
     json: created,
     human: `Created plan ${clean(id)} (${clean(created["status"]) || "held"})
@@ -4335,13 +3416,44 @@ 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) {
-  requirePlanId(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) {
-  requirePlanId(id);
+  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;
@@ -4350,12 +3462,12 @@ async function planEdit(ctx, id, edits) {
     human: `Updated plan ${clean(id)}
 
 ` + planDetail(plan) + (held ? `
-Release it again to run the held steps: ${invokedName()} plan release ${clean(id)}
+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) {
-  requirePlanId(id);
+  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;
@@ -4370,7 +3482,7 @@ async function planRelease(ctx, id, opts) {
   };
 }
 async function planHold(ctx, id) {
-  requirePlanId(id);
+  requirePlanRef(id);
   const plan = await planRequest(id, () => ctx.client.post(`/api/v1/plans/${id}/hold`));
   return {
     json: plan,
@@ -4383,25 +3495,41 @@ async function gateSet(ctx, issue, gate, satisfied) {
   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);
-  const list3 = await readConditions(ctx, issue, expert);
-  const target = findGate(list3, issue, wanted, expert);
-  const id = str7(target["id"]);
+  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);
+    throw await explainNotGateOwner(ctx, error, target, issue, satisfied, list3 !== null);
   }
-  const others = list3.filter((condition) => condition["id"] !== id && condition["satisfied"] !== true).length;
+  const others = list3?.filter((condition) => condition["id"] !== id && condition["satisfied"] !== true).length ?? 0;
   let tail = "";
-  if (satisfied && expert) {
+  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) {
+  } 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(target["label"])}" on ${issue}${tail}
+    human: `${satisfied ? "Satisfied" : "Un-satisfied"} gate "${clean(label)}" on ${issue}${tail}
 `
   };
 }
@@ -4435,8 +3563,10 @@ async function readConditions(ctx, issue, expert) {
   if (!Array.isArray(conditions)) throw new CommandError("The conditions response carried no list.");
   return conditions.filter(isRecord5);
 }
-function requirePlanId(id) {
-  if (!isUuid(id)) throw new UsageError(`not a plan id: ${id} (expected the plan's UUID)`);
+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);
@@ -4445,18 +3575,21 @@ async function planRequest(id, send) {
   try {
     return (await send()).data;
   } catch (error) {
-    throw explainMissing(error, `no plan ${id} in this organization, or this Harness server has no plan API yet`);
+    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) {
+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 (currentOwner !== null && !isRecord5(currentOwner)) {
+  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"]);
@@ -4470,26 +3603,20 @@ async function explainNotGateOwner(ctx, error, gate, issue, satisfied) {
   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) => str7(condition["label"]).trim();
-var gateKey = (condition) => str7(condition["key"]);
+var gateLabel = (condition) => str6(condition["label"]).trim();
+var gateKey = (condition) => str6(condition["key"]);
 function exactMatches(conditions, wanted) {
-  const id = isUuid(wanted) ? wanted.toLowerCase() : null;
-  return conditions.filter((condition) => {
-    if (id !== null && str7(condition["id"]).toLowerCase() === id) return true;
-    if (condition["kind"] !== "gate") return false;
-    const key = gateKey(condition);
-    return key !== "" && key === (id ?? wanted) || gateLabel(condition) === 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(", ");
-  const unnameable = matches.map((condition) => str7(condition["id"])).filter((id) => exactMatches(conditions, id).length !== 1).map((id) => clean(id));
-  const caveat = unnameable.length === 0 ? "" : ` (${unnameable.join(", ")} ${unnameable.length === 1 ? "is" : "are"} also another gate's key or label, so ${unnameable.length === 1 ? "it" : "they"} cannot be named by id)`;
   return new CommandError(
-    `several gates on ${issue} match "${wanted}": ${listed} \u2014 pass the condition id of the one you mean${caveat}`
+    `several gates on ${issue} match "${wanted}": ${listed} \u2014 pass the condition id of the one you mean`
   );
 }
 function findGate(conditions, issue, wanted, expert = false) {
@@ -4497,11 +3624,6 @@ function findGate(conditions, issue, wanted, expert = false) {
   if (exact.length > 1) throw ambiguous(conditions, issue, wanted, exact);
   if (exact.length === 1) {
     const only = exact[0];
-    if (only["kind"] !== "gate") {
-      throw new CommandError(
-        `condition ${wanted} on ${issue} is a ${clean(only["kind"])} condition \u2014 only a gate is satisfied by hand`
-      );
-    }
     return only;
   }
   const gates = conditions.filter((condition) => condition["kind"] === "gate");
@@ -4511,7 +3633,6 @@ function findGate(conditions, issue, wanted, expert = false) {
   );
   if (loose.length > 1) throw ambiguous(conditions, issue, wanted, loose);
   if (loose.length === 1) return loose[0];
-  if (isUuid(wanted)) throw new CommandError(`No condition ${wanted} on ${issue}${expert ? " that you own" : ""}.`);
   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"}`);
@@ -4522,7 +3643,7 @@ function findGate(conditions, issue, wanted, expert = false) {
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function str7(value) {
+function str6(value) {
   return value === null || value === void 0 ? "" : String(value);
 }
 
@@ -4543,265 +3664,7 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/core/credentials.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, isAbsolute, join as join2 } from "path";
-function defaultCredentialsPath(env = process.env) {
-  const xdg = env["XDG_CONFIG_HOME"];
-  const base = xdg !== void 0 && xdg !== "" && isAbsolute(xdg) ? xdg : join2(homedir(), ".config");
-  return join2(base, "harness", "credentials.json");
-}
-function readCredentials(path2) {
-  try {
-    const parsed = JSON.parse(readFileSync3(path2, "utf8"));
-    if (typeof parsed === "object" && parsed !== null) {
-      const { url, token } = parsed;
-      if (typeof url === "string" && typeof token === "string") return { url, token };
-    }
-  } catch {
-  }
-  return null;
-}
-var uniqueCounter = 0;
-function writeCredentials(path2, url, token) {
-  mkdirSync2(dirname2(path2), { recursive: true });
-  const tempPath = `${path2}.${process.pid}.${++uniqueCounter}.tmp`;
-  try {
-    writeFileSync2(tempPath, "", { mode: 384 });
-    chmodSync2(tempPath, 384);
-    writeFileSync2(tempPath, JSON.stringify({ url, token }));
-    renameSync2(tempPath, path2);
-  } finally {
-    rmSync2(tempPath, { force: true });
-  }
-}
-function deleteCredentials(path2) {
-  rmSync2(path2, { force: true });
-}
-
-// src/core/repo-config.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, parse } from "path";
-var CONFIG_RELATIVE_PATH = join3(".harness-cli", "config.json");
-function findRepoConfig(startDir = process.cwd()) {
-  let dir = startDir;
-  const { root } = parse(startDir);
-  for (; ; ) {
-    const candidate = join3(dir, CONFIG_RELATIVE_PATH);
-    if (existsSync(candidate)) {
-      return readRepoConfig(candidate);
-    }
-    if (dir === root) return { config: null, warnings: [] };
-    dir = dirname3(dir);
-  }
-}
-function readRepoConfig(path2) {
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync4(path2, "utf8"));
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return { config: null, warnings: [`harness: ignoring malformed ${path2} (${detail})`] };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return { config: null, warnings: [`harness: ignoring ${path2} \u2014 expected a JSON object`] };
-  }
-  const record = parsed;
-  const config = { path: path2 };
-  const warnings = [];
-  for (const field3 of ["team", "url", "org"]) {
-    const value = record[field3];
-    if (value === void 0) continue;
-    if (typeof value === "string" && value.trim() !== "") {
-      config[field3] = value.trim();
-    } else {
-      warnings.push(`harness: ignoring "${field3}" in ${path2} \u2014 expected a non-empty string`);
-    }
-  }
-  return { config, warnings };
-}
-function trustedHostsPath(env = process.env) {
-  const xdg = env["XDG_CONFIG_HOME"];
-  const base = xdg !== void 0 && xdg !== "" && isAbsolute2(xdg) ? xdg : join3(homedir2(), ".config");
-  return join3(base, "harness", "trusted-hosts.json");
-}
-function readTrustedHosts(env) {
-  try {
-    const parsed = JSON.parse(readFileSync4(trustedHostsPath(env), "utf8"));
-    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed["hosts"])) {
-      return parsed["hosts"].filter(
-        (host) => typeof host === "string"
-      );
-    }
-  } catch {
-  }
-  return [];
-}
-function isHostTrusted(baseUrl, env) {
-  return readTrustedHosts(env).includes(baseUrl);
-}
-function trustHost(baseUrl, env) {
-  const hosts = readTrustedHosts(env);
-  if (hosts.includes(baseUrl)) return;
-  const path2 = trustedHostsPath(env);
-  mkdirSync3(dirname3(path2), { recursive: true });
-  writeFileSync3(path2, JSON.stringify({ hosts: [...hosts, baseUrl] }, null, 2) + "\n");
-}
-
-// src/core/config.ts
-import { homedir as homedir3, tmpdir } from "os";
-import { isAbsolute as isAbsolute3, join as join4 } from "path";
-var DEFAULT_BASE_URL = "https://harness.infra.one";
-function resolveConfig(env = process.env, credentialsPath, repo) {
-  let warnings = [];
-  if (repo === void 0) {
-    const lookup = findRepoConfig();
-    repo = lookup.config;
-    warnings = lookup.warnings;
-  }
-  const path2 = credentialsPath ?? defaultCredentialsPath(env);
-  const stored = readCredentials(path2);
-  const envUrl = blankToNull(env["HARNESS_API_URL"]);
-  const envToken = blankToNull(env["HARNESS_API_TOKEN"]);
-  const repoUrl = repo?.url?.replace(/\/+$/, "") ?? null;
-  let rawUrl;
-  let hostSource;
-  if (envUrl !== null) {
-    rawUrl = envUrl;
-    hostSource = "env";
-  } else if (envToken !== null) {
-    if (repoUrl !== null && normalize(repoUrl) !== normalize(DEFAULT_BASE_URL)) {
-      return {
-        kind: "error",
-        message: `this repo's config (${repo?.path}) targets ${repoUrl}, but HARNESS_API_TOKEN only travels to the host the environment names \u2014 set HARNESS_API_URL explicitly to pair them`,
-        warnings
-      };
-    }
-    rawUrl = DEFAULT_BASE_URL;
-    hostSource = "default";
-  } else if (repoUrl !== null) {
-    rawUrl = repoUrl;
-    hostSource = "repo-config";
-  } else if (stored !== null) {
-    rawUrl = stored.url;
-    hostSource = "stored-login";
-  } else {
-    rawUrl = DEFAULT_BASE_URL;
-    hostSource = "default";
-  }
-  const validated = validateBaseUrl(rawUrl);
-  if (!validated.ok) return { kind: "error", message: validated.message, warnings };
-  const baseUrl = rawUrl.replace(/\/+$/, "");
-  let token;
-  if (envToken !== null) {
-    token = envToken;
-  } else if (stored !== null && normalize(stored.url) !== null && normalize(stored.url) === normalize(baseUrl)) {
-    token = stored.token;
-  } else {
-    const result = { kind: "needs-login", baseUrl, hostSource, warnings };
-    if (hostSource === "repo-config" && repo?.path !== void 0) result.repoConfigPath = repo.path;
-    return result;
-  }
-  return {
-    kind: "ok",
-    config: {
-      baseUrl,
-      token,
-      actor: blankToNull(env["HARNESS_ACTOR"]),
-      // The committed team is the fallback: the environment (and, above it,
-      // the --team flag at the command layer) stays authoritative.
-      team: blankToNull(env["HARNESS_TEAM"]) ?? repo?.team ?? null,
-      cacheDir: resolveCacheDir(env),
-      hostSource
-    },
-    warnings
-  };
-}
-function resolveCacheDir(env = process.env) {
-  return absolute(env["HARNESS_CACHE_DIR"]) ?? join4(resolveCacheHome(env), "harness", "attachments");
-}
-function absolute(value) {
-  return value !== void 0 && value !== "" && isAbsolute3(value) ? value : null;
-}
-function resolveCacheHome(env = process.env) {
-  return absolute(env["XDG_CACHE_HOME"]) ?? join4(homedir3() || tmpdir(), ".cache");
-}
-function normalize(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return null;
-  }
-  const port = parsed.port !== "" ? parsed.port : parsed.protocol === "https:" ? "443" : parsed.protocol === "http:" ? "80" : "";
-  return JSON.stringify([parsed.protocol, parsed.hostname, port, parsed.pathname.replace(/\/+$/, "")]);
-}
-function validateBaseUrl(baseUrl) {
-  let parsed;
-  try {
-    parsed = new URL(baseUrl);
-  } catch {
-    return { ok: false, message: `HARNESS_API_URL must be an http(s) URL with a host, got: ${baseUrl}` };
-  }
-  if (parsed.username !== "" || parsed.password !== "") {
-    return { ok: false, message: "HARNESS_API_URL must not embed credentials (user:pass@) \u2014 use HARNESS_API_TOKEN" };
-  }
-  if (parsed.search !== "" || parsed.hash !== "") {
-    return { ok: false, message: `HARNESS_API_URL must not carry a query or fragment, got: ${baseUrl}` };
-  }
-  if (parsed.protocol === "https:" && parsed.hostname !== "") return { ok: true };
-  if (parsed.protocol === "http:") {
-    if (["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname)) return { ok: true };
-    return {
-      ok: false,
-      message: `refusing plain-http HARNESS_API_URL (${baseUrl}) \u2014 the API token would travel in cleartext. Use https, or http against localhost only.`
-    };
-  }
-  return { ok: false, message: `HARNESS_API_URL must be an http(s) URL with a host, got: ${baseUrl}` };
-}
-function loginHelp(baseUrl, name = invokedName()) {
-  return `Not signed in to ${baseUrl}.
-
-Interactively, in a terminal (not from inside an agent \u2014 the browser
-tab needs someone to see it):
-
-    ${name} login
-
-For agents and CI, mint an API token (admin \u2192 API tokens) with the
-harness:read scope \u2014 plus harness:write only where the workflow
-creates or closes \u2014 set an expiry, and export it:
-
-    export HARNESS_API_TOKEN=aone_...
-
-An outside expert uses the pxc_ credential minted in their expert view:
-export it the same way, or paste it into \`${name} login --no-browser\`.
-`;
-}
-function blankToNull(value) {
-  if (value === void 0 || value.trim() === "") return null;
-  return value;
-}
-
 export {
-  HttpError,
-  UpgradeRequiredError,
-  TransportError,
-  UsageError,
-  LocalError,
-  CommandError,
-  EXPERT_ASSIGNMENTS_PATH,
-  isExpertToken,
-  EXPERT_LAPSED,
-  explainExpertRefusal,
-  SESSION_PATH,
-  isLoginCredential,
-  Client,
-  clean,
-  json,
-  expertSummary,
-  errorDetails,
   MAX_IDEMPOTENCY_KEY_BYTES,
   IDEMPOTENCY_KEY_FORMAT,
   requireIdentifiers,
@@ -4850,7 +3713,7 @@ export {
   linkAdd,
   linkUpdate,
   linkRm,
-  labelList2 as labelList,
+  labelList,
   labelCreate,
   teamCreate,
   teamList,
@@ -4913,26 +3776,18 @@ export {
   PLAN_EXECUTORS,
   CONDITION_KINDS,
   GATE_OWNER_ROLES,
+  PLAN_STATUSES,
+  PLAN_LIST_MAX_LIMIT,
   readPlanFile,
   planCreate,
+  requirePlanListArgs,
+  planList,
   planShow,
   planEdit,
   planRelease,
   planHold,
   gateSet,
   conditionList,
-  requirePlanId,
-  assignments,
-  defaultCredentialsPath,
-  readCredentials,
-  writeCredentials,
-  deleteCredentials,
-  findRepoConfig,
-  isHostTrusted,
-  trustHost,
-  DEFAULT_BASE_URL,
-  resolveConfig,
-  resolveCacheHome,
-  validateBaseUrl,
-  loginHelp
+  requirePlanRef,
+  assignments
 };