@gajae-code/coding-agent 0.18.5 → 0.18.6

package/src/modes/components/tool-execution.ts

@@ -965,7 +965,7 @@ export class ToolExecutionComponent extends Container {
 			if (this.#expanded && !previews?.some(preview => preview.diff)) {
 				const editMode = this.#editMode;
 				const strategy = editMode ? EDIT_MODE_STRATEGIES[editMode] : undefined;
-				const fallback = strategy?.renderStreamingFallback(this.#args, theme);
+				const fallback = strategy?.renderStreamingPlaceholder(this.#args, theme);
 				if (fallback) context.editStreamingFallback = fallback;
 			}
 			context.renderDiff = renderDiff;

package/src/prompts/tools/ask.md

@@ -8,6 +8,8 @@ Asks user when you need clarification or input during task execution.
 - Use `recommended: <index>` to mark default (0-indexed); " (Recommended)" added automatically
 - Use `questions` for multiple related questions instead of asking one at a time
 - Set `multi: true` on question to allow multiple selections
+- Every question body must contain meaningful, non-whitespace text. Never add empty `metadata`/`ignore` questions.
+- While deep-interview is in the `interviewing` phase, submit exactly one question with the required `deepInterview` metadata on that question. Round 0 needs `round: 0`, `component: "review-topology"`, `dimension: "topology"`, `ambiguity`, and `intent_contract` containing the displayed items and affirmative labels. Later questions need a positive round, component, dimension, and ambiguity. Question prose and `workflowGate` alone cannot record an interview answer. After final-spec persistence transitions to `handoff`, next-workflow/approval choices are ordinary asks without interview round metadata.
 </instruction>
 
 <caution>

package/src/sdk/broker/broker.ts

@@ -1495,6 +1495,16 @@ export class Broker {
 	discovery: BrokerDiscovery | null = null;
 	#lock: string;
 	#owner = randomBytes(12).toString("hex");
+	/** Public publication-incarnation id, fixed at startup; never the endpoint generation. */
+	#diagnosticGeneration = randomBytes(16).toString("hex");
+	/** Trusted build snapshot captured at startup; unknown buildId stays null. */
+	#startupBuild: { packageVersion: string; buildId: string | null } = {
+		packageVersion: packageJson.version,
+		buildId:
+			typeof process.env.GJC_BUILD_ID === "string" && process.env.GJC_BUILD_ID.length > 0
+				? process.env.GJC_BUILD_ID
+				: null,
+	};
 	#sessionListCursors = new Map<string, SessionListCursor>();
 	#chains = new Map<string, Promise<void>>();
 	#spawnInFlight = new Map<string, SpawnInFlight>();
@@ -3868,6 +3878,10 @@ export class Broker {
 				ownerId: this.#owner,
 				pid: process.pid,
 				incarnation,
+				// Observation capability: the startup-fixed generation and the protocol the
+				// broker answers. An old broker simply omits both.
+				diagnosticGeneration: this.#diagnosticGeneration,
+				diagnosticProtocol: 1,
 				host: "127.0.0.1",
 				port,
 				url: `ws://127.0.0.1:${port}`,
@@ -4728,6 +4742,32 @@ export class Broker {
 			? entry.response
 			: error("terminal_uncertain", "lifecycle outcome has no recorded response");
 	}
+	/**
+	 * Published diagnostics for observation clients (SPEC "Result contract").
+	 *
+	 * Everything here is captured once at startup and never recomputed, so a later source
+	 * or package change cannot alter what a running broker reports. No token, socket
+	 * coordinate, argv or environment value is included; the identity fields are the
+	 * internal owner/process/root binding the observer already knows from discovery.
+	 */
+	#publishedDiagnostics(): Promise<BrokerResponse> {
+		// Observation is answered ONLY from an already-owned healthy retained publication.
+		// A broker that owns no publication refuses here and recovers nothing: it does not
+		// publish, ensure, restart or touch the authority to answer.
+		if (this.#publication === null || this.#publicationState !== "healthy-owned") {
+			return Promise.resolve(error("unavailable", "broker publication authority is not owned"));
+		}
+		return Promise.resolve({
+			ok: true,
+			result: {
+				diagnosticProtocol: 1,
+				generation: this.#diagnosticGeneration,
+				build: this.#startupBuild,
+				identity: { ownerId: this.#owner, pid: process.pid, agentRoot: this.settings.agentDir },
+			},
+		});
+	}
+
 	// Wire requests are readiness-gated by BrokerTransport before reaching this dispatcher.
 	handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<BrokerResponse> {
 		if (operation === "broker.status") return Promise.resolve({ ok: true, result: this.status() });
@@ -4768,6 +4808,7 @@ export class Broker {
 			const spawnClose = await this.#maybeCloseSpawnChild(input);
 			if (spawnClose) return spawnClose;
 		}
+		if (operation === "broker.diagnostics") return this.#publishedDiagnostics();
 		if (operation === "session.control") return this.#sessionControl(input, idempotencyKey);
 		if (operation === "session.lookup") {
 			const lookup = publicLifecycleLookupInput(input);
@@ -4937,6 +4978,11 @@ export class Broker {
 			...(operation === "session.close" && typeof input.sessionId === "string"
 				? { intendedSessionId: input.sessionId }
 				: {}),
+			...(operation === "session.close" &&
+			typeof input.endpointGeneration === "number" &&
+			typeof input.endpointIncarnation === "string"
+				? { closeAuthorityBound: true }
+				: {}),
 		};
 		if (!this.ledger.get(identity)) {
 			const matchingOperation = this.ledger.findAnyByOperationKey(operationKey);

package/src/sdk/broker/daemon-entry.ts

@@ -1,7 +1,7 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { type BrokerDiscovery, readBrokerDiscovery, readBrokerRestartIntent } from "./discovery";
 import { withBrokerStartupLock } from "./ensure";
-import { observeProcessIncarnation } from "./process-incarnation";
+import { isProcessIncarnation, observeProcessIncarnation } from "./process-incarnation";
 import { resolveSdkInternalSpawnCommand } from "./runtime";
 
 export interface AuthorizedBrokerSuccessorOptions {
@@ -61,12 +61,15 @@ export async function launchAuthorizedBrokerSuccessor(
 			existing.restartRequestId === options.requestId
 		)
 			return { kind: "adopted" as const, discovery: existing };
-		const command = resolveSdkInternalSpawnCommand("broker-internal");
+		const command = resolveSdkInternalSpawnCommand(
+			process.platform === "win32" ? "broker-internal" : "broker-trampoline-internal",
+		);
 		let child: ChildProcess;
+		const isTrampoline = process.platform !== "win32";
 		try {
 			child = spawn(command.file, [...command.args, "--agent-dir", options.agentDir], {
 				detached: true,
-				stdio: "ignore",
+				stdio: isTrampoline ? ["ignore", "pipe", "ignore"] : "ignore",
 				env: { ...command.env, GJC_BROKER_RESTART_REQUEST: options.requestId },
 				...(command.kind === "bun-source" ? { cwd: command.cwd } : {}),
 			});
@@ -78,14 +81,44 @@ export async function launchAuthorizedBrokerSuccessor(
 			};
 		}
 		let spawnError: Error | undefined;
+		let trampolineOutput = "";
+		let trampolineOutputEnded = !isTrampoline;
+		if (child.stdout)
+			child.stdout
+				.setEncoding("utf8")
+				.on("data", chunk => (trampolineOutput += chunk))
+				.once("end", () => (trampolineOutputEnded = true));
 		child.once("error", childError => {
 			spawnError = childError;
 		});
 		child.unref();
-		return { kind: "spawned" as const, child, spawnError: () => spawnError };
+		return {
+			kind: "spawned" as const,
+			child,
+			isTrampoline,
+			trampolineOutput: () => trampolineOutput,
+			trampolineOutputEnded: () => trampolineOutputEnded,
+			spawnError: () => spawnError,
+		};
 	});
 	if (spawnOutcome.kind !== "spawned") return spawnOutcome;
 	const { child } = spawnOutcome;
+	let successorPid: number | undefined;
+	let successorIncarnation: string | undefined;
+	let trampolineExited = !spawnOutcome.isTrampoline;
+	let trampolineExitCode: number | null = null;
+	let trampolineSignal: NodeJS.Signals | null = null;
+	if (spawnOutcome.isTrampoline)
+		child.once("exit", (code, signal) => {
+			trampolineExitCode = code;
+			trampolineSignal = signal;
+			trampolineExited = true;
+		});
+	if (spawnOutcome.isTrampoline && (child.exitCode !== null || child.signalCode !== null)) {
+		trampolineExitCode = child.exitCode;
+		trampolineSignal = child.signalCode;
+		trampolineExited = true;
+	}
 	const until = Math.min(Date.now() + Math.max(1, options.deadlineAt - Date.now()), options.deadlineAt);
 	for (;;) {
 		if (spawnOutcome.spawnError())
@@ -94,7 +127,34 @@ export async function launchAuthorizedBrokerSuccessor(
 				reason: "spawn_failed",
 				detail: spawnOutcome.spawnError()?.message,
 			};
-		if (child.exitCode !== null || child.signalCode !== null)
+		if (!spawnOutcome.isTrampoline && (child.exitCode !== null || child.signalCode !== null))
+			return { kind: "refused", reason: "spawn_exited_before_publication" };
+		if (spawnOutcome.isTrampoline && !successorPid) {
+			const report = spawnOutcome.trampolineOutput().trim();
+			const match = /^(\d+)\t([^\r\n]+)$/.exec(report);
+			if (match) {
+				const pid = Number(match[1]);
+				const incarnation = match[2];
+				if (Number.isSafeInteger(pid) && pid > 0 && isProcessIncarnation(incarnation)) {
+					const observed = observeProcessIncarnation(pid);
+					if (observed.status === "present" && observed.incarnation === incarnation) {
+						successorPid = pid;
+						successorIncarnation = incarnation;
+					}
+				}
+			}
+		}
+		if (successorPid) {
+			const observed = observeProcessIncarnation(successorPid);
+			if (
+				observed.status === "absent" ||
+				(observed.status === "present" && observed.incarnation !== successorIncarnation)
+			)
+				return { kind: "refused", reason: "spawn_exited_before_publication" };
+		}
+		if (spawnOutcome.isTrampoline && trampolineExited && spawnOutcome.trampolineOutputEnded() && !successorPid)
+			return { kind: "refused", reason: "spawn_exited_before_publication" };
+		if (spawnOutcome.isTrampoline && trampolineExited && (trampolineSignal !== null || trampolineExitCode !== 0))
 			return { kind: "refused", reason: "spawn_exited_before_publication" };
 		const discovered = await readBrokerDiscovery(options.agentDir);
 		if (
@@ -102,7 +162,8 @@ export async function launchAuthorizedBrokerSuccessor(
 			discovered.packageGeneration === options.packageGeneration &&
 			discovered.restartRequestId === options.requestId
 		)
-			return { kind: "spawned", discovery: discovered };
+			if (!spawnOutcome.isTrampoline || (trampolineExited && spawnOutcome.trampolineOutputEnded()))
+				return { kind: "spawned", discovery: discovered };
 		if (Date.now() >= until) return { kind: "refused", reason: "publication_timeout" };
 		await Bun.sleep(SUCCESSOR_SPAWN_POLL_MS);
 	}

package/src/sdk/broker/discovery.ts

@@ -386,6 +386,14 @@ export interface BrokerDiscovery {
 	ownerId: string;
 	pid: number;
 	incarnation: string;
+	/**
+	 * Public publication-incarnation id for diagnostic observation, fixed at startup.
+	 * Absent on publications written before the capability existed; an observer then
+	 * reports `unsupported` instead of synthesizing compatibility.
+	 */
+	diagnosticGeneration?: string;
+	/** Diagnostic protocol the publisher answers; absent means no capability. */
+	diagnosticProtocol?: number;
 	host: "127.0.0.1";
 	port: number;
 	url: string;

package/src/sdk/broker/ensure.ts

@@ -14,6 +14,7 @@ import {
 	readBrokerDiscovery,
 	readBrokerRestartIntent,
 } from "./discovery";
+import { isProcessIncarnation, observeProcessIncarnation } from "./process-incarnation";
 import {
 	isSdkInternalRuntimeImagePresent,
 	resolveSdkInternalSpawnCommand,
@@ -369,6 +370,7 @@ interface BrokerOwner {
 	stop(): Promise<void>;
 	canReuse(discovery: BrokerDiscovery | null): boolean;
 	markReady(discovery: BrokerDiscovery): boolean;
+	setTarget(pid: number, incarnation: string): void;
 }
 type EnsureInitiator = "discovery" | "fixture-lease";
 type EnsureOutcome =
@@ -453,25 +455,60 @@ async function reapSpawnedBroker(child: ChildProcess, timing: ReapTiming = DEFAU
 	throw new Error(`Detached SDK broker (pid ${child.pid}) did not exit after SIGKILL during reap.`);
 }
 
+async function reapSpawnedBrokerIdentity(
+	pid: number,
+	incarnation: string,
+	timing: ReapTiming = DEFAULT_REAP_TIMING,
+): Promise<void> {
+	const matches = (): boolean => {
+		const observed = observeProcessIncarnation(pid);
+		return observed.status === "present" && observed.incarnation === incarnation;
+	};
+	const gone = (): boolean => observeProcessIncarnation(pid).status === "absent";
+	const signal = (sig: NodeJS.Signals): void => {
+		if (!matches()) return;
+		try {
+			process.kill(pid, sig);
+		} catch {
+			// already exited between identity check and signal delivery
+		}
+	};
+	if (gone() || !matches()) return;
+	// A reported trampoline has already detached this broker from the retained
+	// child handle, so graceful shutdown cannot be observed or reaped reliably.
+	// Force termination keeps discovery-timeout cleanup within its caller's
+	// bounded deadline while the identity check still prevents PID reuse.
+	signal("SIGKILL");
+	await Promise.race([waitForProcessAbsence(pid), sleep(timing.killVerifyMs)]);
+	if (!gone()) throw new Error(`Detached SDK broker (pid ${pid}) did not exit after SIGKILL during reap.`);
+}
+
+async function waitForProcessAbsence(pid: number): Promise<void> {
+	while (observeProcessIncarnation(pid).status !== "absent") await Bun.sleep(10);
+}
+
 function registerBrokerOwner(
 	agentDir: string,
 	child: ChildProcess,
 	timing: ReapTiming = DEFAULT_REAP_TIMING,
 ): BrokerOwner {
-	const incarnation = child.pid === undefined ? undefined : brokerProcessIncarnation(child.pid);
+	let targetPid = child.pid;
+	let targetIncarnation = child.pid === undefined ? undefined : brokerProcessIncarnation(child.pid);
 	let state: "starting" | "ready" | "cleanup-unverified" = "starting";
 	const matches = (discovery: BrokerDiscovery | null): boolean =>
 		Boolean(
 			discovery &&
-				child.pid !== undefined &&
-				incarnation &&
-				discovery.pid === child.pid &&
-				discovery.incarnation === incarnation,
+				targetPid !== undefined &&
+				targetIncarnation !== undefined &&
+				discovery.pid === targetPid &&
+				discovery.incarnation === targetIncarnation,
 		);
 	const owner: BrokerOwner = {
 		async stop(): Promise<void> {
 			try {
-				await reapSpawnedBroker(child, timing);
+				if (targetPid !== undefined && targetIncarnation !== undefined && targetPid !== child.pid)
+					await reapSpawnedBrokerIdentity(targetPid, targetIncarnation, timing);
+				else await reapSpawnedBroker(child, timing);
 			} catch (error) {
 				state = "cleanup-unverified";
 				throw error;
@@ -486,6 +523,10 @@ function registerBrokerOwner(
 			state = "ready";
 			return true;
 		},
+		setTarget(pid, incarnation): void {
+			targetPid = pid;
+			targetIncarnation = incarnation;
+		},
 	};
 	owners.set(agentDir, owner);
 	return owner;
@@ -688,7 +729,11 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 		// that finished between our first read and the lock acquisition.
 		const discoveredUnderLock = await reconcileBrokerGenerationForStartup(settings, deadline);
 		if (discoveredUnderLock) return { kind: "external-discovery", discovery: discoveredUnderLock };
-		const command = resolveSdkInternalSpawnCommand("broker-internal");
+		const command = resolveSdkInternalSpawnCommand(
+			process.platform === "win32" || initiator === "fixture-lease"
+				? "broker-internal"
+				: "broker-trampoline-internal",
+		);
 		spawnLog = await openBrokerSpawnLog(settings.agentDir);
 		// A stale marker must never be misattributed to this spawn; clear it first.
 		await clearBrokerStartupExitRecord(settings.agentDir);
@@ -696,23 +741,83 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 		const childSpawnedAt = Date.now();
 		const child = spawn(command.file, [...command.args, "--agent-dir", settings.agentDir], {
 			detached: true,
-			stdio: ["ignore", "ignore", spawnLog ? spawnLog.handle.fd : "ignore"],
+			stdio: ["ignore", process.platform === "win32" ? "ignore" : "pipe", spawnLog ? spawnLog.handle.fd : "ignore"],
 			env: brokerSpawnEnvironment(command, settings.env),
 			...(command.kind === "bun-source" ? { cwd: command.cwd } : {}),
 		});
+		const isTrampoline = process.platform !== "win32" && initiator !== "fixture-lease";
 		let spawnError: Error | undefined;
+		let childExited = false;
+		let childExitCode: number | null = null;
+		let childSignalCode: NodeJS.Signals | null = null;
+		let brokerDeathObserved = false;
 		child.once("error", error => {
 			spawnError = error;
 		});
-		const childIncarnation = child.pid === undefined ? undefined : brokerProcessIncarnation(child.pid);
+		child.once("close", (code, signal) => {
+			childExited = true;
+			childExitCode = code;
+			childSignalCode = signal;
+		});
+		let trampolineReported = !isTrampoline;
+		let spawnedBrokerPid = isTrampoline ? undefined : child.pid;
+		let spawnedBrokerIncarnation =
+			isTrampoline || child.pid === undefined ? undefined : brokerProcessIncarnation(child.pid);
 		const owner = registerBrokerOwner(settings.agentDir, child);
+		if (isTrampoline && child.stdout) {
+			let output = "";
+			child.stdout.on("data", chunk => {
+				output += Buffer.from(chunk).toString("utf8");
+				const newline = output.indexOf("\n");
+				if (newline < 0) return;
+				const line = output.slice(0, newline).trim();
+				const [rawPid, rawIncarnation] = line?.split("\t") ?? [];
+				const pid = rawPid ? Number(rawPid) : NaN;
+				if (!Number.isSafeInteger(pid) || pid <= 0) return;
+				if (isProcessIncarnation(rawIncarnation)) {
+					const incarnation = rawIncarnation;
+					trampolineReported = true;
+					spawnedBrokerPid = pid;
+					spawnedBrokerIncarnation = incarnation;
+					owner.setTarget(pid, incarnation);
+				}
+			});
+		}
 		child.unref();
 		// The child holds its own duplicate of the descriptor. Failure to close the
 		// parent's diagnostic handle must not discard exact ownership of a live child.
 		await spawnLog?.handle.close().catch(() => undefined);
 		let discoveryError: unknown;
 		while (ensureBrokerTiming.now() < deadline) {
-			if (spawnError || child.exitCode !== null || child.signalCode !== null) break;
+			if (
+				spawnError ||
+				(isTrampoline && childExited && (!trampolineReported || childExitCode !== 0 || childSignalCode !== null)) ||
+				(!isTrampoline && process.platform === "win32" && (child.exitCode !== null || child.signalCode !== null))
+			)
+				break;
+			if (
+				isTrampoline &&
+				trampolineReported &&
+				spawnedBrokerPid !== undefined &&
+				spawnedBrokerIncarnation !== undefined
+			) {
+				const observed = observeProcessIncarnation(spawnedBrokerPid);
+				if (observed.status === "present" && observed.incarnation !== spawnedBrokerIncarnation) {
+					brokerDeathObserved = true;
+					break;
+				}
+				if (observed.status === "absent") {
+					brokerDeathObserved = true;
+					break;
+				}
+			}
+			// The trampoline's stdout line identifies the real broker. Do not read
+			// discovery until that line has been parsed, or a marker from the
+			// trampoline could be trusted as the broker's own startup evidence.
+			if (isTrampoline && !trampolineReported) {
+				await ensureBrokerTiming.sleep(50);
+				continue;
+			}
 			try {
 				const discovered = await readBrokerDiscoveryBeforeDeadline(
 					settings.agentDir,
@@ -724,6 +829,20 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 						await ensureBrokerTiming.sleep(50);
 						continue;
 					}
+					if (isTrampoline && !childExited) {
+						await ensureBrokerTiming.sleep(50);
+						continue;
+					}
+					if (isTrampoline && spawnedBrokerPid !== undefined && spawnedBrokerIncarnation !== undefined) {
+						const observed = observeProcessIncarnation(spawnedBrokerPid);
+						if (
+							observed.status === "absent" ||
+							(observed.status === "present" && observed.incarnation !== spawnedBrokerIncarnation)
+						) {
+							brokerDeathObserved = true;
+							break;
+						}
+					}
 					if (owner.markReady(discovered)) {
 						return initiator === "fixture-lease"
 							? { kind: "local-started-fixture", discovery: discovered, owner, child }
@@ -737,8 +856,13 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 			}
 			await ensureBrokerTiming.sleep(50);
 		}
-		const exitedBeforeDiscovery = child.exitCode !== null || child.signalCode !== null;
-		if (exitedBeforeDiscovery && child.exitCode === 0) {
+		const exitedBeforeDiscovery =
+			(isTrampoline &&
+				(!trampolineReported ||
+					(childExited && (childExitCode !== 0 || childSignalCode !== null)) ||
+					brokerDeathObserved)) ||
+			(!isTrampoline && process.platform === "win32" && (child.exitCode !== null || child.signalCode !== null));
+		if (!isTrampoline && exitedBeforeDiscovery && childExitCode === 0) {
 			// A clean exit means another broker won the ownership lock (two ACP
 			// processes racing a cold broker state, e.g. a provider probe and an
 			// agent launch). The winner may publish its discovery right after our
@@ -765,16 +889,16 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 		const startupExitRecord = await readBrokerStartupExitRecord(settings.agentDir);
 		const trustedMarker =
 			marker &&
-			child.pid !== undefined &&
-			childIncarnation !== undefined &&
-			marker.pid === child.pid &&
-			marker.incarnation === childIncarnation
+			spawnedBrokerPid !== undefined &&
+			spawnedBrokerIncarnation !== undefined &&
+			marker.pid === spawnedBrokerPid &&
+			marker.incarnation === spawnedBrokerIncarnation
 				? marker
 				: undefined;
 		const trustedStartupExitRecord =
 			startupExitRecord &&
-			child.pid !== undefined &&
-			startupExitRecord.pid === child.pid &&
+			spawnedBrokerPid !== undefined &&
+			startupExitRecord.pid === spawnedBrokerPid &&
 			startupExitRecord.writtenAt >= childSpawnedAt
 				? startupExitRecord
 				: undefined;
@@ -828,8 +952,20 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 			? new Error(`Failed to spawn detached SDK broker: ${spawnError.message}`)
 			: exitedBeforeDiscovery
 				? new BrokerStartupError({
-						exitCode: child.exitCode ?? trustedStartupExitRecord?.exitCode ?? null,
-						signal: child.signalCode ?? trustedStartupExitRecord?.signal ?? null,
+						exitCode: isTrampoline
+							? (trustedStartupExitRecord?.exitCode ??
+								trustedMarker?.exitCode ??
+								childExitCode ??
+								child.exitCode ??
+								null)
+							: (childExitCode ?? child.exitCode ?? trustedStartupExitRecord?.exitCode ?? null),
+						signal: isTrampoline
+							? (trustedStartupExitRecord?.signal ??
+								trustedMarker?.signal ??
+								childSignalCode ??
+								child.signalCode ??
+								null)
+							: (childSignalCode ?? child.signalCode ?? trustedStartupExitRecord?.signal ?? null),
 						reason:
 							brokerStartupExitReason(trustedStartupExitRecord) ?? brokerStartupFailureReason(trustedMarker),
 						stderrExcerpt: spawnLogTail.length > 0 ? spawnLogTail : undefined,