@pi-agents/orchid 0.1.0-beta.0

package/src/orchestrator/task-executor-core.ts

@@ -0,0 +1,675 @@
+/**
+ * Task Executor Core — Headless execution semantics for Runtime V2
+ *
+ * This module owns the deterministic task execution logic for headless lane execution.
+ * It has NO dependency on Pi's ExtensionAPI, ExtensionContext, UI
+ * widgets, session lifecycle, TMUX, or TASK_AUTOSTART.
+ *
+ * Consumers:
+ *   - lane-runner.ts (Runtime V2 headless lane execution, TP-105)
+ *
+ * Design rules:
+ *   1. No Pi imports. No ExtensionContext. No ctx.ui.
+ *   2. File I/O is explicit (path parameters, not cwd inference).
+ *   3. All functions are independently testable.
+ *   4. STATUS.md and .DONE semantics are preserved exactly.
+ *
+ * @module orchid/task-executor-core
+ * @since TP-103
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, basename, resolve, join } from "path";
+import { spawnSync } from "child_process";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+/**
+ * Parsed step information from PROMPT.md or STATUS.md.
+ *
+ * Re-exported from the core for downstream consumers.
+ */
+export interface StepInfo {
+	number: number;
+	name: string;
+	status: "not-started" | "in-progress" | "complete";
+	checkboxes: { text: string; checked: boolean }[];
+	totalChecked: number;
+	totalItems: number;
+}
+
+/**
+ * Parsed task metadata from PROMPT.md.
+ *
+ * This is the core's view of a task — independent of the orchestrator's
+ * ParsedTask which carries additional scheduling/routing metadata.
+ */
+export interface CoreParsedTask {
+	taskId: string;
+	taskName: string;
+	reviewLevel: number;
+	size: string;
+	steps: StepInfo[];
+	contextDocs: string[];
+	taskFolder: string;
+	promptPath: string;
+}
+
+/**
+ * Parsed STATUS.md data.
+ */
+export interface ParsedStatus {
+	steps: StepInfo[];
+	reviewCounter: number;
+	iteration: number;
+}
+
+// ── PROMPT.md Parsing ────────────────────────────────────────────────
+
+/**
+ * Parse a PROMPT.md file into structured task metadata.
+ *
+ * Pure function — no file I/O. Caller provides content and path.
+ *
+ * @param content - Raw PROMPT.md content
+ * @param promptPath - Absolute path to the PROMPT.md file (used to derive taskFolder)
+ * @returns Parsed task metadata
+ */
+export function parsePromptMd(content: string, promptPath: string): CoreParsedTask {
+	const text = content.replace(/\r\n/g, "\n");
+	const taskFolder = dirname(resolve(promptPath));
+
+	// Task ID and name
+	let taskId = "",
+		taskName = "";
+	const titleMatch = text.match(/^#\s+(?:Task:\s*)?(\S+-\d+)\s*[-–:]\s*(.+)/m);
+	if (titleMatch) {
+		taskId = titleMatch[1];
+		taskName = titleMatch[2].trim();
+	} else {
+		taskId = basename(taskFolder);
+		taskName = taskId;
+	}
+
+	// Review level
+	let reviewLevel = 0;
+	const rlMatch = text.match(/##\s+Review Level[:\s]*(\d)/);
+	if (rlMatch) reviewLevel = parseInt(rlMatch[1]);
+
+	// Size
+	let size = "M";
+	const sizeMatch = text.match(/\*\*Size:\*\*\s*(\w+)/);
+	if (sizeMatch) size = sizeMatch[1];
+
+	// Steps
+	const steps: StepInfo[] = [];
+	const stepRegex = /###\s+Step\s+(\d+):\s*(.+)/g;
+	const positions: { number: number; name: string; start: number }[] = [];
+	let m: RegExpExecArray | null;
+	while ((m = stepRegex.exec(text)) !== null) {
+		positions.push({ number: parseInt(m[1]), name: m[2].trim(), start: m.index });
+	}
+	for (let i = 0; i < positions.length; i++) {
+		const section = text.slice(
+			positions[i].start,
+			i + 1 < positions.length ? positions[i + 1].start : text.length,
+		);
+		const checkboxes: { text: string; checked: boolean }[] = [];
+		const cbRegex = /^\s*-\s*\[([ xX])\]\s*(.*)/gm;
+		let cb: RegExpExecArray | null;
+		while ((cb = cbRegex.exec(section)) !== null) {
+			checkboxes.push({ text: cb[2].trim(), checked: cb[1].toLowerCase() === "x" });
+		}
+		steps.push({
+			number: positions[i].number,
+			name: positions[i].name,
+			status: "not-started",
+			checkboxes,
+			totalChecked: checkboxes.filter((c) => c.checked).length,
+			totalItems: checkboxes.length,
+		});
+	}
+
+	// Context docs
+	const contextDocs: string[] = [];
+	const ctxMatch = text.match(/##\s+Context to Read First\s*\n+([\s\S]*?)(?=\n##\s|$)/);
+	if (ctxMatch) {
+		const pathRegex = /`([^\s`]+\.(?:md|yaml|json|go|ts|js))`/g;
+		let pm: RegExpExecArray | null;
+		while ((pm = pathRegex.exec(ctxMatch[1])) !== null) contextDocs.push(pm[1]);
+	}
+
+	return { taskId, taskName, reviewLevel, size, steps, contextDocs, taskFolder, promptPath };
+}
+
+// ── STATUS.md Parsing ────────────────────────────────────────────────
+
+/**
+ * Parse a STATUS.md file into structured execution state.
+ *
+ * Pure function — no file I/O. Caller provides content.
+ *
+ * @param content - Raw STATUS.md content
+ * @returns Parsed status with steps, review counter, and iteration
+ */
+export function parseStatusMd(content: string): ParsedStatus {
+	const text = content.replace(/\r\n/g, "\n");
+	const steps: StepInfo[] = [];
+	let currentStep: StepInfo | null = null;
+	let reviewCounter = 0,
+		iteration = 0;
+
+	for (const line of text.split("\n")) {
+		const rcMatch = line.match(/\*\*Review Counter:\*\*\s*(\d+)/);
+		if (rcMatch) reviewCounter = parseInt(rcMatch[1]);
+		const itMatch = line.match(/\*\*Iteration:\*\*\s*(\d+)/);
+		if (itMatch) iteration = parseInt(itMatch[1]);
+
+		const stepMatch = line.match(/^###\s+Step\s+(\d+):\s*(.+)/);
+		if (stepMatch) {
+			if (currentStep) {
+				currentStep.totalChecked = currentStep.checkboxes.filter((c) => c.checked).length;
+				currentStep.totalItems = currentStep.checkboxes.length;
+				steps.push(currentStep);
+			}
+			currentStep = {
+				number: parseInt(stepMatch[1]),
+				name: stepMatch[2].trim(),
+				status: "not-started",
+				checkboxes: [],
+				totalChecked: 0,
+				totalItems: 0,
+			};
+			continue;
+		}
+		if (currentStep) {
+			const ss = line.match(/\*\*Status:\*\*\s*(.*)/);
+			if (ss) {
+				const s = ss[1];
+				if (s.includes("✅") || s.toLowerCase().includes("complete")) currentStep.status = "complete";
+				else if (s.includes("🟨") || s.toLowerCase().includes("progress"))
+					currentStep.status = "in-progress";
+			}
+			const cb = line.match(/^\s*-\s*\[([ xX])\]\s*(.*)/);
+			if (cb)
+				currentStep.checkboxes.push({ text: cb[2].trim(), checked: cb[1].toLowerCase() === "x" });
+		}
+	}
+	if (currentStep) {
+		currentStep.totalChecked = currentStep.checkboxes.filter((c) => c.checked).length;
+		currentStep.totalItems = currentStep.checkboxes.length;
+		steps.push(currentStep);
+	}
+	return { steps, reviewCounter, iteration };
+}
+
+// ── STATUS.md Generation ─────────────────────────────────────────────
+
+/**
+ * Generate an initial STATUS.md from a parsed task.
+ *
+ * @param task - Parsed task (from parsePromptMd or orchestrator ParsedTask)
+ * @returns Complete STATUS.md content string
+ */
+export function generateStatusMd(task: {
+	taskId: string;
+	taskName: string;
+	reviewLevel: number;
+	size: string;
+	steps: StepInfo[];
+}): string {
+	const now = new Date().toISOString().slice(0, 10);
+	const lines: string[] = [
+		`# ${task.taskId}: ${task.taskName} — Status`,
+		"",
+		`**Current Step:** Not Started`,
+		`**Status:** 🔵 Ready for Execution`,
+		`**Last Updated:** ${now}`,
+		`**Review Level:** ${task.reviewLevel}`,
+		`**Review Counter:** 0`,
+		`**Iteration:** 0`,
+		`**Size:** ${task.size}`,
+		"",
+		"---",
+		"",
+	];
+	for (const step of task.steps) {
+		lines.push(`### Step ${step.number}: ${step.name}`, `**Status:** ⬜ Not Started`, "");
+		for (const cb of step.checkboxes) lines.push(`- [ ] ${cb.text}`);
+		lines.push("", "---", "");
+	}
+	lines.push(
+		"## Reviews",
+		"",
+		"| # | Type | Step | Verdict | File |",
+		"|---|------|------|---------|------|",
+		"",
+		"---",
+		"",
+		"## Discoveries",
+		"",
+		"| Discovery | Disposition | Location |",
+		"|-----------|-------------|----------|",
+		"",
+		"---",
+		"",
+		"## Execution Log",
+		"",
+		"| Timestamp | Action | Outcome |",
+		"|-----------|--------|---------|",
+		`| ${now} | Task staged | STATUS.md auto-generated by task-runner |`,
+		"",
+		"---",
+		"",
+		"## Blockers",
+		"",
+		"*None*",
+		"",
+		"---",
+		"",
+		"## Notes",
+		"",
+		"*Reserved for execution notes*",
+	);
+	return lines.join("\n");
+}
+
+// ── STATUS.md Mutation ───────────────────────────────────────────────
+
+/**
+ * Update a metadata field in STATUS.md.
+ *
+ * Matches `**Field:** value` patterns and replaces the value.
+ *
+ * @param statusPath - Absolute path to STATUS.md
+ * @param field - Field name (e.g., "Status", "Current Step")
+ * @param value - New value
+ */
+export function updateStatusField(statusPath: string, field: string, value: string): void {
+	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
+	const pattern = new RegExp(
+		`(\\*\\*${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\*\\*\\s*)(.+)`,
+	);
+	if (pattern.test(content)) {
+		content = content.replace(pattern, `$1${value}`);
+	} else {
+		content = content.replace(/(\*\*[^*]+:\*\*\s*.+\n)/, `$1**${field}:** ${value}\n`);
+	}
+	writeFileSync(statusPath, content);
+}
+
+/**
+ * Update a step's status in STATUS.md.
+ *
+ * @param statusPath - Absolute path to STATUS.md
+ * @param stepNum - Step number to update
+ * @param status - New status
+ */
+export function updateStepStatus(
+	statusPath: string,
+	stepNum: number,
+	status: "not-started" | "in-progress" | "complete",
+): void {
+	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
+	const emoji =
+		status === "complete"
+			? "✅ Complete"
+			: status === "in-progress"
+				? "🟨 In Progress"
+				: "⬜ Not Started";
+	const lines = content.split("\n");
+	let inTarget = false;
+	for (let i = 0; i < lines.length; i++) {
+		const sm = lines[i].match(/^###\s+Step\s+(\d+):/);
+		if (sm) inTarget = parseInt(sm[1]) === stepNum;
+		if (inTarget && lines[i].match(/^\*\*Status:\*\*/)) {
+			lines[i] = `**Status:** ${emoji}`;
+			break;
+		}
+	}
+	writeFileSync(statusPath, lines.join("\n"));
+}
+
+/**
+ * Append a row to a named table section in STATUS.md.
+ *
+ * @param statusPath - Absolute path to STATUS.md
+ * @param sectionName - Section heading (e.g., "Execution Log", "Reviews")
+ * @param row - Markdown table row to append
+ */
+export function appendTableRow(statusPath: string, sectionName: string, row: string): void {
+	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
+	const lines = content.split("\n");
+	let insertIdx = -1,
+		inSection = false,
+		lastTableRow = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (lines[i].match(new RegExp(`^##\\s+${sectionName}`))) {
+			inSection = true;
+			continue;
+		}
+		if (inSection) {
+			if (lines[i].match(/^##\s/) || lines[i].trim() === "---") {
+				insertIdx = lastTableRow >= 0 ? lastTableRow + 1 : i;
+				break;
+			}
+			if (lines[i].startsWith("|") && !lines[i].match(/^\|[\s-|]+\|$/)) {
+				lastTableRow = i;
+			}
+		}
+	}
+	if (insertIdx === -1) {
+		insertIdx = lastTableRow >= 0 ? lastTableRow + 1 : lines.length;
+	}
+	lines.splice(insertIdx, 0, row);
+	writeFileSync(statusPath, lines.join("\n"));
+}
+
+/**
+ * Log an execution event to the Execution Log table in STATUS.md.
+ */
+export function logExecution(statusPath: string, action: string, outcome: string): void {
+	const ts = new Date().toISOString().slice(0, 16).replace("T", " ");
+	appendTableRow(statusPath, "Execution Log", `| ${ts} | ${action} | ${outcome} |`);
+}
+
+/**
+ * Log a review entry to the Reviews table in STATUS.md.
+ */
+export function logReview(
+	statusPath: string,
+	num: string,
+	type: string,
+	stepNum: number,
+	verdict: string,
+	file: string,
+): void {
+	appendTableRow(
+		statusPath,
+		"Reviews",
+		`| ${num} | ${type} | Step ${stepNum} | ${verdict} | ${file} |`,
+	);
+}
+
+/**
+ * Sanitize steering message content for safe injection into a markdown table row.
+ * Collapses newlines, escapes pipe characters, and truncates to 200 chars.
+ */
+export function sanitizeSteeringContent(content: string): string {
+	let s = content.replace(/\r?\n/g, " / ").replace(/\|/g, "\\|");
+	if (s.length > 200) s = s.slice(0, 197) + "...";
+	return s;
+}
+
+// ── Step Completion Logic ────────────────────────────────────────────
+
+/**
+ * Determine whether a parsed step is complete.
+ *
+ * A step is complete when its status is explicitly "complete" OR
+ * when all checkboxes are checked (with at least one checkbox present).
+ *
+ * @param step - Parsed step info (or undefined)
+ * @returns true if the step should be considered complete
+ */
+export function isStepComplete(step: StepInfo | undefined): boolean {
+	if (!step) return false;
+	if (step.status === "complete") return true;
+	return step.totalChecked === step.totalItems && step.totalItems > 0;
+}
+
+/**
+ * Determine whether a step is "low-risk" and should skip reviews.
+ *
+ * Low-risk steps: Step 0 (Preflight) and the final step (Delivery/Docs).
+ *
+ * @param stepNumber - The 0-based step number
+ * @param totalSteps - Total number of steps in the task
+ * @returns true if the step should skip plan and code reviews
+ */
+export function isLowRiskStep(stepNumber: number, totalSteps: number): boolean {
+	if (totalSteps <= 0) return false;
+	const lastStepIndex = totalSteps - 1;
+	return stepNumber === 0 || stepNumber === lastStepIndex;
+}
+
+// ── Review Helpers ───────────────────────────────────────────────────
+
+/**
+ * Extract a review verdict from review file content.
+ *
+ * Searches for standard verdict patterns (APPROVE, REVISE, RETHINK)
+ * with fallback to non-standard formats.
+ *
+ * @param reviewContent - Raw content of a review output file
+ * @returns Uppercase verdict string
+ */
+export function extractVerdict(reviewContent: string): string {
+	// Primary: standard format "### Verdict: APPROVE|REVISE|RETHINK"
+	const match = reviewContent.match(/###?\s*Verdict[:\s]*(APPROVE|REVISE|RETHINK)/i);
+	if (match) return match[1].toUpperCase();
+
+	// Tolerate non-standard verdict formats
+	const lower = reviewContent.toLowerCase();
+	if (
+		lower.includes("changes requested") ||
+		lower.includes("request changes") ||
+		lower.includes("needs revision")
+	)
+		return "REVISE";
+	if (
+		lower.includes("approve") &&
+		!lower.includes("do not approve") &&
+		!lower.includes("cannot approve")
+	)
+		return "APPROVE";
+	if (lower.includes("rethink") || lower.includes("re-think")) return "RETHINK";
+
+	return "UNKNOWN";
+}
+
+// ── Git Helpers ──────────────────────────────────────────────────────
+
+/**
+ * Get the current HEAD commit SHA (short form).
+ *
+ * @returns Short commit SHA or empty string on failure
+ */
+export function getHeadCommitSha(): string {
+	try {
+		const result = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
+			encoding: "utf-8",
+			timeout: 5000,
+		});
+		return result.status === 0 ? (result.stdout || "").trim() : "";
+	} catch {
+		return "";
+	}
+}
+
+/**
+ * Find the git commit SHA where a specific step was completed.
+ *
+ * Workers commit at step boundaries with messages like:
+ *   feat(TP-048): complete Step N — description
+ *
+ * @param stepNumber - Step number to search for
+ * @param taskId - Task ID prefix in commit message
+ * @param since - Optional base commit to search from
+ * @returns Commit SHA if found, or empty string
+ */
+export function findStepBoundaryCommit(stepNumber: number, taskId: string, since?: string): string {
+	try {
+		const args = [
+			"log",
+			"--oneline",
+			"--grep",
+			`complete Step ${stepNumber}`,
+			"--grep",
+			taskId,
+			"--all-match",
+			"-1",
+			"--format=%H",
+		];
+		if (since) args.push(`${since}..HEAD`);
+		const result = spawnSync("git", args, {
+			encoding: "utf-8",
+			timeout: 5000,
+		});
+		return result.status === 0 ? (result.stdout || "").trim() : "";
+	} catch {
+		return "";
+	}
+}
+
+// ── Review Request Generation ────────────────────────────────────────
+
+/**
+ * Standards resolution config shape (minimal, no TaskConfig dependency).
+ */
+export interface StandardsConfig {
+	docs: string[];
+	rules: string[];
+}
+
+/**
+ * Resolve which standards apply to a task based on its area.
+ *
+ * @param globalStandards - Project-level standards
+ * @param overrides - Per-area overrides keyed by area name
+ * @param taskAreas - Task area definitions keyed by area name
+ * @param taskFolder - Absolute task folder path
+ * @returns Resolved standards for this task
+ */
+export function resolveStandards(
+	globalStandards: StandardsConfig,
+	overrides: Record<string, Partial<StandardsConfig>>,
+	taskAreas: Record<string, { path: string; [key: string]: any }>,
+	taskFolder: string,
+): StandardsConfig {
+	const normalizedFolder = taskFolder.replace(/\\/g, "/");
+	for (const [areaName, areaCfg] of Object.entries(taskAreas)) {
+		const areaPath = areaCfg.path.replace(/\\/g, "/");
+		if (normalizedFolder.includes(areaPath)) {
+			const override = overrides[areaName];
+			if (override) {
+				return {
+					docs: override.docs ?? globalStandards.docs,
+					rules: override.rules ?? globalStandards.rules,
+				};
+			}
+			break;
+		}
+	}
+	return { docs: globalStandards.docs, rules: globalStandards.rules };
+}
+
+/**
+ * Generate a review request document for a plan or code review.
+ *
+ * @param type - Review type (plan or code)
+ * @param stepNum - Step number being reviewed
+ * @param stepName - Step name
+ * @param taskPromptPath - Path to the task's PROMPT.md
+ * @param taskFolder - Path to the task folder
+ * @param projectName - Project name from config
+ * @param standards - Resolved standards for this task
+ * @param outputPath - Path where the reviewer should write output
+ * @param stepBaselineCommit - Optional baseline commit for code review diffs
+ * @returns Complete review request markdown content
+ */
+export function generateReviewRequest(
+	type: "plan" | "code",
+	stepNum: number,
+	stepName: string,
+	taskPromptPath: string,
+	taskFolder: string,
+	projectName: string,
+	standards: StandardsConfig,
+	outputPath: string,
+	stepBaselineCommit?: string,
+): string {
+	const standardsDocs = standards.docs.map((d) => `   - ${d}`).join("\n");
+	const standardsRules = standards.rules.map((r) => `- ${r}`).join("\n");
+	const statusPath = join(taskFolder, "STATUS.md");
+
+	if (type === "plan") {
+		return [
+			`# Review Request: Plan Review`,
+			"",
+			`You are reviewing an implementation plan for a ${projectName} task.`,
+			`You have full tool access — use \`read\` to examine files and \`bash\` to run commands.`,
+			"",
+			`## Task Context`,
+			"",
+			`- **Task PROMPT:** ${taskPromptPath}`,
+			`- **Task STATUS:** ${statusPath}`,
+			`- **Step being planned:** Step ${stepNum}: ${stepName}`,
+			"",
+			`## Instructions`,
+			"",
+			`1. Read the PROMPT.md for full requirements`,
+			`2. Read STATUS.md for progress so far`,
+			`3. Check relevant source files for existing patterns:`,
+			standardsDocs,
+			"",
+			`## Project Standards`,
+			"",
+			standardsRules,
+			"",
+			`## Output`,
+			"",
+			`Write your review to: \`${outputPath}\``,
+		].join("\n");
+	}
+
+	const diffCmd = stepBaselineCommit
+		? `git diff ${stepBaselineCommit}..HEAD --name-only`
+		: `git diff --name-only`;
+	const diffFullCmd = stepBaselineCommit ? `git diff ${stepBaselineCommit}..HEAD` : `git diff`;
+
+	return [
+		`# Review Request: Code Review`,
+		"",
+		`You are reviewing code changes for a ${projectName} task.`,
+		`You have full tool access — use \`read\` to examine files and \`bash\` to run commands.`,
+		"",
+		`## Task Context`,
+		"",
+		`- **Task PROMPT:** ${taskPromptPath}`,
+		`- **Task STATUS:** ${statusPath}`,
+		`- **Step reviewed:** Step ${stepNum}: ${stepName}`,
+		...(stepBaselineCommit ? [`- **Step baseline commit:** ${stepBaselineCommit}`] : []),
+		"",
+		`## Instructions`,
+		"",
+		`1. Run \`${diffCmd}\` to see files changed in this step`,
+		`   Then \`${diffFullCmd}\` for the full diff`,
+		`   **Important:** The worker commits code via checkpoints, so plain \`git diff\` may show nothing.`,
+		`   Always use the baseline commit range above to see all step changes.`,
+		`2. Read changed files in full for context`,
+		`3. Check neighboring files for pattern consistency`,
+		`4. Check standards:`,
+		standardsDocs,
+		"",
+		`## Project Standards`,
+		"",
+		standardsRules,
+		"",
+		`## Output`,
+		"",
+		`Write your review to: \`${outputPath}\``,
+	].join("\n");
+}
+
+// ── Display Helpers ──────────────────────────────────────────────────
+
+/**
+ * Convert a kebab-case name to Title Case for display.
+ */
+export function displayName(name: string): string {
+	return name
+		.split("-")
+		.map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+		.join(" ");
+}

package/src/orchestrator/tmux-compat.ts

@@ -0,0 +1,37 @@
+/**
+ * Migration-only helpers for legacy TMUX-shaped persisted lane fields.
+ *
+ * Runtime V2 no longer accepts TMUX config/runtime contracts. The only
+ * compatibility retained here is one-release state ingress normalization for
+ * `lanes[].tmuxSessionName` → `lanes[].laneSessionId`.
+ */
+
+export interface LaneSessionAliasTarget {
+	laneSessionId?: unknown;
+	tmuxSessionName?: unknown;
+}
+
+/**
+ * Read canonical + legacy lane session fields from a lane-like record.
+ */
+export function readLaneSessionAliases(target: LaneSessionAliasTarget): {
+	laneSessionId: unknown;
+	tmuxSessionName: unknown;
+} {
+	return {
+		laneSessionId: target.laneSessionId,
+		tmuxSessionName: target.tmuxSessionName,
+	};
+}
+
+/**
+ * Normalize tmuxSessionName -> laneSessionId in place and remove legacy key.
+ */
+export function normalizeLaneSessionAlias(target: LaneSessionAliasTarget): void {
+	if (typeof target.laneSessionId !== "string" && typeof target.tmuxSessionName === "string") {
+		target.laneSessionId = target.tmuxSessionName;
+	}
+	if ("tmuxSessionName" in target) {
+		delete target.tmuxSessionName;
+	}
+}