@allocator-one/infraone 0.0.0-stage → 1.17.0

package/dist/server-TRXBTJSA.js

@@ -0,0 +1,1080 @@
+#!/usr/bin/env node
+import {
+  ACTIVITY_MAX_LIMIT,
+  BUDGET_MAX_DOLLARS,
+  CONDITION_KINDS,
+  GATE_OWNER_ROLES,
+  IDEMPOTENCY_KEY_FORMAT,
+  JOBS_MAX_LIMIT,
+  JOB_STATES,
+  JOB_STATUS_ALIASES,
+  MAX_IDEMPOTENCY_KEY_BYTES,
+  MCP_SURFACE,
+  OUTCOME_MAX_CHARACTERS,
+  PLAN_EXECUTORS,
+  PLAN_LIST_MAX_LIMIT,
+  PLAN_STATUSES,
+  RELATION_CREATE_TYPES,
+  RELATION_UPDATE_TYPES,
+  STEER_MAX_CHARACTERS,
+  activity,
+  archive,
+  assignments,
+  blocked,
+  close,
+  comment,
+  comments,
+  conditionList,
+  create,
+  deleteComment,
+  dep,
+  docCreate,
+  docList,
+  docShow,
+  docUpdate,
+  editComment,
+  gateSet,
+  jobCancel,
+  jobContinue,
+  jobPause,
+  jobShow,
+  jobSteer,
+  jobsList,
+  labelCreate,
+  labelDelete,
+  labelList,
+  labelUpdate,
+  linkAdd,
+  linkList,
+  linkRm,
+  linkUpdate,
+  list,
+  memberAdd,
+  memberList,
+  memberSetRole,
+  milestoneCreate,
+  milestoneList,
+  planCreate,
+  planEdit,
+  planHold,
+  planList,
+  planRelease,
+  planShow,
+  prepareRun,
+  procedureRun,
+  procedureSave,
+  procedureShow,
+  projectCreate,
+  projectList,
+  projectShow,
+  projectUpdate,
+  ready,
+  relationAdd,
+  relationList,
+  relationRm,
+  relationUpdate,
+  search,
+  show,
+  skillsList,
+  startRun,
+  stateAdd,
+  stateDelete,
+  stateOrder,
+  stateUpdate,
+  stats,
+  teamCreate,
+  teamList,
+  teamRename,
+  teamSetDefault,
+  toolsList,
+  toolsSearch,
+  update,
+  upload,
+  userList,
+  workflowStates
+} from "./chunk-CEEQW6ZV.js";
+import {
+  Client,
+  HttpError,
+  TransportError,
+  UsageError,
+  errorDetails,
+  explainExpertRefusal,
+  resolveConfig
+} from "./chunk-BHBEIT5I.js";
+import {
+  CLI_VERSION,
+  invokedName,
+  named
+} from "./chunk-5THYIKLW.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var NeedsLoginError = class extends Error {
+};
+function context() {
+  const resolved = resolveConfig();
+  for (const warning of resolved.warnings) process.stderr.write(named(warning + "\n"));
+  if (resolved.kind === "error") throw new NeedsLoginError(resolved.message);
+  if (resolved.kind === "needs-login") {
+    throw new NeedsLoginError(
+      `Not signed in to ${resolved.baseUrl}${resolved.org === void 0 ? "" : ` for organization ${resolved.org}`}. Run \`${invokedName()} login\` in a terminal (or set HARNESS_API_TOKEN for headless use) \u2014 the MCP server never opens a browser itself.`
+    );
+  }
+  return { client: new Client(resolved.config), config: resolved.config };
+}
+function toolError(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+async function run(work) {
+  let token = "";
+  try {
+    const ctx = context();
+    token = ctx.config.token;
+    const output = await work(ctx);
+    const content = [{ type: "text", text: JSON.stringify(output.json) }];
+    if (output.notice !== void 0 && output.notice !== "") {
+      content.push({ type: "text", text: named(output.notice.trimEnd()) });
+    }
+    if (output.partial === true) {
+      content.push({ type: "text", text: "partial failure \u2014 inspect the JSON entries for per-item errors" });
+      return { content, isError: true };
+    }
+    return { content };
+  } catch (caught) {
+    const error = explainExpertRefusal(caught, token);
+    if (error instanceof NeedsLoginError) return toolError(error.message);
+    if (error instanceof HttpError) {
+      return toolError(named(`${error.message} (HTTP ${error.status})${errorDetails(error.body)}`));
+    }
+    if (error instanceof TransportError) return toolError(`cannot reach the API: ${error.message}`);
+    if (error instanceof Error) return toolError(named(error.message));
+    throw error;
+  }
+}
+var page = {
+  limit: z.number().int().positive().optional().describe("page size (server may cap it)"),
+  page: z.number().int().positive().optional().describe("page number, 1-based"),
+  all: z.boolean().optional().describe("follow every page")
+};
+var identifier = z.string().describe("issue identifier, e.g. IO-123");
+var commentId = z.string().uuid().describe("comment UUID from issue_show or comment_list");
+var dateField = z.string().optional().describe('YYYY-MM-DD; "" clears the date');
+var planCondition = z.object({
+  kind: z.enum(CONDITION_KINDS).optional().describe("not_before, gate or event; optional with gate"),
+  not_before: z.string().optional().describe("not_before: an ISO 8601 UTC instant"),
+  gate: z.string().optional().describe("shorthand for kind gate with this key; the label defaults to it, e.g. finance-sign-off"),
+  key: z.string().optional().describe("gate: a stable lowercase slug (a-z, 0-9 and -), unique among the step's gates; gate_set takes it"),
+  label: z.string().optional().describe("gate: what a person ticks, e.g. Finance sign-off; defaults to the key"),
+  owner: z.string().nullable().optional().describe(
+    `gate: who ticks it. role:<role> (${GATE_OWNER_ROLES.join(", ")}), user:<id or email> (a member who can use Operator) or expert:<email> (an outside expert, never a member's email). Only the owner ticks an owned gate, and nobody names an owner they would hold themselves (owner_is_actor). null or absent: no owner`
+  ),
+  event: z.string().optional().describe("event: deal_stage_changed, opportunity_stage_changed, form_submitted or investment_executed"),
+  subject_id: z.string().optional().describe("event: the record the event is about (one you can read)"),
+  target_id: z.string().optional().describe("event: the stage or status a stage change must reach")
+}).passthrough();
+var planIssueFields = {
+  title: z.string(),
+  description: z.string().optional().describe("an Operator step's description is its instruction (required for one)"),
+  design: z.string().optional(),
+  notes: z.string().optional(),
+  acceptance_criteria: z.string().optional(),
+  priority: z.number().int().optional().describe("0 none, 1 urgent, 2 high, 3 medium, 4 low"),
+  estimate: z.number().optional(),
+  due_date: z.string().optional().describe("YYYY-MM-DD"),
+  assignee: z.string().optional().describe("email or user id; never on an Operator step"),
+  label_ids: z.array(z.string()).optional()
+};
+var planStep = z.object({
+  ...planIssueFields,
+  key: z.string().describe("unique in the plan; other steps refer to this step by it"),
+  parent: z.string().optional().describe("key of the step that contains this one; the root when absent"),
+  blocked_by: z.array(z.string()).optional().describe("keys of the steps this one waits for"),
+  executor: z.enum(PLAN_EXECUTORS).optional().describe("none (a person, the default) or operator"),
+  team: z.string().optional().describe("team key for a person's step; Operator steps go to the Operator team"),
+  conditions: z.array(planCondition).optional().describe("wait conditions: all must hold before the step is ready")
+}).passthrough();
+var planDocument = z.object({
+  ...planIssueFields,
+  parent: z.string().optional().describe("an existing issue to file the root under, e.g. IO-12"),
+  retry_budget: z.number().int().min(0).optional().describe("retries per failed Operator step (default 2)"),
+  spend_budget_cents: z.number().int().min(0).nullable().optional().describe("needed to release a plan with Operator steps"),
+  steps: z.array(planStep).min(1).describe(
+    "with the root, at most the organization's max plan steps (default 1000, at most 2000), and at most 100 Operator steps"
+  )
+}).passthrough();
+var planId = z.string().describe("the plan's UUID, or its root issue's identifier (e.g. FR-1, any casing): plan_list or issue_show's plan.root");
+var planStepEdit = z.object({
+  step: z.string().optional().describe("the step's key; give this or issue"),
+  issue: z.string().optional().describe("the step's issue identifier; give this or step"),
+  executor: z.enum(PLAN_EXECUTORS).optional().describe("none hands the step to a person"),
+  key: z.string().nullable().optional().describe("the step's new key")
+}).passthrough();
+var idempotencyKey = z.string().min(1).max(MAX_IDEMPOTENCY_KEY_BYTES).regex(IDEMPOTENCY_KEY_FORMAT, "must use printable ASCII without leading or trailing spaces");
+var OPERATOR_APPROVAL_NOTE = "Approval happens in the app: give a person the approval_url (pending_approval.url on job_show); no tool approves a change set. By reference only, never the objective's text.";
+var OPERATOR_JOB_TOOLS = [
+  {
+    name: "jobs_list",
+    description: "List the Operator jobs the caller sees in the workbench, newest first: state, waiting_on (approval, person, reconciliation, verification or delivery), objective_kind, owner, plan step, window, and the workbench url and approval_url. " + OPERATOR_APPROVAL_NOTE + " Pages by cursor; all follows every page, and a second text item says when older jobs exist.",
+    readOnly: true,
+    shape: {
+      status: z.array(z.enum([...JOB_STATES, ...JOB_STATUS_ALIASES])).min(1).optional().describe("job states, or the aliases open (not done), waiting and done"),
+      mine: z.boolean().optional().describe("only jobs the caller owns"),
+      limit: z.number().int().min(1).max(JOBS_MAX_LIMIT).optional().describe("jobs per page (default 20)"),
+      all: z.boolean().optional().describe("follow every page")
+    },
+    handler: (ctx, args) => jobsList(ctx, {
+      status: args["status"] === void 0 ? void 0 : args["status"].join(","),
+      mine: args["mine"],
+      limit: args["limit"],
+      all: args["all"]
+    })
+  },
+  {
+    name: "job_show",
+    description: "One Operator job by reference: state and waiting_on, plan version, progress (stage, situation, needs_viewer), window (remaining and budget, in ms), spend in cents, blockers, pending_approval with its url, grant, verification status, effect counts, artifact links, pinned skill identity, people, saved procedures and viewer_can. " + OPERATOR_APPROVAL_NOTE + " Poll it to follow a job: it has ended when state is completed, failed or cancelled, and a person has to act exactly when waiting_on is set; a job paused with no waiting_on resumes by itself.",
+    readOnly: true,
+    shape: { id: z.string().uuid().describe("Operator job UUID, from jobs_list") },
+    handler: (ctx, args) => jobShow(ctx, args["id"])
+  }
+];
+var OPERATOR_CONTROL_NOTE = "Not idempotent: never retry it on your own; when an error says the outcome is unknown (a timeout, a dropped connection or a 5xx), read the job with job_show before trying again. Approving stays in the app: no tool approves a change set. Returns the job as job_show does, by reference only.";
+var jobId = z.string().uuid().describe("Operator job UUID, from jobs_list");
+var OPERATOR_CONTROL_TOOLS = [
+  {
+    name: "job_steer",
+    description: "Steer an Operator job as Steer does in the app: posts the instruction in the job's room, attributed to the caller. The job's owner and collaborators may steer, wherever the app offers it (not a finished, failed or awaiting-approval job). Work the instruction changes needs a fresh approval: earlier approvals stop applying to it. Steering a running job stops its current run so it can take the instruction. " + OPERATOR_CONTROL_NOTE,
+    readOnly: false,
+    idempotent: false,
+    shape: {
+      id: jobId,
+      instruction: z.string().min(1).describe(
+        `what to change, in plain language: 1 to ${STEER_MAX_CHARACTERS} characters once trimmed`
+      )
+    },
+    handler: (ctx, args) => jobSteer(ctx, args["id"], args["instruction"])
+  },
+  {
+    name: "job_cancel",
+    description: "Cancel an Operator job as Cancel does in the app; only the job's execution principal may. It cannot be undone, but committed effects stay committed: the job's effects still count them, and staged ones that never ran count as unknown. " + OPERATOR_CONTROL_NOTE,
+    readOnly: false,
+    destructive: true,
+    idempotent: false,
+    shape: { id: jobId },
+    handler: (ctx, args) => jobCancel(ctx, args["id"])
+  },
+  {
+    name: "job_pause",
+    description: "Pause a running Operator job as Pause does in the app; only the job's execution principal may. Holds it for a person without resetting its active-time budget; continuing it runs it again. " + OPERATOR_CONTROL_NOTE,
+    readOnly: false,
+    idempotent: false,
+    shape: { id: jobId },
+    handler: (ctx, args) => jobPause(ctx, args["id"])
+  }
+];
+var OPERATOR_RUN_TOOLS = [
+  {
+    name: "job_start",
+    description: `Start an Operator job from an outcome, as Run as job does in Chat Mode in the app: the request is posted, attributed to the caller, in a new organization chat of theirs, and Operator takes it from there under the caller's own current rights. Returns job_id, state, workbench_url and, when a change set already awaits approval, approval_url. Approval happens in the app: give a person the approval_url; this tool never approves anything, and no tool does. Each call starts another job, so never call it again to "retry": not after a timeout, a dropped connection or a 5xx either. An "Outcome unknown" error means a job may have been started; look for it with jobs_list (mine) before calling again. Only the organization's admins may pass a budget. Follow the job with job_show.`,
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    shape: {
+      outcome: z.string().describe(
+        `what the job should achieve, in plain language: 1 to ${OUTCOME_MAX_CHARACTERS} characters once trimmed`
+      ),
+      budget: z.number().positive().max(BUDGET_MAX_DOLLARS).optional().describe(
+        `the job's budget in US dollars, at most two decimals, up to ${BUDGET_MAX_DOLLARS}; only the organization's admins may pass one`
+      ),
+      skill: z.string().optional().describe("an Operator skill's invocation name, like /summarize-lps (skills_list names them)")
+    },
+    handler: async (ctx, args) => {
+      const request = prepareRun(args["outcome"], {
+        budget: args["budget"] === void 0 ? void 0 : String(args["budget"]),
+        skill: args["skill"]
+      }, MCP_SURFACE);
+      const job = await startRun(ctx, request, MCP_SURFACE);
+      return {
+        json: {
+          job_id: job.job_id,
+          state: job.state,
+          workbench_url: job.workbench_url,
+          ...job.approval_url === null ? {} : { approval_url: job.approval_url }
+        },
+        human: `Started Operator job ${job.job_id}.`
+      };
+    }
+  }
+];
+var NOT_IDEMPOTENT = 'Not idempotent: never retry it automatically, not after a timeout or a 5xx either. An "Outcome unknown" error may have landed and says what to check before calling again; only "cannot reach the API" means the request never reached the server, so nothing changed.';
+var OPERATOR_LIFECYCLE_TOOLS = [
+  {
+    name: "job_continue",
+    description: "Continue an Operator job, as Continue does in the app: opens a new audited window for a job that ran out of time or waits on a person, or retries a failed run or verification. Only the job's execution principal may. Returns the job as job_show does. Approval still happens in the app, at its approval_url. " + NOT_IDEMPOTENT,
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    shape: { id: z.string().uuid().describe("Operator job UUID, from jobs_list") },
+    handler: (ctx, args) => jobContinue(ctx, args["id"])
+  },
+  {
+    name: "job_changes",
+    description: "An Operator job's latest change set by reference: its manifest id, version, status, digest, plan version, maximum effect count, and each action's type, version, order, effect count, required capability ids and digest; never values or targets. change_set is null while the job has proposed nothing. Beside it, the job's state, waiting_on, workbench url and approval_url: review and approve in the app, at that link.",
+    readOnly: true,
+    shape: { id: z.string().uuid().describe("Operator job UUID, from jobs_list") },
+    handler: (ctx, args) => jobShow(ctx, args["id"], { changes: true })
+  },
+  {
+    name: "procedure_save",
+    description: "Save a completed Operator job whose work was verified as a versioned procedure, as Save procedure does in the app. Only the job's owner can. Returns the procedure as procedure_show does, or only its id and url when it can't be read back. Saving again saves another procedure. " + NOT_IDEMPOTENT,
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    shape: {
+      job_id: z.string().uuid().describe("Operator job UUID, from jobs_list"),
+      name: z.string().trim().min(1).describe("the procedure's name; trimmed and cut to 200 characters")
+    },
+    handler: (ctx, args) => procedureSave(ctx, args["job_id"], args["name"])
+  },
+  {
+    name: "procedure_show",
+    description: "One saved Operator procedure: its name, source job_id and job_url (the app), current_version, each version's recipe_digest, capability_ids and action_roster, and the parameter_schema a run of the current version takes (scoped_inputs.required naming contact_reconciliation means a run needs group_id and source_resource_id). Never a version's recipe or anything the saved job read.",
+    readOnly: true,
+    shape: { id: z.string().uuid().describe("Operator procedure UUID, from job_show's procedures") },
+    handler: (ctx, args) => procedureShow(ctx, args["id"])
+  },
+  {
+    name: "procedure_run",
+    description: "Run a saved Operator procedure as a new job, as Rerun does in the app: fresh inputs, the caller's own current rights, and a change set that needs its own approval in the app. Nothing of the saved job carries over. Returns the new job as job_show does, or only its id and url when it can't be read back; give a person its approval_url. " + NOT_IDEMPOTENT,
+    readOnly: false,
+    destructive: false,
+    idempotent: false,
+    shape: {
+      id: z.string().uuid().describe("Operator procedure UUID"),
+      version: z.number().int().min(1).optional().describe("the version expected to be current; the run is refused if it no longer is (default: the current one)"),
+      parameters: z.record(z.unknown()).optional().describe("values for the procedure's parameter_schema (procedure_show), default {}"),
+      group_id: z.string().min(1).optional().describe("the contact group to reconcile, when scoped_inputs require it"),
+      source_resource_id: z.string().min(1).optional().describe("the uploaded file to reconcile against, when scoped_inputs require it")
+    },
+    handler: (ctx, args) => procedureRun(ctx, args["id"], {
+      version: args["version"],
+      parameters: args["parameters"],
+      group: args["group_id"],
+      source: args["source_resource_id"]
+    })
+  }
+];
+var TOOLS = [
+  // ── Issues ──
+  {
+    name: "issue_list",
+    description: "List issues with filters. ready=true \u2192 unblocked open issues, each with agent_step (true when it is filed in the Operator team, where plan steps Operator runs live: only the plan driver claims those, and a claim refusal is the authority); blocked=true \u2192 issues waiting on a blocker.",
+    readOnly: true,
+    shape: {
+      ...page,
+      ready: z.boolean().optional(),
+      blocked: z.boolean().optional(),
+      status: z.enum(["open", "in_progress", "closed"]).optional(),
+      assignee: z.string().optional().describe('me, a user id, an email, or a full name; "" for unassigned'),
+      created_by: z.string().optional().describe("me or a creator user id"),
+      involved: z.literal("me").optional().describe("issues created by, assigned to, or mentioning the caller"),
+      priority: z.enum(["urgent", "high", "medium", "low", "none"]).optional(),
+      label: z.string().optional(),
+      type: z.enum(["task", "bug", "feature", "epic"]).optional(),
+      search: z.string().optional(),
+      team: z.string().optional(),
+      parent: z.string().optional().describe("list children of this epic"),
+      scope: z.enum(["all", "archived"]).optional()
+    },
+    handler: (ctx, args) => {
+      if (args["ready"] === true && args["blocked"] === true) {
+        throw new UsageError("ready and blocked are mutually exclusive \u2014 pass one, not both");
+      }
+      const opts = { ...args, createdBy: args["created_by"] };
+      if (args["ready"] === true) return ready(ctx, opts);
+      if (args["blocked"] === true) return blocked(ctx, opts);
+      return list(ctx, opts);
+    }
+  },
+  {
+    name: "issue_search",
+    description: "Search issues by meaning: ranked results across a lexical and a semantic signal, so describing a problem in your own words finds issues that share none of them. Pass the question as asked \u2014 plain language works better than keywords. An exact identifier always ranks first. Returns at most 20 results, no pagination; use issue_list with search for paginated lexical filtering.",
+    readOnly: true,
+    shape: {
+      query: z.string().describe("the question or phrase to search for"),
+      limit: z.number().int().optional().describe("maximum results (default 10, capped at 20)")
+    },
+    handler: (ctx, args) => {
+      const limit = args["limit"] === void 0 ? {} : { limit: args["limit"] };
+      return search(ctx, [String(args["query"])], limit);
+    }
+  },
+  {
+    name: "issue_show",
+    description: "Full issue detail: fields, relations, children, comments. blockers gives each unresolved blocker's state_type and archived flag: only a completed blocker resolves, so a cancelled or archived one still blocks. waiting_on_condition and conditions say which wait conditions (not_before, gate, event) still hold it; tick a gate with gate_set. plan is the plan governing the issue (the nearest rooted at it or an ancestor), or null: its id, root identifier (which the plan tools take), status, held, the revision number it runs, in_revision (whether that revision lists the issue: an Operator step outside it waits for plan_release, a person's step does not) and the issue's executor. images=true downloads attached images to the local cache and includes their paths as local_images.",
+    readOnly: true,
+    shape: { id: identifier, images: z.boolean().optional() },
+    handler: (ctx, args) => show(ctx, args["id"], { images: args["images"] === true })
+  },
+  {
+    name: "activity_list",
+    description: "Mixed issue activity: comments, creation, state and assignee changes, wait-condition events, and field changes (priority, labels, parent, title, description, archived) with from/to values. actor_label, when set, is the agent or CLI label a write was made under. Returns the newest page unless all=true.",
+    readOnly: true,
+    shape: {
+      id: identifier,
+      limit: z.number().int().min(1).max(ACTIVITY_MAX_LIMIT).optional().describe(`entries per page (default 20, max ${ACTIVITY_MAX_LIMIT})`),
+      all: z.boolean().optional().describe("follow cursors through all older activity")
+    },
+    handler: (ctx, args) => activity(ctx, args["id"], args)
+  },
+  {
+    name: "issue_create",
+    description: "Create an issue. type becomes a type/ label.",
+    readOnly: false,
+    shape: {
+      title: z.string(),
+      team: z.string().optional().describe("team key; defaults to HARNESS_TEAM"),
+      description: z.string().optional(),
+      design: z.string().optional(),
+      notes: z.string().optional(),
+      acceptance_criteria: z.string().optional(),
+      type: z.enum(["task", "bug", "feature", "epic"]).optional(),
+      priority: z.enum(["urgent", "high", "medium", "low", "none"]).optional(),
+      due_date: dateField,
+      parent: z.string().optional(),
+      assignee: z.string().optional(),
+      labels: z.array(z.string()).optional(),
+      idempotency_key: idempotencyKey.optional().describe("reuse the same printable-ASCII key when deliberately retrying this create")
+    },
+    handler: (ctx, args) => create(ctx, {
+      ...args,
+      acceptance: args["acceptance_criteria"],
+      dueDate: args["due_date"],
+      label: args["labels"],
+      idempotencyKey: args["idempotency_key"]
+    })
+  },
+  {
+    name: "issue_update",
+    description: "Update issue fields or workflow state. To take an issue, use issue_claim instead of assignee.",
+    readOnly: false,
+    shape: {
+      id: identifier,
+      title: z.string().optional(),
+      description: z.string().optional(),
+      design: z.string().optional(),
+      notes: z.string().optional().describe("replaces the notes"),
+      append_notes: z.string().optional().describe("appends to the notes"),
+      acceptance_criteria: z.string().optional(),
+      priority: z.enum(["urgent", "high", "medium", "low", "none"]).optional(),
+      due_date: dateField,
+      state: z.string().optional().describe("workflow state by name or type"),
+      parent: z.string().optional(),
+      assignee: z.string().optional().describe('"" unassigns'),
+      add_labels: z.array(z.string()).optional().describe("label names or ids to add without replacing existing labels"),
+      remove_labels: z.array(z.string()).optional().describe("attached label names or ids to remove without replacing others")
+    },
+    handler: (ctx, args) => update(ctx, args["id"], {
+      ...args,
+      acceptance: args["acceptance_criteria"],
+      appendNotes: args["append_notes"],
+      dueDate: args["due_date"],
+      addLabel: args["add_labels"],
+      removeLabel: args["remove_labels"]
+    })
+  },
+  {
+    name: "issue_claim",
+    description: "Atomically claim an issue: assigns it and moves it to the team's first started state. A conflict names its reason: someone else holds it, or it is not claimable (e.g. agent_step, waiting_on_condition). A refusal that comes from a plan (agent_step, plan_not_released, not_in_plan_revision, edited_since_release) names the plan by its root: the release that fixes it when it is the one plan governing the issue (plan_release takes the root), the nearest plan to look at when several do. A person never claims an agent_step, an Operator step.",
+    readOnly: false,
+    shape: { id: identifier },
+    handler: (ctx, args) => update(ctx, args["id"], { claim: true })
+  },
+  {
+    name: "issue_close",
+    description: "Close issues. Set duplicate_of for one source issue to close it as a duplicate; it cannot be combined with cancel. The result lists newly unblocked issues \u2014 surface them. still_blocking lists the dependents a cancelled or duplicate-closed issue still blocks: only completing releases them.",
+    readOnly: false,
+    shape: {
+      ids: z.array(identifier).min(1),
+      reason: z.string().optional().describe("why it is done, e.g. the commit hash"),
+      cancel: z.boolean().optional().describe("close as canceled instead of completed; incompatible with duplicate_of"),
+      duplicate_of: identifier.optional().describe("canonical issue; requires exactly one source id and is incompatible with cancel")
+    },
+    handler: (ctx, args) => close(ctx, args["ids"], {
+      reason: args["reason"],
+      cancel: args["cancel"],
+      duplicateOf: args["duplicate_of"]
+    })
+  },
+  {
+    name: "issue_comment",
+    description: "Comment on an issue. Mentions resolve server-side and notify the mentioned people.",
+    readOnly: false,
+    shape: {
+      id: identifier,
+      body: z.string(),
+      mentions: z.array(z.string()).optional()
+    },
+    handler: (ctx, args) => comment(ctx, args["id"], [args["body"]], args["mentions"] ?? [])
+  },
+  {
+    name: "issue_comment_edit",
+    description: "Edit one of your issue comments within its edit window.",
+    readOnly: false,
+    shape: {
+      id: identifier,
+      comment_id: commentId,
+      body: z.string().min(1).refine((body) => body.trim() !== "", "comment body must not be blank")
+    },
+    handler: (ctx, args) => editComment(ctx, args["id"], args["comment_id"], [args["body"]])
+  },
+  {
+    name: "issue_comment_delete",
+    description: "Delete one of your issue comments.",
+    readOnly: false,
+    shape: {
+      id: identifier,
+      comment_id: commentId
+    },
+    handler: (ctx, args) => deleteComment(ctx, args["id"], args["comment_id"])
+  },
+  {
+    name: "issue_archive",
+    description: "Archive issues (or restore them with restore=true). Archived issues show up under scope=archived.",
+    readOnly: false,
+    shape: { ids: z.array(identifier).min(1), restore: z.boolean().optional() },
+    handler: (ctx, args) => archive(ctx, args["ids"], { restore: args["restore"] === true })
+  },
+  {
+    name: "comment_list",
+    description: "An issue's complete comment thread, oldest first. Follows every older page; pagination failures return an error, not a partial thread.",
+    readOnly: true,
+    shape: { id: identifier },
+    handler: (ctx, args) => comments(ctx, args["id"])
+  },
+  // ── Relations ──
+  {
+    name: "relation_add",
+    description: "Add a blocking dependency: blocker blocks issue.",
+    readOnly: false,
+    shape: { issue: identifier, blocker: identifier },
+    handler: (ctx, args) => dep(ctx, "add", args["issue"], args["blocker"])
+  },
+  {
+    name: "relation_rm",
+    description: "Remove a blocking dependency.",
+    readOnly: false,
+    shape: { issue: identifier, blocker: identifier },
+    handler: (ctx, args) => dep(ctx, "rm", args["issue"], args["blocker"])
+  },
+  {
+    name: "relation_list",
+    description: "List every typed relation on an issue, including stable relation ids.",
+    readOnly: true,
+    shape: { issue: identifier },
+    handler: (ctx, args) => relationList(ctx, args["issue"])
+  },
+  {
+    name: "relation_create",
+    description: "Create a typed relation between two issues.",
+    readOnly: false,
+    shape: {
+      issue: identifier,
+      related_issue: identifier,
+      type: z.enum(RELATION_CREATE_TYPES)
+    },
+    handler: (ctx, args) => relationAdd(ctx, args["issue"], args["related_issue"], args["type"])
+  },
+  {
+    name: "relation_update",
+    description: "Change a relation's direction, resolving it by relation id or unique related issue.",
+    readOnly: false,
+    shape: {
+      issue: identifier,
+      id_or_issue: z.string(),
+      type: z.enum(RELATION_UPDATE_TYPES)
+    },
+    handler: (ctx, args) => relationUpdate(ctx, args["issue"], args["id_or_issue"], args["type"])
+  },
+  {
+    name: "relation_delete",
+    description: "Remove a typed relation by relation id or unique related issue.",
+    readOnly: false,
+    shape: { issue: identifier, id_or_issue: z.string() },
+    handler: (ctx, args) => relationRm(ctx, args["issue"], args["id_or_issue"])
+  },
+  // ── Links (URLs on an issue) ──
+  {
+    name: "link_list",
+    description: "URLs attached to an issue (distinct from blocking relations).",
+    readOnly: true,
+    shape: { issue: identifier },
+    handler: (ctx, args) => linkList(ctx, args["issue"])
+  },
+  {
+    name: "link_add",
+    description: "Attach a URL to an issue.",
+    readOnly: false,
+    shape: { issue: identifier, url: z.string(), title: z.string().optional() },
+    handler: (ctx, args) => linkAdd(ctx, args["issue"], args["url"], args["title"])
+  },
+  {
+    name: "link_update",
+    description: "Edit a link by link id or exact URL.",
+    readOnly: false,
+    shape: {
+      issue: identifier,
+      id_or_url: z.string(),
+      change: z.union([
+        z.object({ url: z.string(), title: z.string().optional() }),
+        z.object({ title: z.string(), url: z.string().optional() })
+      ])
+    },
+    handler: (ctx, args) => linkUpdate(ctx, args["issue"], args["id_or_url"], args["change"])
+  },
+  {
+    name: "link_rm",
+    description: "Remove a link from an issue, by link id or exact URL.",
+    readOnly: false,
+    shape: { issue: identifier, id_or_url: z.string() },
+    handler: (ctx, args) => linkRm(ctx, args["issue"], args["id_or_url"])
+  },
+  // ── Projects ──
+  {
+    name: "project_list",
+    description: "List projects.",
+    readOnly: true,
+    shape: { ...page, search: z.string().optional(), state: z.string().optional() },
+    handler: (ctx, args) => projectList(ctx, args)
+  },
+  {
+    name: "project_show",
+    description: "Project detail including milestones.",
+    readOnly: true,
+    shape: { id: z.string() },
+    handler: (ctx, args) => projectShow(ctx, args["id"])
+  },
+  {
+    name: "project_create",
+    description: "Create a project.",
+    readOnly: false,
+    shape: {
+      name: z.string(),
+      description: z.string().optional(),
+      summary: z.string().optional(),
+      state: z.string().optional(),
+      lead_id: z.string().optional(),
+      start_date: dateField,
+      target_date: dateField
+    },
+    handler: (ctx, args) => projectCreate(ctx, {
+      ...args,
+      lead: args["lead_id"],
+      startDate: args["start_date"],
+      targetDate: args["target_date"]
+    })
+  },
+  {
+    name: "project_update",
+    description: "Update a project.",
+    readOnly: false,
+    shape: {
+      id: z.string(),
+      name: z.string().optional(),
+      description: z.string().optional(),
+      summary: z.string().optional(),
+      state: z.string().optional(),
+      lead_id: z.string().optional(),
+      start_date: dateField,
+      target_date: dateField
+    },
+    handler: (ctx, args) => projectUpdate(ctx, args["id"], {
+      ...args,
+      lead: args["lead_id"],
+      startDate: args["start_date"],
+      targetDate: args["target_date"]
+    })
+  },
+  // ── Milestones ──
+  {
+    name: "milestone_list",
+    description: "List a project's milestones.",
+    readOnly: true,
+    shape: { project_id: z.string() },
+    handler: (ctx, args) => milestoneList(ctx, args["project_id"])
+  },
+  {
+    name: "milestone_create",
+    description: "Create a milestone in a project.",
+    readOnly: false,
+    shape: {
+      project_id: z.string(),
+      name: z.string(),
+      description: z.string().optional(),
+      target_date: dateField
+    },
+    handler: (ctx, args) => milestoneCreate(ctx, { project: args["project_id"], name: args["name"], description: args["description"], targetDate: args["target_date"] })
+  },
+  // ── Documents ──
+  {
+    name: "document_list",
+    description: "List documents.",
+    readOnly: true,
+    shape: { ...page, search: z.string().optional() },
+    handler: (ctx, args) => docList(ctx, args)
+  },
+  {
+    name: "document_show",
+    description: "Document detail including full content.",
+    readOnly: true,
+    shape: { id: z.string() },
+    handler: (ctx, args) => docShow(ctx, args["id"])
+  },
+  {
+    name: "document_create",
+    description: "Create a document.",
+    readOnly: false,
+    shape: { title: z.string(), content: z.string().optional(), project_id: z.string().optional() },
+    handler: (ctx, args) => docCreate(ctx, { title: args["title"], content: args["content"], project: args["project_id"] })
+  },
+  {
+    name: "document_update",
+    description: "Update a document.",
+    readOnly: false,
+    shape: {
+      id: z.string(),
+      title: z.string().optional(),
+      content: z.string().optional(),
+      project_id: z.string().optional()
+    },
+    handler: (ctx, args) => docUpdate(ctx, args["id"], { title: args["title"], content: args["content"], project: args["project_id"] })
+  },
+  // ── Labels, teams, states, users, stats ──
+  {
+    name: "label_list",
+    description: "List labels.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => labelList(ctx)
+  },
+  {
+    name: "label_create",
+    description: "Create a label.",
+    readOnly: false,
+    shape: { name: z.string(), color: z.string().optional() },
+    handler: (ctx, args) => labelCreate(ctx, args["name"], args["color"])
+  },
+  {
+    name: "team_list",
+    description: "List teams.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => teamList(ctx)
+  },
+  {
+    name: "team_create",
+    description: "Create a team. The key becomes the identifier prefix for the team's issues (upcased, letters/digits, letter first); numbering starts above any issues already carrying that prefix. The server seeds the default workflow states, so the team is immediately usable.",
+    readOnly: false,
+    shape: {
+      key: z.string().describe("team key, e.g. IOS"),
+      name: z.string().describe("display name")
+    },
+    handler: (ctx, args) => teamCreate(ctx, { key: args["key"], name: args["name"] })
+  },
+  {
+    name: "workflow_states",
+    description: "A team's workflow states (name + type).",
+    readOnly: true,
+    shape: { team: z.string().optional().describe("team key; defaults to HARNESS_TEAM") },
+    handler: (ctx, args) => workflowStates(ctx, args["team"])
+  },
+  {
+    name: "team_rename",
+    description: "Rename a team. The key is create-only \u2014 it is the identifier prefix of every issue filed under the team \u2014 so this changes the display name only. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      key: z.string().describe("team key, e.g. IOS"),
+      name: z.string().describe("new display name")
+    },
+    handler: (ctx, args) => teamRename(ctx, args["key"], args["name"])
+  },
+  {
+    name: "team_set_default",
+    description: "Make a team the organization's default filing target, clearing the previous default. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: { key: z.string().describe("team key") },
+    handler: (ctx, args) => teamSetDefault(ctx, args["key"])
+  },
+  {
+    name: "state_add",
+    description: "Add a workflow state to a team, appended after its existing states. Type is one of backlog, unstarted, started, completed, canceled. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      name: z.string().describe("display name"),
+      type: z.string().describe("backlog | unstarted | started | completed | canceled"),
+      color: z.string().optional().describe("swatch name"),
+      team: z.string().optional().describe("team key; defaults to HARNESS_TEAM")
+    },
+    handler: (ctx, args) => stateAdd(ctx, { team: args["team"], name: args["name"], type: args["type"], color: args["color"] })
+  },
+  {
+    name: "state_update",
+    description: "Rename, retype or recolor one of a team's workflow states. Pass at least one of name, type, color. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      id: z.string().describe("workflow state id (from workflow_states)"),
+      name: z.string().optional(),
+      type: z.string().optional().describe("backlog | unstarted | started | completed | canceled"),
+      color: z.string().optional().describe("swatch name"),
+      team: z.string().optional().describe("team key; defaults to HARNESS_TEAM")
+    },
+    handler: (ctx, args) => stateUpdate(ctx, args["id"], {
+      team: args["team"],
+      name: args["name"],
+      type: args["type"],
+      color: args["color"]
+    })
+  },
+  {
+    name: "state_order",
+    description: "Reorder a team's workflow states. Send EVERY state id, in the order you want them \u2014 a partial list is refused rather than half-applied, because renumbering part of the order would collide with the positions it left alone. Call workflow_states first to get the ids. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      state_ids: z.string().describe("comma-separated state ids, in the desired order \u2014 all of them"),
+      team: z.string().optional().describe("team key; defaults to HARNESS_TEAM")
+    },
+    handler: (ctx, args) => stateOrder(ctx, args["state_ids"], { team: args["team"] })
+  },
+  {
+    name: "state_delete",
+    description: "Delete a workflow state. Refused while issues still sit in it \u2014 move them out first. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      id: z.string().describe("workflow state id"),
+      team: z.string().optional().describe("team key; defaults to HARNESS_TEAM")
+    },
+    // `yes` is the CLI's typo guard for a human at a shell; an MCP call is
+    // already an explicit, named request to delete this id.
+    handler: (ctx, args) => stateDelete(ctx, args["id"], { team: args["team"], yes: true })
+  },
+  {
+    name: "label_update",
+    description: "Rename or recolor a label. Color is a swatch name (purple, green, red, yellow, pink, blue, orange, gray) or a hex code. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      id: z.string().describe("label id (from label_list)"),
+      name: z.string().optional(),
+      color: z.string().optional().describe("swatch name or hex code")
+    },
+    handler: (ctx, args) => labelUpdate(ctx, args["id"], { name: args["name"], color: args["color"] })
+  },
+  {
+    name: "label_delete",
+    description: "Delete a label. Refused while issues still carry it, or while other labels are nested under it. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: { id: z.string().describe("label id") },
+    handler: (ctx, args) => labelDelete(ctx, args["id"], { yes: true })
+  },
+  {
+    name: "member_list",
+    description: "Who can reach THIS organization's tracker, and at what rank \u2014 its grant holders plus its own admins. Not the same as user_list, which is the deployment-wide assignee picker and never lists a collaborator. Each entry carries both role (the granted rank, absent for an org admin) and standing (what that rank resolves to). Needs Harness administrator standing.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => memberList(ctx)
+  },
+  {
+    name: "member_add",
+    description: "Grant a tracker rank to an existing account by email, minting the organization membership if they have none. The account must already exist. Refused if they are already on the roster \u2014 use member_set_role to change a rank. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      email: z.string().describe("address of an existing account"),
+      role: z.string().describe("admin | staff | collaborator")
+    },
+    handler: (ctx, args) => memberAdd(ctx, { email: args["email"], role: args["role"] })
+  },
+  {
+    name: "member_set_role",
+    description: "Change or revoke a member's tracker rank; 'none' revokes. Refused when it would remove the organization's last Harness administrator. Needs Harness administrator standing.",
+    readOnly: false,
+    shape: {
+      user_id: z.string().describe("the member's user id (from member_list)"),
+      role: z.string().describe("admin | staff | collaborator | none")
+    },
+    handler: (ctx, args) => memberSetRole(ctx, args["user_id"], { role: args["role"] })
+  },
+  {
+    name: "user_list",
+    description: "List users (for assignee resolution).",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => userList(ctx)
+  },
+  {
+    name: "stats",
+    description: "Per-team and total issue counts.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => stats(ctx)
+  },
+  // ── Plans and gates ──
+  {
+    name: "plan_list",
+    description: `A team's plans, newest first: each plan's id, root (its root issue's identifier, which the other plan tools take in place of the id), title, status, held, revision (null before its first release), released_at and inserted_at. One list of at most ${PLAN_LIST_MAX_LIMIT}, no pages: a second text item says when it came back full. issue_show's plan names the plan an issue belongs to.`,
+    readOnly: true,
+    shape: {
+      team: z.string().optional().describe("team key whose issues root the plans; defaults to HARNESS_TEAM"),
+      status: z.enum(PLAN_STATUSES).optional().describe("only plans in this status"),
+      limit: z.number().int().min(1).max(PLAN_LIST_MAX_LIMIT).optional().describe("maximum plans (default 50)")
+    },
+    handler: (ctx, args) => planList(ctx, { team: args["team"], status: args["status"], limit: args["limit"] })
+  },
+  {
+    name: "plan_create",
+    description: "Create a plan: a root issue and its steps, created in one transaction or not at all, and held until a person releases it (plan_release). Steps refer to each other by key: parent (containment) and blocked_by (dependencies). executor operator files a step in the organization's Operator team, where only the plan driver claims it; a person's step goes to its team (or the plan's). conditions are wait conditions (not_before, gate, event); a gate may carry a key (gate: <key> is shorthand) and an owner, who alone ticks it. An invalid plan writes nothing and the error lists every violation by step key; too_many_steps says which cap the plan is over: the organization's max plan steps (default 1000, which a Harness admin raises in Harness settings \u2192 Plans, up to 2000) or the fixed 100 Operator steps of the delegated grant. Reuse idempotency_key when retrying. Once released, the changes an Operator step proposes need a person's approval in the app, as plan_release says.",
+    readOnly: false,
+    shape: {
+      team: z.string().optional().describe("team key for the root and people's steps; defaults to HARNESS_TEAM"),
+      plan: planDocument.describe("the root's fields plus steps"),
+      idempotency_key: idempotencyKey.optional().describe("reuse the same printable-ASCII key when deliberately retrying this create")
+    },
+    handler: (ctx, args) => planCreate(ctx, args["plan"], { team: args["team"], idempotencyKey: args["idempotency_key"] })
+  },
+  {
+    name: "plan_show",
+    description: "A plan, by its id or its root issue's identifier: status, budgets, current revision and spend estimate, and its whole tree root first: each step's key, executor, parent, state, ready flag, held flag (changed since the release: only an Operator step waits for the next release, a person's stays ready), in_revision, wait conditions (a gate's key and owner) and waiting_for (each open gate's owner and holders, the people who can tick it: [] when nobody can, null when unowned or not known), plus the blocks edges between steps.",
+    readOnly: true,
+    shape: { id: planId },
+    handler: (ctx, args) => planShow(ctx, args["id"])
+  },
+  {
+    name: "plan_edit",
+    description: "Change step executors and keys (each step named by its key or issue identifier) and the plan's budgets. Editing a released Operator step, or handing one to a person, holds it until the plan is released again; a person's step stays workable, and the next release takes the change in. A budget edit needs the plan held. Descriptions, parents and edges are edited with issue_update and relation_add/relation_rm; conditions are set at plan_create, and gate_set ticks a gate. Once released, the changes an Operator step proposes need a person's approval in the app, as plan_release says.",
+    readOnly: false,
+    shape: {
+      id: planId,
+      steps: z.array(planStepEdit).optional(),
+      retry_budget: z.number().int().min(0).optional(),
+      spend_budget_cents: z.number().int().min(0).nullable().optional().describe("null clears the budget")
+    },
+    handler: (ctx, args) => {
+      const { id, ...edits } = args;
+      return planEdit(ctx, id, edits);
+    }
+  },
+  {
+    name: "plan_release",
+    description: "Release a held plan (or one that needs attention) as the caller: freezes its next revision, which takes in the steps added or edited since the last one, and lets its ready steps run. A plan over a step cap is refused with too_many_steps, naming the cap as plan_create does. A plan with Operator steps needs a spend budget and the caller's right to run Operator; collaborators join its plan room. Each Operator step runs as a job (jobs_list names its plan_step), and the changes a job proposes need a person's approval in the app: give them the job's approval_url. No tool approves.",
+    readOnly: false,
+    shape: {
+      id: planId,
+      collaborators: z.array(z.string()).max(20).optional().describe("people of this organization, by id or email"),
+      retry_budget: z.number().int().min(0).optional(),
+      spend_budget_cents: z.number().int().min(0).nullable().optional().describe("null clears the budget")
+    },
+    handler: (ctx, args) => planRelease(ctx, args["id"], {
+      collaborators: args["collaborators"],
+      retryBudget: args["retry_budget"],
+      spendBudgetCents: args["spend_budget_cents"]
+    })
+  },
+  {
+    name: "plan_hold",
+    description: "Pause every step of a plan: none is ready until it is released again.",
+    readOnly: false,
+    shape: { id: planId },
+    handler: (ctx, args) => planHold(ctx, args["id"])
+  },
+  {
+    name: "gate_set",
+    description: "Satisfy (satisfied true) or un-satisfy (false) a gate wait condition on an issue, found by its key, label or condition id (condition_list and issue_show list conditions). A condition id writes directly, without a staff-only conditions lookup; a key or label needs that lookup. Needs staff standing in the organization or a place in its plan's room; only an owned gate's owner ticks it, and its owner or staff untick it. Anyone else gets a 403 naming the owner. An outside expert's pxc_ credential ticks the gates it owns on a step assigned to it (assignment_list); any other step is 404. An Operator-only login (operator-cli) is refused here, as on every tool outside Operator's, even for a person in the plan's room.",
+    readOnly: false,
+    shape: {
+      issue: identifier,
+      gate: z.string().describe("the gate's key, its label, or its condition id"),
+      satisfied: z.boolean()
+    },
+    handler: (ctx, args) => gateSet(ctx, args["issue"], args["gate"], args["satisfied"])
+  },
+  {
+    name: "condition_list",
+    description: "An issue's wait conditions (not_before, gate, event), oldest first: each one's id, kind, a gate's key, label and owner, and whether, when and by whom it was satisfied. gate_set ticks a gate. With an outside expert's pxc_ credential: only the gates it owns on a step assigned to it, in the expert view (owner as {kind, role}, satisfied_by as {kind: you|role|expert|member}); any other step is 404.",
+    readOnly: true,
+    shape: { issue: identifier },
+    handler: (ctx, args) => conditionList(ctx, args["issue"])
+  },
+  {
+    name: "assignment_list",
+    description: "An outside expert's own assignments, for their pxc_ credential: expert ({id, role}), plan ({id, status} or null), and assignments, each step assigned to them with its identifier, title, state, due_date, description (null when Operator runs the step), open_blockers (a count) and the gates on it they own. gate_set ticks one. A pxc_ credential reaches only this, condition_list and gate_set: every other tool is refused as expert_bound_credential. Any other credential is refused as expert_credential_required.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => assignments(ctx)
+  },
+  // ── Operator jobs (CLI-43) ──
+  ...OPERATOR_JOB_TOOLS,
+  // ── Operator job controls (CLI-46) ──
+  ...OPERATOR_CONTROL_TOOLS,
+  // ── Operator job start (CLI-45) ──
+  ...OPERATOR_RUN_TOOLS,
+  // ── Operator job lifecycle (CLI-47) ──
+  ...OPERATOR_LIFECYCLE_TOOLS,
+  // ── Uploads ──
+  {
+    name: "upload",
+    description: "Upload a local image (png/jpg/webp/gif, up to 25 MB) or H.264 MP4 video (8-bit 4:2:0, optional AAC audio and mov_text subtitles, up to 100 MB). Returns metadata and markdown: images use image markdown; videos use ordinary links rendered as inline players in Harness issues. A video is private to its uploader until that user saves its link in an issue description or comment. Reading an issue does not automatically download videos.",
+    readOnly: false,
+    shape: { path: z.string().describe("local file path") },
+    handler: (ctx, args) => upload(ctx, args["path"])
+  },
+  // ── Operator's catalog (CLI-44) ──
+  {
+    name: "tools_search",
+    description: "Browse or search what Operator can use now in this organization: only capabilities that are switched on appear. Without query, the index in id order (25 a page); with query, a keyword search ranked by score (15 a page). domain narrows either to one domain. Each capability carries its domain, summary, description, mode, effect and kind: read, write, or send (a write delivered beyond the platform). Write and send capabilities, and any proposal, always need a person's approval in the app before they take effect; nothing here runs or approves anything. A page that isn't the last comes with a notice naming the next cursor; all=true follows every page.",
+    readOnly: true,
+    shape: {
+      query: z.string().optional().describe("search terms, at most 200 bytes; omit to browse the index"),
+      domain: z.string().optional().describe("only this capability domain, e.g. crm"),
+      cursor: z.string().optional().describe("the next page's cursor, from the previous call's notice"),
+      all: z.boolean().optional().describe("follow every page")
+    },
+    handler: (ctx, args) => {
+      const opts = { domain: args["domain"], cursor: args["cursor"], all: args["all"] };
+      return args["query"] === void 0 ? toolsList(ctx, opts) : toolsSearch(ctx, args["query"], opts);
+    }
+  },
+  {
+    name: "skills_list",
+    description: "The organization's skills assigned to Operator, in title order: each skill's id, title, invocation_name and content_sha256. A skill's content and description are never exposed.",
+    readOnly: true,
+    shape: {},
+    handler: (ctx) => skillsList(ctx)
+  }
+];
+function buildServer(name = "harness") {
+  const server = new McpServer({ name, version: CLI_VERSION });
+  for (const tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        inputSchema: tool.shape,
+        annotations: {
+          readOnlyHint: tool.readOnly,
+          ...tool.destructive === void 0 ? {} : { destructiveHint: tool.destructive },
+          ...tool.idempotent === void 0 ? {} : { idempotentHint: tool.idempotent }
+        }
+      },
+      ((args) => run((ctx) => tool.handler(ctx, args)))
+    );
+  }
+  return server;
+}
+async function startMcpServer(name = "harness") {
+  const server = buildServer(name);
+  await server.connect(new StdioServerTransport());
+}
+export {
+  buildServer,
+  startMcpServer
+};