@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/internal-urls/issue-pr-protocol.ts

@@ -375,8 +375,10 @@ function buildSingleResource({
 
 function formatFileLine(idx: number, file: PrDiffFile, repo: string, prNumber: number): string {
 	const stats = file.changeType === "binary" ? "(binary)" : `+${file.additions} -${file.deletions}`;
-	const rename = file.oldPath ? `  (renamed from ${file.oldPath})` : "";
-	return `${idx}. ${file.path}  ${stats}  [${file.changeType}]${rename}\n   pr://${repo}/${prNumber}/diff/${idx}`;
+	const escapedNote = file.pathEscaped ? " (escaped non-UTF-8 name)" : "";
+	const renameNote = file.oldPathEscaped ? " (escaped non-UTF-8 name)" : "";
+	const rename = file.oldPath ? `  (renamed from ${file.oldPath}${renameNote})` : "";
+	return `${idx}. ${file.path}${escapedNote}  ${stats}  [${file.changeType}]${rename}\n   pr://${repo}/${prNumber}/diff/${idx}`;
 }
 
 async function fetchAndRenderPrDiff(

package/src/lsp/config.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { $which, isRecord, logger, pathIsWithin } from "@gajae-code/utils";
+import * as piUtils from "@gajae-code/utils";
+import { isRecord, logger, pathIsWithin } from "@gajae-code/utils";
 import { YAML } from "bun";
 import { getConfigDirPaths } from "../config";
 import { type ClaudePluginRoot, getPreloadedPluginRoots } from "../discovery/helpers";
@@ -332,13 +333,13 @@ export function resolveCommand(command: string, cwd: string): string | null {
 	}
 
 	// Fall back to $PATH
-	return $which(command);
+	return piUtils.$which(command);
 }
 
 /** Resolve an LSP executable without consulting project-controlled bin directories. */
 function resolveTrustedLspCommand(command: string, cwd: string): string | null {
 	if (!path.isAbsolute(command) && (command.includes("/") || command.includes("\\"))) return null;
-	const discovered = path.isAbsolute(command) ? command : $which(command);
+	const discovered = path.isAbsolute(command) ? command : piUtils.$which(command);
 	if (!discovered) return null;
 	if (isProjectControlledPath(discovered, cwd)) return null;
 	const canonical = canonicalExistingPath(discovered);

package/src/lsp/path-trust.ts

@@ -63,19 +63,25 @@ export function isProjectControlledPath(candidate: string, cwd: string): boolean
 	const home = os.homedir();
 	const stopPaths = new Set([path.resolve(home), canonicalPath(home)].map(normalizePathForComparison));
 	const lexicalTrustRoot = findProjectTrustRoot(cwd, stopPaths);
-	if (lexicalTrustRoot !== undefined && pathIsLexicallyWithin(lexicalTrustRoot, candidate)) return true;
+	const candidateIsHomeScoped = pathIsLexicallyWithin(home, candidate) || pathIsWithin(home, candidate);
+	if (
+		lexicalTrustRoot !== undefined &&
+		pathIsLexicallyWithin(lexicalTrustRoot, candidate) &&
+		(!candidateIsHomeScoped || pathIsLexicallyWithin(home, lexicalTrustRoot))
+	)
+		return true;
 
 	const canonicalTrustRoots = new Set<string>();
 	if (lexicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(lexicalTrustRoot));
 	const canonicalTrustRoot = findProjectTrustRoot(canonicalPath(cwd), stopPaths);
-	if (canonicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalTrustRoot);
+	if (canonicalTrustRoot !== undefined) canonicalTrustRoots.add(canonicalPath(canonicalTrustRoot));
 	for (const trustRoot of canonicalTrustRoots) {
 		if (
-			pathIsLexicallyWithin(trustRoot, canonicalParentPath(candidate)) ||
-			pathIsWithin(trustRoot, canonicalPath(candidate))
-		) {
+			(pathIsLexicallyWithin(trustRoot, canonicalParentPath(candidate)) ||
+				pathIsWithin(trustRoot, canonicalPath(candidate))) &&
+			(!candidateIsHomeScoped || pathIsLexicallyWithin(home, trustRoot) || pathIsWithin(home, trustRoot))
+		)
 			return true;
-		}
 	}
 	return false;
 }

package/src/main.ts

@@ -39,7 +39,9 @@ import { BUNDLED_GROK_BUILD_EXTENSION_ID, getBundledGrokBuildExtensionFactory }
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import { releaseLaunchWorktreeReservationAfterRegistration } from "./gjc-runtime/launch-worktree-reservation";
 import { persistCoordinatorRuntimeInputReady } from "./gjc-runtime/session-state-sidecar";
+import { assertMasterLaunchArgs, assertMasterLaunchDisposition, createMasterModeContext } from "./master-mode/context";
 import type { AcpStartupOptions } from "./modes/acp/startup-options";
 import type { SessionSelectionResult } from "./modes/components/session-selector";
 import type { InteractiveMode } from "./modes/interactive-mode";
@@ -56,7 +58,7 @@ import {
 	discoverAuthStorage,
 } from "./sdk";
 import { processIncarnation } from "./sdk/broker/process-incarnation";
-import { SessionIndex } from "./sdk/broker/session-index";
+import { newMasterAttestationEpoch, resolveSessionLocator, SessionIndex } from "./sdk/broker/session-index";
 import type { AgentSession } from "./session/agent-session";
 import { SessionMigrationBusyError } from "./session/internal/session-open-errors";
 import {
@@ -349,7 +351,9 @@ export async function submitInteractiveInput(
 		| "checkShutdownRequested"
 		| "waitForAgentEnd"
 	>,
-	session: Pick<AgentSession, "prompt" | "promptCustomMessage">,
+	session: Pick<AgentSession, "prompt" | "promptCustomMessage"> & {
+		continuePersistedHistory?: AgentSession["continuePersistedHistory"];
+	},
 	input: SubmittedUserInput,
 ): Promise<void> {
 	if (input.cancelled) {
@@ -357,8 +361,13 @@ export async function submitInteractiveInput(
 	}
 
 	try {
+		if (input.started) {
+			if (!session.continuePersistedHistory) throw new Error("Session continuation is unavailable.");
+			await session.continuePersistedHistory();
+			return;
+		}
 		// Continue shortcuts submit an already-started empty prompt with no optimistic user message.
-		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
+		if (!mode.markPendingSubmissionStarted(input)) {
 			return;
 		}
 		const agentEnd = mode.waitForAgentEnd();
@@ -745,6 +754,9 @@ export async function runInteractiveMode(
 	if (
 		shouldOfferAutomaticOnboarding({
 			normalInteractive: true,
+			automation:
+				/^(?:1|true|yes|on)$/i.test(process.env.CI ?? "") ||
+				/^(?:1|true|yes|on)$/i.test(process.env.GJC_AUTOMATION ?? ""),
 			initialMessage,
 			initialMessages,
 			initialImages,
@@ -1359,6 +1371,7 @@ export async function runRootCommand(
 	deps: RunRootCommandDependencies = {},
 ): Promise<void> {
 	const parsedArgs = parsed;
+	assertMasterLaunchArgs(parsedArgs);
 	let initialThemeInitialized = false;
 	let autoChdirApplied = false;
 	let bareResumeSessionManager: SessionManager | undefined;
@@ -1546,6 +1559,22 @@ export async function runRootCommand(
 		print: Boolean(parsedArgs.print),
 		mode: parsedArgs.mode,
 	});
+	// Master admission runs unconditionally and BEFORE any session state is
+	// opened or created. Nesting it under nonInteractiveError skipped it for a
+	// non-TTY launch carrying prepared input, which resolves to autoPrint with no
+	// error, so `--master <prompt>` proceeded as an ordinary auto-print run.
+	try {
+		assertMasterLaunchDisposition({
+			master: parsedArgs.master,
+			isInteractive: disposition.isInteractive,
+			autoPrint: disposition.autoPrint,
+			nonInteractiveError: disposition.nonInteractiveError,
+		});
+	} catch (error) {
+		process.stderr.write(`${chalk.red(error instanceof Error ? error.message : "Invalid master launch")}\n`);
+		if (!deps.suppressProcessExit) process.exitCode = 1;
+		return;
+	}
 	if (disposition.nonInteractiveError) {
 		process.stderr.write(`${chalk.red(disposition.nonInteractiveError)}\n`);
 		process.exit(1);
@@ -1669,6 +1698,14 @@ export async function runRootCommand(
 			}
 		}
 	}
+	const masterModeContext =
+		parsedArgs.master === true && sessionManager
+			? createMasterModeContext(
+					parsedArgs.masterScope ?? "repo",
+					sessionManager.getSessionId(),
+					newMasterAttestationEpoch(),
+				)
+			: undefined;
 
 	const { options: sessionOptions } = await logger.time(
 		"buildSessionOptions",
@@ -1735,6 +1772,7 @@ export async function runRootCommand(
 	sessionOptions.notificationHostModeSupported = isInteractive;
 	sessionOptions.sdkHostModeSupported = isInteractive;
 	sessionOptions.settings = settingsInstance;
+	sessionOptions.masterModeContext = masterModeContext;
 	if (isInteractive && sessionOptions.mcpConfigPath) {
 		sessionOptions.deferMcpConfigStartup = true;
 	}
@@ -1819,7 +1857,7 @@ export async function runRootCommand(
 	const directSessionId = process.env.GJC_LIFECYCLE_REQUEST_ID ? undefined : sessionManager?.getSessionId();
 	if (directSessionId) {
 		const sessionIndex = new SessionIndex(settingsInstance.getAgentDir());
-		const locator = { repo: sessionManager?.getCwd() ?? cwd, stateRoot: settingsInstance.getAgentDir() };
+		const locator = await resolveSessionLocator(sessionManager?.getCwd() ?? cwd, settingsInstance.getAgentDir());
 		// A pid is reusable, so the broker's teardown fence needs this session's OS
 		// start incarnation recorded alongside the pid it publishes.
 		const directSessionIncarnation = processIncarnation(process.pid);
@@ -1830,7 +1868,31 @@ export async function runRootCommand(
 			endpointGeneration: 0,
 			pid: process.pid,
 			...(directSessionIncarnation ? { processIncarnation: directSessionIncarnation } : {}),
+			...(masterModeContext && directSessionIncarnation
+				? {
+						masterRole: {
+							version: 2,
+							ownerSessionId: masterModeContext.ownerSessionId,
+							launchPid: process.pid,
+							launchProcessIncarnation: directSessionIncarnation,
+							role: "master" as const,
+							attestationEpoch: masterModeContext.attestationEpoch,
+						},
+					}
+				: {}),
 		});
+		if (locator.worktreeRoot !== null) {
+			try {
+				await releaseLaunchWorktreeReservationAfterRegistration(
+					settingsInstance.getAgentDir(),
+					locator.worktreeRoot,
+				);
+			} catch (error) {
+				logger.warn("Failed to release launch worktree reservation after host registration", {
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		}
 		postmortem.register("direct-session-index", async () => {
 			await sessionIndex.append({
 				type: "host_unregistered",

package/src/master-mode/context.ts

@@ -0,0 +1,50 @@
+import { randomBytes } from "node:crypto";
+import type { Args } from "../cli/args";
+
+export type MasterScope = "repo" | "pwd" | "global";
+
+/**
+ * Process-local master authority. Its capability accessor is deliberately the
+ * only way to reach the raw capability; this context is never serializable.
+ */
+export interface MasterModeContext {
+	readonly scope: MasterScope;
+	readonly ownerSessionId: string;
+	readonly attestationEpoch: string;
+	getCapability(): string;
+}
+
+export function createMasterModeContext(
+	scope: MasterScope,
+	ownerSessionId: string,
+	attestationEpoch: string,
+): MasterModeContext {
+	const capability = randomBytes(32).toString("base64url");
+	return { scope, ownerSessionId, attestationEpoch, getCapability: () => capability };
+}
+
+/** Reject routes that cannot establish an interactive, durable master session. */
+export function assertMasterLaunchArgs(parsed: Args): void {
+	if (parsed.master !== true) return;
+	if (
+		parsed.print === true ||
+		parsed.mode !== undefined ||
+		parsed.export !== undefined ||
+		parsed.listModels !== undefined ||
+		parsed.noSession === true
+	) {
+		throw new Error("--master requires an interactive durable TUI launch");
+	}
+}
+
+export function assertMasterLaunchDisposition(input: {
+	master: boolean | undefined;
+	isInteractive: boolean;
+	autoPrint: boolean;
+	nonInteractiveError?: string;
+}): void {
+	if (input.master !== true) return;
+	if (!input.isInteractive || input.autoPrint || input.nonInteractiveError !== undefined) {
+		throw new Error("--master requires an interactive TTY launch");
+	}
+}

package/src/master-mode/first-request.ts

@@ -0,0 +1,65 @@
+import { canonicalSessionCwd, sessionWorktreeRoot } from "../sdk/broker/session-index";
+import type { MasterScope } from "./context";
+import { collectMasterPeerSnapshot, type MasterPeerSnapshotLifecycle, renderMasterPeerSnapshot } from "./snapshot";
+
+export const MASTER_PEER_SNAPSHOT_CUSTOM_TYPE = "master-peer-snapshot";
+
+/** The injected message shape consumed by the agent-session contributor seam. */
+export interface MasterPeerSnapshotMessage {
+	customType: string;
+	content: string;
+	display: false;
+	attribution: "agent";
+}
+
+export interface MasterPeerSnapshotContributorInput {
+	readonly lifecycle: MasterPeerSnapshotLifecycle;
+	readonly ownerSessionId: string;
+	/** Current transcript/session identity; differs from ownerSessionId after a branch or switch. */
+	readonly getSessionId?: () => string;
+	readonly scope: MasterScope;
+	/** Live cwd accessor; resolved at injection time, not at registration. */
+	readonly getCwd: () => string;
+	/**
+	 * Whether a prior injection was persisted to the session branch. A persisted
+	 * block proves a first request was accepted, so later turns never duplicate
+	 * it; a pre-accept cancellation persists nothing and the next attempt
+	 * re-collects a fresh snapshot.
+	 */
+	readonly hasPersistedInjection: () => boolean;
+	readonly onError?: (error: unknown) => void;
+}
+
+/**
+ * Builds the one-shot before-agent-start contributor that injects the scoped,
+ * no-probe master peer snapshot immediately before the first accepted provider
+ * request. Idle masters never collect: the snapshot is gathered only when a
+ * prompt actually starts.
+ */
+export function createMasterPeerSnapshotContributor(
+	input: MasterPeerSnapshotContributorInput,
+): () => Promise<MasterPeerSnapshotMessage | undefined> {
+	return async () => {
+		try {
+			if (input.hasPersistedInjection()) return undefined;
+			const anchorCwd = await canonicalSessionCwd(input.getCwd());
+			const snapshot = await collectMasterPeerSnapshot({
+				lifecycle: input.lifecycle,
+				actor: { id: input.ownerSessionId, namespace: "sdk:master-snapshot" },
+				ownerSessionId: input.ownerSessionId,
+				...(input.getSessionId === undefined ? {} : { currentSessionId: input.getSessionId() }),
+				scope: input.scope,
+				requestAnchor: { cwd: anchorCwd, worktreeRoot: await sessionWorktreeRoot(anchorCwd) },
+			});
+			return {
+				customType: MASTER_PEER_SNAPSHOT_CUSTOM_TYPE,
+				content: renderMasterPeerSnapshot(snapshot),
+				display: false,
+				attribution: "agent",
+			};
+		} catch (error) {
+			input.onError?.(error);
+			return undefined;
+		}
+	};
+}

package/src/master-mode/snapshot.ts

@@ -0,0 +1,205 @@
+import {
+	type ResolvedScopeV1,
+	resolveScopeRequest,
+	type ScopeNameV1,
+	type ScopeRequestV1,
+	type SdkSearchResultV1,
+	type SdkSearchRowV1,
+	sdkSearchResultV1,
+} from "../sdk/broker/session-scope";
+import type { SessionLifecycleActor, SessionListOutcome, SessionListRequest } from "../sdk/lifecycle/service";
+
+export type MasterPeerSnapshot = {
+	readonly status: SdkSearchResultV1["status"];
+	readonly scope: ResolvedScopeV1;
+	readonly observedAt: string;
+	readonly indexSeq?: number;
+	readonly rows: readonly SdkSearchRowV1[];
+	readonly truncated?: boolean;
+};
+
+const MASTER_PEER_SNAPSHOT_MAX_ROWS = 256;
+const MASTER_PEER_SNAPSHOT_MAX_BYTES = 64 * 1024;
+
+/** The scoped Broker surface needed for the one-time master peer snapshot. */
+export interface MasterPeerSnapshotLifecycle {
+	list(request: Omit<SessionListRequest, "operation">): Promise<SessionListOutcome>;
+}
+
+export interface CollectMasterPeerSnapshotInput {
+	readonly lifecycle: MasterPeerSnapshotLifecycle;
+	readonly actor: SessionLifecycleActor;
+	readonly ownerSessionId: string;
+	readonly currentSessionId?: string;
+	readonly scope: ScopeNameV1;
+	readonly requestAnchor: ScopeRequestV1["requestAnchor"];
+	readonly timeoutMs?: number;
+}
+
+function compareText(left: string, right: string): number {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+
+/**
+ * Orders by session ID, then the complete canonical locator as a deterministic
+ * tie-breaker. The Broker's `live` value is index evidence, not a fresh probe.
+ */
+function compareRows(left: SdkSearchRowV1, right: SdkSearchRowV1): number {
+	const id = compareText(left.id, right.id);
+	if (id !== 0) return id;
+	const cwd = compareText(left.locator.cwd, right.locator.cwd);
+	if (cwd !== 0) return cwd;
+	const worktreeRoot = compareText(left.locator.worktreeRoot ?? "", right.locator.worktreeRoot ?? "");
+	if (worktreeRoot !== 0) return worktreeRoot;
+	return compareText(left.locator.stateRoot, right.locator.stateRoot);
+}
+
+function unavailableSnapshot(scope: ResolvedScopeV1): MasterPeerSnapshot {
+	return {
+		status: "unavailable",
+		scope,
+		observedAt: new Date().toISOString(),
+		rows: [],
+	};
+}
+
+function matchesResolvedScope(left: ResolvedScopeV1, right: ResolvedScopeV1): boolean {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+
+/** Retains a row prefix only when its final escaped prompt block fits the budget. */
+function boundSnapshotRows(
+	snapshot: Omit<MasterPeerSnapshot, "rows" | "truncated">,
+	rows: readonly SdkSearchRowV1[],
+): {
+	rows: readonly SdkSearchRowV1[];
+	truncated: boolean;
+} {
+	const retained: SdkSearchRowV1[] = [];
+	for (const [index, row] of rows.entries()) {
+		if (retained.length >= MASTER_PEER_SNAPSHOT_MAX_ROWS) return { rows: retained, truncated: true };
+
+		retained.push(row);
+		const willTruncate = index < rows.length - 1;
+		const candidate: MasterPeerSnapshot = {
+			...snapshot,
+			rows: retained,
+			...(willTruncate ? { truncated: true } : {}),
+		};
+		if (Buffer.byteLength(renderMasterPeerSnapshot(candidate), "utf8") > MASTER_PEER_SNAPSHOT_MAX_BYTES) {
+			retained.pop();
+			return { rows: retained, truncated: true };
+		}
+		if (willTruncate && retained.length === MASTER_PEER_SNAPSHOT_MAX_ROWS) return { rows: retained, truncated: true };
+	}
+	return { rows: retained, truncated: false };
+}
+
+/**
+ * Collects the first-request peer snapshot through scoped Broker session.list.
+ * It deliberately has no Router or endpoint-probe dependency.
+ */
+export async function collectMasterPeerSnapshot(input: CollectMasterPeerSnapshotInput): Promise<MasterPeerSnapshot> {
+	const request: ScopeRequestV1 = {
+		version: 1,
+		requested: input.scope,
+		requestAnchor: input.requestAnchor,
+	};
+	const resolvedScope = await resolveScopeRequest(request);
+	const outcome = await input.lifecycle.list({
+		actor: input.actor,
+		capability: "session.list",
+		target: { scope: request },
+		...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+	});
+	const result = sdkSearchResultV1(outcome.result);
+	if (!result || !matchesResolvedScope(result.scope, resolvedScope)) return unavailableSnapshot(resolvedScope);
+	const snapshot: Omit<MasterPeerSnapshot, "rows" | "truncated"> = {
+		status: result.status,
+		scope: result.scope,
+		observedAt: result.observedAt,
+		...(result.indexSeq === undefined ? {} : { indexSeq: result.indexSeq }),
+	};
+	const rows = result.rows
+		.filter(row => row.id !== (input.currentSessionId ?? input.ownerSessionId))
+		.sort(compareRows);
+	const bounded = boundSnapshotRows(snapshot, rows);
+	return {
+		...snapshot,
+		rows: bounded.rows,
+		...(bounded.truncated ? { truncated: true } : {}),
+	};
+}
+
+/** Escapes untrusted metadata before it is placed in fixed prompt framing. */
+export function escapeMasterPeerSnapshotText(input: string): string {
+	let firstEscapable = -1;
+	for (let index = 0; index < input.length; index++) {
+		const code = input.charCodeAt(index);
+		if (code === 38 || code === 60 || code === 62 || code === 96) {
+			firstEscapable = index;
+			break;
+		}
+	}
+	if (firstEscapable === -1) return input;
+
+	let output = input.slice(0, firstEscapable);
+	for (let index = firstEscapable; index < input.length; index++) {
+		const character = input[index];
+		if (character === "&") output += "&amp;";
+		else if (character === "<") output += "&lt;";
+		else if (character === ">") output += "&gt;";
+		else if (character === "`") output += "&#96;";
+		else output += character;
+	}
+	return output;
+}
+
+function escapeOptionalText(input: string | null): string | null {
+	return input === null ? null : escapeMasterPeerSnapshotText(input);
+}
+
+function renderedScope(scope: ResolvedScopeV1): ResolvedScopeV1 {
+	const resolved =
+		scope.resolved === null
+			? null
+			: scope.resolved.kind === "repo"
+				? { kind: "repo" as const, worktreeRoot: escapeMasterPeerSnapshotText(scope.resolved.worktreeRoot) }
+				: scope.resolved.kind === "pwd"
+					? { kind: "pwd" as const, cwd: escapeMasterPeerSnapshotText(scope.resolved.cwd) }
+					: { kind: "global" as const, visibility: scope.resolved.visibility };
+	return {
+		version: scope.version,
+		requested: escapeMasterPeerSnapshotText(scope.requested) as ScopeNameV1,
+		requestAnchor: {
+			cwd: escapeMasterPeerSnapshotText(scope.requestAnchor.cwd),
+			worktreeRoot: escapeOptionalText(scope.requestAnchor.worktreeRoot),
+		},
+		resolved,
+		resolution: escapeMasterPeerSnapshotText(scope.resolution) as ResolvedScopeV1["resolution"],
+	};
+}
+
+function renderedRows(rows: readonly SdkSearchRowV1[]): readonly SdkSearchRowV1[] {
+	return rows.map(row => ({
+		id: escapeMasterPeerSnapshotText(row.id),
+		locator: {
+			cwd: escapeMasterPeerSnapshotText(row.locator.cwd),
+			worktreeRoot: escapeOptionalText(row.locator.worktreeRoot),
+			stateRoot: escapeMasterPeerSnapshotText(row.locator.stateRoot),
+		},
+		live: row.live,
+	}));
+}
+
+/** Renders the fixed, escaped prompt block for one master peer observation. */
+export function renderMasterPeerSnapshot(snapshot: MasterPeerSnapshot): string {
+	const content = {
+		scope: renderedScope(snapshot.scope),
+		observedAt: escapeMasterPeerSnapshotText(snapshot.observedAt),
+		...(snapshot.indexSeq === undefined ? {} : { indexSeq: snapshot.indexSeq }),
+		...(snapshot.truncated === undefined ? {} : { truncated: snapshot.truncated }),
+		rows: renderedRows(snapshot.rows),
+	};
+	return `<gjc-master-peer-snapshot>\nstatus: ${escapeMasterPeerSnapshotText(snapshot.status)}\n${JSON.stringify(content)}\n</gjc-master-peer-snapshot>`;
+}