@taiga-ai/mcp-server 0.28.0-dev.598 → 0.28.0-dev.599

package/dist/index.js

@@ -22484,8 +22484,11 @@ var TaigaClient = class {
 		return this.request("POST", `/builds/${seg(id)}/stop`);
 	}
 	/** Ask the coding agent for changes to the run's pull request (PRO-3035). */
-	async requestBuildRunChanges(id, notes) {
-		return this.request("POST", `/builds/${seg(id)}/request-changes`, { notes });
+	async requestBuildRunChanges(id, notes, opts = {}) {
+		return this.request("POST", `/builds/${seg(id)}/request-changes`, {
+			notes,
+			...opts.reviewPlan !== void 0 ? { reviewPlan: opts.reviewPlan } : {}
+		});
 	}
 	async listBuildRunSteps(id) {
 		return this.request("GET", `/builds/${seg(id)}/steps`);
@@ -23579,14 +23582,16 @@ object({
 	headSha: lenient(string$2()),
 	file: lenient(string$2()),
 	failingChecks: lenient(lenientList(storedFailingCheck)),
-	blockers: lenient(lenientList(_enum(READY_BLOCKERS)))
+	blockers: lenient(lenientList(_enum(READY_BLOCKERS))),
+	detail: lenient(string$2())
 }).transform((e) => ({
 	reason: e.reason,
 	...e.rounds === void 0 ? {} : { rounds: e.rounds },
 	...e.headSha === void 0 ? {} : { headSha: e.headSha },
 	...e.file === void 0 ? {} : { file: e.file },
 	...e.failingChecks === void 0 ? {} : { failingChecks: e.failingChecks },
-	...e.blockers === void 0 ? {} : { blockers: e.blockers }
+	...e.blockers === void 0 ? {} : { blockers: e.blockers },
+	...e.detail === void 0 ? {} : { detail: e.detail }
 }));
 /**
 * What a run's hardening came to, coverage included (PRO-2829). `passed`
@@ -27309,7 +27314,7 @@ function handbackSaid(escalation) {
 		case "review_bot_cap": return `review bots still have open comments${rounds}`;
 		case "ci_never_settled": return "CI did not finish in time";
 		case "review_fix_stalled": return "Taiga could not fix some review comments; its replies say what it tried";
-		case "changes_not_planned": return "the planner did not plan the request for changes, so the pull request is as it was";
+		case "changes_not_planned": return `the planner did not plan the request for changes${typeof e.detail === "string" && e.detail ? ` (${e.detail})` : ""}, so the pull request is as it was`;
 		case "ready_blocked": return `CI is green, but Taiga kept the pull request a draft${blockers.length ? `: ${blockers.join("; ")}` : ""}`;
 		case "check_weakened": return `CI went green only after a fix changed ${typeof e.file === "string" ? e.file : "a CI workflow or a test"}`;
 		default: return typeof e.reason === "string" ? e.reason : null;
@@ -27356,16 +27361,34 @@ function runOutcome(run) {
 	return {
 		disposition,
 		outcome: {
-			in_flight: status === "pending" ? "Queued: waiting to start." : `Running: ${RUNNING[status] ?? status}${progress}.`,
+			in_flight: status === "pending" ? "Queued: waiting to start." : status === "replanning" ? steerPaused(run["failedReason"], progress) : `Running: ${RUNNING[status] ?? status}${progress}.`,
 			gated: handback ? `Handed back to a person: ${handback}. ${pr}${draft ? `${draft},` : ""} waits for them to ${handbackNextStep(run["reviewEscalation"])}.` : `Waiting for a person to review and merge ${pr}${draft}.`,
 			succeeded: `Merged: ${pr} is in ${typeof run["baseBranch"] === "string" ? run["baseBranch"] : "the base branch"}.`,
 			unmerged: typeof run["prNumber"] === "number" || run["prUrl"] ? `Settled without merging: ${pr} was left unmerged.` : "Settled without a merged pull request.",
 			failed: `Failed${why ? `: ${why}` : ""}${progress}.`,
-			stopped: `Stopped before it finished${progress}.`,
+			stopped: replanHandedBack(run["failedReason"], why, progress) ?? `Stopped before it finished${progress}.`,
 			rejected: `${pr} was closed without merging, so the work did not land.${handback ? ` It had been handed back: ${handback}.` : ""}`
 		}[disposition] ?? status
 	};
 }
+/**
+* A run re-planning for a request for changes (PRO-3161), in one sentence:
+* the re-plan in flight, or the revised plan waiting for review.
+*/
+function steerPaused(reason, progress) {
+	if (reason === "steer_review") return `Paused${progress}: the plan revised for a request for changes waits for a person to review it (taiga_review_plan).`;
+	return `Paused after a step${progress}: its plan is being revised for a request for changes.`;
+}
+/**
+* A run its re-plan handed back (PRO-3165), in one sentence with the
+* planner's reason. Null for any other stop.
+*/
+function replanHandedBack(reason, why, progress) {
+	const said = why && why !== reason ? `: ${why}` : ".";
+	if (reason === "replan_refused") return `Stopped${progress}, handed back: the planner would not plan the request for changes${said} Resume continues the original plan.`;
+	if (reason === "replan_failed") return `Stopped${progress}, handed back: ${why && why !== reason ? why.replace(/\.?$/, ".") : "the plan could not be revised."} Resume continues the original plan.`;
+	return null;
+}
 /** Words a sentence does not end at: "e.g." and the like, and a lone initial. */
 const ABBREVIATION = /(?:\b(?:e\.g|i\.e|etc|vs|cf|incl|approx)|(?:^|\s)[A-Za-z])\.$/i;
 /** A finding's first sentence, capped: it ends at . ! or ? before white space, but not at an abbreviation. */
@@ -27710,20 +27733,27 @@ function registerBuildTools(server, client) {
 		});
 	}));
 	if (!client.hasCapability("products:write")) return;
+	const steering = client.hasFeature("steerRuns");
 	if (client.hasFeature("requestChanges")) server.registerTool("taiga_request_changes", {
-		title: "Request changes on a pull request",
-		description: "Tell the coding agent what should change on a run's open pull request, as a person's review would: it splits the request into separate asks, makes the changes on the same pull request, and answers each one there (done, answered, or not done and why). Only for a run whose pull request is waiting for review (the initiative is in review with its pull request open); refused otherwise, and where the organization does not have it yet. taiga_wait follows the run until it is back in review.",
+		title: steering ? "Request changes on a run" : "Request changes on a pull request",
+		description: steering ? "Tell Taiga what should change in a run, while it builds or once its pull request waits for review. The run stops after the step it is building (at once when it is not building one), the planner revises the steps still to build on top of the committed work (adding, editing, dropping, or reverting committed steps exactly), and the run continues with the revised steps; never a new initiative. A request while the run hardens, checks CI or is already being re-planned waits and joins the next re-plan. reviewPlan holds the run until a person has looked at the revised plan (taiga_review_plan approves it or comments to revise it again). A request the planner will not plan, a policy conflict, hands the run back with the reason, still on its original plan. The answer says what happened to it (steer). For a plan that waits for its build to be approved, comment on the plan with taiga_review_plan instead." : "Tell the coding agent what should change on a run's open pull request, as a person's review would: it splits the request into separate asks, makes the changes on the same pull request, and answers each one there (done, answered, or not done and why). Only for a run whose pull request is waiting for review (the initiative is in review with its pull request open); refused otherwise, and where the organization does not have it yet. taiga_wait follows the run until it is back in review.",
 		inputSchema: object({
 			runId,
-			notes: string$2().trim().min(1).max(CHANGE_REQUEST_MAX_CHARS).describe("What should change, in markdown: a list of changes, questions, or both")
+			notes: string$2().trim().min(1).max(CHANGE_REQUEST_MAX_CHARS).describe("What should change, in markdown: a list of changes, questions, or both"),
+			...steering ? { reviewPlan: boolean().optional().describe("Hold the run until a person has reviewed the revised plan (default false)") } : {}
 		}),
 		annotations: OPERATE
 	}, (params) => runTool(async () => {
-		const result = await client.requestBuildRunChanges(params.runId, params.notes);
+		const reviewPlan = "reviewPlan" in params ? params.reviewPlan : void 0;
+		const result = await client.requestBuildRunChanges(params.runId, params.notes, { reviewPlan });
 		const row = pickFields([result.data], RUN_OUTCOME_FIELDS)[0];
 		return toolResult({
 			...readableRow(row),
-			requestId: result.data.requestId
+			requestId: result.data.requestId,
+			...result.data.steer ? {
+				steer: result.data.steer,
+				situation: steerSituation(result.data.steer)
+			} : {}
 		});
 	}));
 	server.registerTool("taiga_stop_run", {
@@ -27736,6 +27766,12 @@ function registerBuildTools(server, client) {
 		return toolResult(readableRow(pickFields([result.data], RUN_OUTCOME_FIELDS)[0]));
 	}));
 }
+/** What happened to a request that steers a run (PRO-3161), in one sentence. */
+function steerSituation(steer) {
+	if (steer === "replanning") return "The run has paused and its plan is being revised for the request.";
+	if (steer === "after_step") return "The run stops when the step it is building ends, then its plan is revised.";
+	return "The run is hardening, checking CI or already being re-planned; the request joins the next re-plan.";
+}
 //#endregion
 //#region src/tools/queue.ts
 /** How many entries the read names; past this an entry keeps its initiativeId only. */
@@ -28152,6 +28188,37 @@ async function planFailureOf(client, initiativeId, itemCause) {
 		by: typeof actor.name === "string" ? actor.name : actor.type ?? null
 	};
 }
+/**
+* What a request for changes did to this plan (PRO-3161), when one revised it:
+* the steps the re-plan added, edited and dropped, and the committed steps it
+* reverts, from the `run_replanned` event that made this version. Null for a
+* plan no request revised, or when the history cannot be read.
+*/
+async function planRevisionOf(client, initiativeId, planId) {
+	let events;
+	try {
+		events = (await client.listBacklogItemActivity(initiativeId)).data;
+	} catch (error) {
+		if (error instanceof TaigaApiError || isNetworkFailure(error)) return null;
+		throw error;
+	}
+	for (const event of [...events].reverse()) {
+		if (event.kind !== "turn" || event.trigger !== "run_replanned") continue;
+		const data = event.data ?? {};
+		if (data["planId"] !== planId) continue;
+		return {
+			revisedFor: "a request for changes",
+			previousPlanId: data["previousPlanId"] ?? null,
+			added: data["added"] ?? [],
+			edited: data["edited"] ?? [],
+			dropped: data["dropped"] ?? [],
+			reverted: data["reverted"] ?? [],
+			waitsForReview: data["reviewPlan"] === true,
+			at: event.occurredAt ?? null
+		};
+	}
+	return null;
+}
 const planId = idInput("plan", "taiga_get_plan gives the initiative's active plan and its ID");
 const initiativeId = idInput("initiative", "taiga_list_initiatives (query finds one by title) gives it");
 /** The plan without its steps' prose: enough to approve it or say what a run will do. */
@@ -28170,7 +28237,9 @@ const PLAN_STEP_SUMMARY_FIELDS = [
 	"dependencies",
 	"writes",
 	"reads",
-	"createsResources"
+	"createsResources",
+	"revertsSteps",
+	"changeRequestIds"
 ];
 /** The outcome fields of an initiative, with how many of its criteria are met, and where it stands. */
 const outcomeOf = (item) => withSituation(item, {
@@ -28290,7 +28359,7 @@ function registerBacklogReads(server, client) {
 	}));
 	server.registerTool("taiga_get_plan", {
 		title: "Get the active plan",
-		description: "Read an initiative's active plan, step by step: what each builds, the files it writes and reads, and what it depends on. Enough to approve or reject it; full: true adds each step's complete instructions (long). NOT_FOUND when there is no active plan; the initiative's situation says why.",
+		description: "Read an initiative's active plan, step by step: what each builds, the files it writes and reads, and what it depends on. Enough to approve or reject it; full: true adds each step's complete instructions (long). A plan a request for changes revised says so in revision: the steps it added, edited and dropped, and the committed steps it reverts. NOT_FOUND when there is no active plan; the initiative's situation says why.",
 		inputSchema: object({
 			initiativeId,
 			full: boolean().optional().describe("Carry each step's complete instructions (default false: a summary)")
@@ -28298,10 +28367,16 @@ function registerBacklogReads(server, client) {
 		annotations: READ_ONLY
 	}, (params) => runTool(async () => {
 		const plan = (await client.getActivePlan(params.initiativeId)).data;
-		if (params.full) return toolResult(plan);
+		const revision = await planRevisionOf(client, params.initiativeId, plan.id);
+		const revised = revision ? { revision } : {};
+		if (params.full) return toolResult({
+			...plan,
+			...revised
+		});
 		const steps = Array.isArray(plan.steps) ? plan.steps : [];
 		return toolResult({
 			...pickFields([plan], PLAN_SUMMARY_FIELDS)[0],
+			...revised,
 			steps: pickFields(steps, PLAN_STEP_SUMMARY_FIELDS)
 		});
 	}));
@@ -28465,7 +28540,7 @@ function registerResume(server, client) {
 function registerPlanReview(server, client) {
 	server.registerTool("taiga_review_plan", {
 		title: "Approve or reject a plan",
-		description: "Give an initiative's plan its verdict. approve starts the run that builds it; reject sends it back with a comment and the planner writes a new one from it. Read the plan first (taiga_get_plan) and pass its ID; refused if the plan was replaced since, a new one is being written, or a run is already going.",
+		description: "Give an initiative's plan its verdict. approve starts the run that builds it; reject sends it back with a comment and the planner revises it from the comment, keeping what the comment does not object to. Read the plan first (taiga_get_plan) and pass its ID; refused if the plan was replaced since, a new one is being written, or a run is already going." + (client.hasFeature("steerRuns") ? " A plan a request for changes revised while its run waits for this review (taiga_request_changes with reviewPlan): approve continues that run on its branch, and reject comments to revise it again." : ""),
 		inputSchema: object({
 			planId,
 			verdict: _enum(["approve", "reject"]).describe("approve builds the plan; reject sends it back"),
@@ -45490,6 +45565,7 @@ const RUN_REPORT_FIELDS = [
 ];
 const runSignature = (run) => JSON.stringify([
 	run.status,
+	run.failedReason,
 	run.completedSteps,
 	run.prUrl,
 	run.prState,
@@ -45502,6 +45578,10 @@ function judgeBuild(until) {
 			reached: false,
 			stoppedBecause: `the run is ${String(run.status)}`
 		};
+		if (until !== "changed" && run.status === "replanning" && run.failedReason === "steer_review") return {
+			reached: false,
+			stoppedBecause: "the run waits for a person to review its revised plan (taiga_review_plan)"
+		};
 		return null;
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.28.0-dev.598",
+  "version": "0.28.0-dev.599",
   "description": "Taiga for AI coding assistants: read products, policies, initiatives and runs, and operate the line, over MCP",
   "mcpName": "ga.tai/mcp-server",
   "license": "UNLICENSED",