@gavin-hu/my-pi-agent 0.17.0 → 0.18.0

package/extensions/plan/tools/exit.ts

@@ -3,7 +3,7 @@
  *
  * It presents the saved plan for approval, then seeds the approved steps into
  * the todo list and finalizes the session goal: a `planning` goal becomes the
- * plan's own `## Goal`, and a session with no goal is offered the same. The
+ * plan's own `## Goal`, and a session with no goal is given the same. The
  * review loop and the browser lifecycle belong to `review.ts`; the nested writes
  * belong to `todo-seed.ts` and the goal tool.
  */
@@ -12,6 +12,7 @@ import { basename } from "node:path";
 import type { ExtensionAPI, ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { sanitizeLine } from "../../../lib/format.ts";
+import { messageOf } from "../../../lib/errors.ts";
 import { lastGoal } from "../../../lib/goal-state.ts";
 import { GOAL_TOOL } from "../../../lib/tool-names.ts";
 import { reuseText, toolDetails } from "../../../lib/tui/chrome.ts";
@@ -19,12 +20,13 @@ import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import { paint } from "../../../lib/tui/tokens.ts";
 import { callLine, detailsOrLine, moreHint } from "../../../lib/tui/tool.ts";
 import { failedResult } from "../../../lib/tool-result.ts";
-import { loadConfig } from "../config.ts";
 import { feedbackSummary } from "../feedback.ts";
 import { mergeSummary, overCap, preview, verificationNote } from "../format.ts";
 import { sanitizePlanText } from "../plan-text.ts";
 import { planTitle, type StoredPlan } from "../plans.ts";
 import { reviewPlan } from "../review.ts";
+import { decideSplit, rosterCard, SPLIT_OFF_NOTE } from "../split.ts";
+import { writeTeam } from "../../../lib/plans/team.ts";
 import { EXIT_TOOL, SET_PLAN_STEPS_TOOL, type PlanRuntime } from "../runtime.ts";
 import { goalSection, MAX_STEPS, planStepSummary } from "../steps.ts";
 import type { ExitPlanModeDetails } from "../types.ts";
@@ -32,11 +34,27 @@ import type { PlanWebReview } from "../web.ts";
 import { firstTextLine } from "./nested.ts";
 import { seedTodos } from "./todo-seed.ts";
 
+const PlanUnitParams = Type.Object({
+	name: Type.String({ description: "Lowercase slug; the owner session takes it as its label." }),
+	paths: Type.Array(Type.String(), { description: "Repository-relative path prefixes this unit owns." }),
+	test: Type.String({ description: "The command that proves the unit is done." }),
+	dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Units that must land first." })),
+	lead: Type.Optional(Type.Boolean({ description: "True for the one unit this session keeps." })),
+});
+
 const ExitPlanModeParams = Type.Object({
 	plan_path: Type.String({
 		description:
-			"Path to the plan file written by write_plan (absolute, or relative to the working directory). The user reviews this file.",
+			"Path to the plan file written by write_plan: the absolute path it returned, or the `~/…` form it displayed. A bare name resolves inside the plans directory. The user reviews this file.",
 	}),
+	units: Type.Optional(
+		Type.Array(PlanUnitParams, {
+			description:
+				"The plan's slices, when it has two or more independent ones the user will run in separate sessions. " +
+				"Only used when the plan.split setting is on; validation refuses an overlapping, looping, or oversized " +
+				"split before the review opens. Omit it to approve as one flow.",
+		}),
+	),
 });
 
 type ExitPlanModeArgs = Static<typeof ExitPlanModeParams>;
@@ -52,24 +70,16 @@ interface GoalOutcome {
 /**
  * Finalise the session goal from the approved plan.
  *
- * A `planning` goal needs no dialog — approving the plan *is* the decision — and a
- * session with no goal at all gets one confirm, unless `plan.goalPrompt` is off,
- * which records the objective without asking. A final goal (`active` or
- * `achieved`) is the user's own: approving ordinary work never rewrites it.
- * Recording runs through the goal tool, so validation and the widget stay goal's,
- * and no model turn is spent.
+ * Approving the plan *is* the decision, so neither a `planning` goal nor a
+ * session with none is asked again. A final goal (`active` or `achieved`) is the
+ * user's own: approving ordinary work never rewrites it. Recording runs through
+ * the goal tool, so validation and the widget stay goal's, and no model turn is
+ * spent.
  */
 async function finalizeGoal(ctx: ExtensionToolContext, plan: StoredPlan): Promise<GoalOutcome> {
 	const objective = planObjective(plan);
 	const current = lastGoal(ctx.sessionManager.getBranch());
 	if (current !== null && current.status !== "planning") return { objective };
-	if (current === null) {
-		if (!ctx.hasUI) return { objective };
-		if (loadConfig(ctx.cwd).goalPrompt) {
-			const approved = await ctx.ui.confirm("Record this plan as the session goal?", objective);
-			if (!approved) return { objective };
-		}
-	}
 	const outcome = await ctx.executeTool(GOAL_TOOL, { objective, status: "active" });
 	const action = current === null ? "recorded" : "promoted";
 	return outcome.isError ? { objective, action, error: firstTextLine(outcome) } : { objective, action };
@@ -101,7 +111,8 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 		annotations: { readOnlyHint: true, openWorldHint: false },
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			const planPath = (params as ExitPlanModeArgs).plan_path.trim();
+			const args = params as ExitPlanModeArgs;
+			const planPath = args.plan_path.trim();
 
 			if (!runtime.isEnabled()) {
 				return failedResult("Not in plan mode; there is no plan to approve.", {
@@ -134,6 +145,26 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				);
 			}
 
+			// The split is decided before the review opens, so a refused or rejected split
+			// never spends the user's review — and the screen can show what it approves.
+			const units = args.units?.map((unit) => ({
+				name: unit.name,
+				paths: [...unit.paths],
+				test: unit.test,
+				dependsOn: [...(unit.dependsOn ?? [])],
+				...(unit.lead ? { lead: true } : {}),
+			}));
+			const split = decideSplit(ctx.cwd, await runtime.plans.rootFor(ctx.cwd), units);
+			if (split.kind === "refused") {
+				return failedResult(`Refused: ${split.reason}`, {
+					approved: false,
+					plan: file.content,
+					planPath: file.path,
+					relativePath: file.relativePath,
+				} satisfies ExitPlanModeDetails);
+			}
+			const pending = split.kind === "team" ? split : undefined;
+
 			if (!ctx.hasUI) {
 				return failedResult(
 					`No interactive UI is available to approve the plan. It is saved at ${file.relativePath}; present it and ask the user to approve it in their reply.`,
@@ -156,6 +187,7 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				baselines: runtime,
 				plan: file,
 				signal,
+				...(pending === undefined ? {} : { split: { ...pending.team, verdict: pending.verdict } }),
 			});
 
 			if (decision.action === "refine") {
@@ -218,9 +250,33 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 				};
 			}
 
+			// The team becomes real here, never before: the section is what a joining
+			// session reads, so it appears only after the user approved the split. The
+			// write happens while plan mode is still on, so a failure leaves the session
+			// able to retry instead of approved-but-empty.
+			let approved = decision.plan;
+			if (pending !== undefined) {
+				try {
+					approved = await runtime.plans.write(ctx.cwd, {
+						title: planTitle(basename(decision.plan.path)),
+						content: writeTeam(decision.plan.content, { lead: pending.team.lead, units: pending.team.units }),
+						planPath: decision.plan.path,
+					});
+				} catch (writeError) {
+					return failedResult(
+						`The plan was approved but its team could not be written: ${messageOf(writeError)}. Plan mode is still on and no steps were seeded; fix the plan file and call exit_plan_mode again.`,
+						{
+							approved: false,
+							plan: decision.plan.content,
+							planPath: decision.plan.path,
+							relativePath: decision.plan.relativePath,
+						} satisfies ExitPlanModeDetails,
+					);
+				}
+			}
 			runtime.disable(ctx);
-			const { steps, merged, error } = await seedTodos(pi, ctx, decision.plan.content);
-			const goal = await finalizeGoal(ctx, decision.plan);
+			const { steps, merged, error } = await seedTodos(pi, ctx, approved.content);
+			const goal = await finalizeGoal(ctx, approved);
 			const listing =
 				steps.length > 0
 					? `\n\n${steps
@@ -247,19 +303,41 @@ export function registerExitTool(pi: ExtensionAPI, runtime: PlanRuntime, web: Pl
 			const browserNote = decision.comments.length
 				? `\n\nThe user approved from the browser review with these comments:\n${feedbackSummary(decision.comments)}`
 				: "";
+			const splitNote =
+				pending === undefined
+					? split.kind === "off"
+						? `\n\n${SPLIT_OFF_NOTE}`
+						: ""
+					: `\n\n${rosterCard(pending.team, approved.path, pi.getSessionName())}\n\nWork only your own unit (${pending.team.lead}); the other units belong to the sessions the user starts.`;
 			return {
 				content: [
 					{
 						type: "text",
-						text: `Plan approved. Plan mode is off and write access is restored. The plan file ${decision.plan.relativePath} is the source of truth; follow its steps.${browserNote}${tail}${verification}${goalNote}${listing}`,
+						text: `Plan approved. Plan mode is off and write access is restored. The plan file ${approved.relativePath} is the source of truth; follow its steps.${browserNote}${splitNote}${tail}${verification}${goalNote}${listing}`,
 					},
 				],
 				details: {
 					approved: true,
-					plan: decision.plan.content,
-					planPath: decision.plan.path,
-					relativePath: decision.plan.relativePath,
+					plan: approved.content,
+					planPath: approved.path,
+					relativePath: approved.relativePath,
 					annotations: decision.comments.length > 0 ? decision.comments : undefined,
+					...(pending === undefined
+						? split.kind === "off"
+							? { splitOff: true }
+							: {}
+						: {
+								team: {
+									lead: pending.team.lead,
+									verdict: pending.verdict,
+									units: pending.team.units.map((unit) => ({
+										name: unit.name,
+										paths: unit.paths,
+										test: unit.test,
+										dependsOn: unit.dependsOn,
+									})),
+								},
+							}),
 				} satisfies ExitPlanModeDetails,
 			};
 		},

package/extensions/plan/tools/write.ts

@@ -40,7 +40,7 @@ export function registerWriteTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 		name: WRITE_PLAN_TOOL,
 		label: "Write plan",
 		description:
-			"Save the plan you designed as a markdown file under .pi/plans (project root, or the agent directory outside a " +
+			"Save the plan you designed as a markdown file in the plans directory (the agent directory, keyed by " +
 			"repository). Write the complete plan, not a summary, in this outline so it is consistent and scannable:\n\n" +
 			`${PLAN_OUTLINE}\n\n` +
 			"Each section has one job: lead it with its outcome, keep a prose section to a few bullets or two or three " +
@@ -51,10 +51,11 @@ export function registerWriteTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 			"The outline is a guide, not a form: drop Context, Approach, Visual, or Risks when there is nothing to say. " +
 			"Keep Steps and Verification — the steps are read from that section (without it, the shallowest list " +
 			"anywhere becomes the steps), and Verification becomes the last todo item. " +
-			"In Steps, each top-level bullet is one outcome in the order you will do them, and deeper bullets are notes. " +
+			"In Steps, each top-level bullet is one outcome in the order you will do them; " +
+			"an indented line continues that outcome, and a deeper bullet is a note. " +
 			"Returns the path to pass to exit_plan_mode; plan_path overwrites an existing file when refining. " +
 			`A plan with more than ${MAX_STEPS} top-level steps in its Steps section is refused, so approval never drops steps it cannot track.`,
-		promptSnippet: "Save the designed plan as a markdown file under .pi/plans.",
+		promptSnippet: "Save the designed plan as a markdown file in the plans directory.",
 		promptGuidelines: [
 			"While plan mode is active, write the full plan with write_plan, then call exit_plan_mode with the returned path.",
 			"When refining with plan_path, keep every section heading as it was: the review marks changed sections by heading, " +
@@ -88,6 +89,10 @@ export function registerWriteTool(pi: ExtensionAPI, runtime: PlanRuntime): void
 					planPath: args.plan_path,
 				});
 				runtime.setLastPlan(ctx, file.path);
+				// A store an older version kept in the checkout was moved in by this
+				// write; say so once, where the user is looking.
+				const moved = runtime.plans.takeNotice();
+				if (moved) ctx.ui.notify(moved, "info");
 				return textResult(
 					`Wrote the plan to ${file.relativePath}. Call exit_plan_mode with plan_path: ${file.path}${stepElisionNote(summary.elided)}`,
 					{ path: file.path, relativePath: file.relativePath, bytes: file.bytes } satisfies WritePlanDetails,

package/extensions/plan/tools.ts

@@ -2,7 +2,7 @@
  * Model-facing registration for the plan-mode tools.
  *
  * `enter_plan_mode` lets the model ask to plan before touching code; it needs
- * user confirmation. `write_plan` saves the plan artifact under `.pi/plans` and
+ * user confirmation. `write_plan` saves the plan artifact in the plans directory and
  * returns its path. `cancel_plan_mode` leaves planning without approving, so a
  * phone user is never trapped in read-only mode. `exit_plan_mode` reads that file
  * back, presents it for approval (a scrollable review screen in the TUI, a select dialog elsewhere),

package/extensions/plan/tui.ts

@@ -6,9 +6,11 @@
  * the active Markdown theme, so headings, lists, code, links, and quotes match
  * the rest of the application; plan-authored control characters are stripped
  * first so the file cannot drive the terminal. Task checkboxes are recolored
- * and the footer colors the primary actions. It returns the chosen action
- * through `onClose` so the caller can act
- * only after the screen is gone and input focus is free again.
+ * and the footer colors the primary actions. Approving leaves plan mode and
+ * starts the work, so it asks `y/N` first through the shared `ConfirmState`;
+ * the plan stays mounted, and `Esc` backs out of the question before it backs
+ * out of the review. It returns the chosen action through `onClose` so the
+ * caller can act only after the screen is gone and input focus is free again.
  */
 
 import { basename } from "node:path";
@@ -27,6 +29,7 @@ import {
 	type TuiMouseEventResult,
 } from "@earendil-works/pi-tui";
 import { sanitizeLine } from "../../lib/format.ts";
+import { renderTeam, type PlanUnit } from "../../lib/plans/team.ts";
 import {
 	editorTheme,
 	screenHint,
@@ -35,13 +38,14 @@ import {
 	type ViewportRowsSource,
 } from "../../lib/tui/chrome.ts";
 import { isCloseKey } from "../../lib/tui/cursor.ts";
+import { ConfirmState } from "../../lib/tui/confirm.ts";
 import { gaugeBar } from "../../lib/tui/gauge.ts";
 import { GLYPHS } from "../../lib/tui/glyphs.ts";
 import { plainRule, titleRule } from "../../lib/tui/rules.ts";
 import { emptyState, checkbox } from "../../lib/tui/rows.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { planTitle, type StoredPlan } from "./plans.ts";
-import { changedSections, sanitizePlanText, type SectionDigest } from "./plan-text.ts";
+import { changedSections, planDisplayText, type SectionDigest } from "./plan-text.ts";
 import { extractPlanSections } from "./steps.ts";
 
 /** What the user chose from the read/review screen. */
@@ -83,6 +87,11 @@ export interface PlanViewOptions {
 	tui?: TUI;
 	/** Markdown theme for the body; defaults to Pi's active theme. */
 	markdownTheme?: MarkdownTheme;
+	/**
+	 * The split approval would write. Rendered as a read-only section after the
+	 * plan, because the `## Team` section itself only exists after approval.
+	 */
+	split?: { lead: string; units: readonly PlanUnit[]; verdict: "pair" | "team" };
 }
 
 /** Rows the screen shows when the terminal height is unknown. */
@@ -175,6 +184,8 @@ export class PlanViewComponent implements Component {
 	private cache: BodyCache | null = null;
 	/** True while the inline refine editor owns the keyboard. */
 	private editing = false;
+	/** The y/N approval question, shared with the other destructive screens. */
+	private readonly confirm = new ConfirmState();
 	/** The inline refine editor, built lazily once a TUI handle is available. */
 	private editor: Editor | null = null;
 
@@ -195,7 +206,7 @@ export class PlanViewComponent implements Component {
 		const padding = width >= MIN_PADDED_WIDTH ? BODY_PADDING : 0;
 		const base = this.options.markdownTheme ?? getMarkdownTheme();
 		const theme = planMarkdownTheme(this.theme, base);
-		const current = sanitizePlanText(this.options.plan.content);
+		const current = planDisplayText(this.options.plan.content);
 		const changed = changedSections(this.options.baseline, current);
 		const chunks = extractPlanSections(current);
 		const lines: string[] = [];
@@ -216,10 +227,31 @@ export class PlanViewComponent implements Component {
 			// chunk omits before the next section.
 			if (index < chunks.length - 1 && lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
 		});
+		const split = this.splitSection();
+		if (split !== undefined) {
+			if (lines.length > 0 && lines[lines.length - 1] !== "") lines.push("");
+			const rendered = new Markdown(split, padding, 0, theme)
+				.render(width)
+				.map((line) => truncateToWidth(line.trimEnd(), width));
+			sections.push({ title: "Split", offset: lines.length });
+			lines.push(...rendered);
+		}
 		this.cache = { width, lines, sections, changedCount: changed.filter(Boolean).length };
 		return this.cache;
 	}
 
+	/**
+	 * The split as a read-only section: the same table approval writes, so what the
+	 * user approves is what the plan file will carry.
+	 */
+	private splitSection(): string | undefined {
+		const split = this.options.split;
+		if (split === undefined) return undefined;
+		const owners = split.units.filter((unit) => !unit.lead).length;
+		const summary = `${split.verdict} · lead + ${owners} owner${owners === 1 ? "" : "s"} · written on approval`;
+		return ["## Split", "", summary, "", renderTeam({ lead: split.lead, units: [...split.units] })].join("\n");
+	}
+
 	/** The section whose heading is at or above the viewport top. */
 	private currentSection(sections: SectionOffset[]): SectionOffset | undefined {
 		let current: SectionOffset | undefined;
@@ -314,6 +346,12 @@ export class PlanViewComponent implements Component {
 			this.options.requestRender();
 			return;
 		}
+		// A pending question owns the keyboard, so a scroll key cannot slip past it
+		// and `Esc` backs out of the question rather than the review.
+		if (this.confirm.pending) {
+			if (this.confirm.resolve(data) !== undefined) this.options.requestRender();
+			return;
+		}
 		if (isCloseKey(data)) {
 			this.options.onClose("keep");
 			return;
@@ -330,8 +368,10 @@ export class PlanViewComponent implements Component {
 		else if (matchesKey(data, Key.end) || data === "G") this.scrollTo(this.maxOffset);
 		else if (data === "n") this.jumpSection(1);
 		else if (data === "p") this.jumpSection(-1);
-		else if (data === "a") this.options.onClose("approve");
-		else if (data === "r") this.startRefine();
+		else if (data === "a") {
+			this.confirm.ask("Approve and run the plan? y/N", () => this.options.onClose("approve"));
+			this.options.requestRender();
+		} else if (data === "r") this.startRefine();
 		else if (data === "w") this.options.onClose("browser");
 		else if (data === "x") this.options.onClose("cancel");
 	}
@@ -400,10 +440,13 @@ export class PlanViewComponent implements Component {
 		} else {
 			if (this.maxOffset > 0) lines.push(scrollRow(theme, w, this.offset, end, body.length, sectionLabel));
 			else lines.push("");
+			const pending = this.confirm.pending;
 			const sectionHints = sections.length > 1 ? SECTION_HINTS : [];
 			const hints: ScreenHint[] =
 				this.maxOffset > 0 ? [...PRIMARY_HINTS, ...SCROLL_HINTS, ...sectionHints] : PRIMARY_HINTS;
-			lines.push(screenHint(theme, w, hints));
+			lines.push(
+				pending ? truncateToWidth(`  ${paint(theme, "warn", pending.prompt)}`, w) : screenHint(theme, w, hints),
+			);
 		}
 		lines.push(plainRule(theme, w));
 		return lines;

package/extensions/plan/types.ts

@@ -6,6 +6,32 @@ import type { PlanAnnotation } from "./feedback.ts";
 import type { SectionDigest } from "./plan-text.ts";
 import type { StepUpdate } from "./steps.ts";
 
+/**
+ * Who is looking at a running review: the session that opened it (`owner`, the
+ * only role that can approve), or someone the link was shared with (`reviewer`,
+ * who may comment).
+ */
+export type ReviewRole = "owner" | "reviewer";
+
+/**
+ * What a review token names: its role, and — for a reviewer — the name it posts
+ * under, bound the first time that link writes.
+ */
+export interface ReviewCaller {
+	role: ReviewRole;
+	/** The reviewer's name, once this link has written; absent for the owner and
+	 * for a reviewer that has not commented yet. */
+	name?: string;
+}
+
+/**
+ * One frame on the review's event stream. `comment`, `plan`, and `share` say a
+ * page should re-read the island; `closed` ends the review for everyone, and
+ * `revoked` tells a reviewer the owner stopped sharing. The frame carries no
+ * state of its own, so the island stays the one contract.
+ */
+export type ReviewFrame = "comment" | "plan" | "share" | "closed" | "revoked";
+
 /** Persisted (custom entry) plan-mode state. */
 export interface PlanModeEntry {
 	enabled: boolean;
@@ -38,7 +64,7 @@ export interface EnterPlanModeDetails {
 export interface WritePlanDetails {
 	/** Absolute path of the written plan file. */
 	path: string;
-	/** Path relative to the working directory, when inside it. */
+	/** How the path is shown: `~`-shortened, since plans live outside the project. */
 	relativePath: string;
 	/** Size of the written plan in bytes. */
 	bytes: number;
@@ -48,7 +74,7 @@ export interface WritePlanDetails {
 export interface SetPlanStepsDetails {
 	/** Absolute path of the plan file that was updated. */
 	path: string;
-	/** Path relative to the working directory, for transcript display. */
+	/** How the path is shown: `~`-shortened. */
 	relativePath: string;
 	/** The checkbox changes that were applied, in call order. */
 	updates: StepUpdate[];
@@ -66,7 +92,7 @@ export interface ExitPlanModeDetails {
 	plan: string;
 	/** Absolute path of the reviewed plan file. */
 	planPath?: string;
-	/** Path relative to the working directory, for transcript display. */
+	/** How the path is shown: `~`-shortened. */
 	relativePath?: string;
 	/** True when the user asked to refine the plan instead of approving. */
 	refined?: boolean;
@@ -78,6 +104,14 @@ export interface ExitPlanModeDetails {
 	cancelled?: boolean;
 	/** True when no interactive UI was available to ask for approval. */
 	unavailable?: boolean;
+	/** The team approval wrote into the plan, when the plan was split. */
+	team?: {
+		lead: string;
+		units: Array<{ name: string; paths: string[]; test: string; dependsOn: string[] }>;
+		verdict: "pair" | "team";
+	};
+	/** True when the model proposed a split while `plan.split` was off. */
+	splitOff?: boolean;
 }
 
 /** Structured result carried in `cancel_plan_mode`'s `details`. */

package/extensions/plan/web-chrome.ts

@@ -43,7 +43,7 @@ export const WEB_CHROME_JS = String.raw`  function setStatus(text, kind) {
     var count = annotations.length;
     label += " \u00b7 " + count + (count === 1 ? " comment" : " comments");
     if (dirty && !saved && !approved && !closed) {
-      label += " \u00b7 unsaved";
+      label += " \u00b7 " + (role === "reviewer" ? "unposted" : "unsaved");
       if (!tone) tone = "warn";
     }
     stateEl.textContent = label;
@@ -76,6 +76,7 @@ export const WEB_CHROME_JS = String.raw`  function setStatus(text, kind) {
   function lockActions() {
     if (approveButton) approveButton.disabled = true;
     if (saveButton) saveButton.disabled = true;
+    if (postButton) postButton.disabled = true;
     if (cancelButton) cancelButton.disabled = true;
   }