gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

package/packages/pi-coding-agent/src/core/package-commands.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Writable } from "node:stream";
@@ -25,216 +25,238 @@ function writePackage(root: string, files: Record<string, string>): void {
 	}
 }
 
+function createTestDirs(prefix: string, t: { after: (fn: () => void) => void }) {
+	const root = mkdtempSync(join(tmpdir(), `pi-lifecycle-${prefix}-`));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const cwd = join(root, "cwd");
+	const agentDir = join(root, "agent");
+	const extensionDir = join(root, `ext-${prefix}`);
+	mkdirSync(cwd, { recursive: true });
+	mkdirSync(agentDir, { recursive: true });
+	mkdirSync(extensionDir, { recursive: true });
+	return { root, cwd, agentDir, extensionDir };
+}
+
 describe("runPackageCommand lifecycle hooks", () => {
-	it("executes registered beforeInstall and afterInstall handlers for local packages", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-install-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-registered");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-registered",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `
-					import { writeFileSync } from "node:fs";
-					import { join } from "node:path";
-					export default function (pi) {
-						pi.registerBeforeInstall((ctx) => {
-							writeFileSync(join(ctx.installedPath, "before-install-ran.txt"), "ok", "utf-8");
-						});
-						pi.registerAfterInstall((ctx) => {
-							writeFileSync(join(ctx.installedPath, "after-install-ran.txt"), "ok", "utf-8");
-						});
-					}
-				`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const result = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(result.handled, true);
-			assert.equal(result.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "before-install-ran.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "after-install-ran.txt"), "utf-8"), "ok");
-			assert.ok(stdout.getOutput().includes(`Installed ${extensionDir}`));
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("executes registered beforeInstall and afterInstall handlers for local packages", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("install", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-registered",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function (pi) {",
+				"  pi.registerBeforeInstall((ctx) => {",
+				'    writeFileSync(join(ctx.installedPath, "before-install-ran.txt"), "ok", "utf-8");',
+				"  });",
+				"  pi.registerAfterInstall((ctx) => {",
+				'    writeFileSync(join(ctx.installedPath, "after-install-ran.txt"), "ok", "utf-8");',
+				"  });",
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const result = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(result.handled, true);
+		assert.equal(result.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "before-install-ran.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "after-install-ran.txt"), "utf-8"), "ok");
+		assert.ok(stdout.getOutput().includes(`Installed ${extensionDir}`));
 	});
 
-	it("runs legacy named lifecycle hooks when no registered hooks exist", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-legacy-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-legacy");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-legacy",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `
-					import { writeFileSync } from "node:fs";
-					import { join } from "node:path";
-					export default function () {}
-					export async function beforeInstall(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-before-install.txt"), "ok", "utf-8");
-					}
-					export async function afterInstall(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-after-install.txt"), "ok", "utf-8");
-					}
-					export async function beforeRemove(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-before-remove.txt"), "ok", "utf-8");
-					}
-					export async function afterRemove(ctx) {
-						writeFileSync(join(ctx.installedPath, "legacy-after-remove.txt"), "ok", "utf-8");
-					}
-				`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const installResult = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(installResult.handled, true);
-			assert.equal(installResult.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "legacy-before-install.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "legacy-after-install.txt"), "utf-8"), "ok");
-
-			const removeResult = await runPackageCommand({
-				appName: "pi",
-				args: ["remove", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(removeResult.handled, true);
-			assert.equal(removeResult.exitCode, 0);
-			assert.equal(readFileSync(join(extensionDir, "legacy-before-remove.txt"), "utf-8"), "ok");
-			assert.equal(readFileSync(join(extensionDir, "legacy-after-remove.txt"), "utf-8"), "ok");
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("runs legacy named lifecycle hooks when no registered hooks exist", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("legacy", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-legacy",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function () {}",
+				"export async function beforeInstall(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-before-install.txt"), "ok", "utf-8");',
+				"}",
+				"export async function afterInstall(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-after-install.txt"), "ok", "utf-8");',
+				"}",
+				"export async function beforeRemove(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-before-remove.txt"), "ok", "utf-8");',
+				"}",
+				"export async function afterRemove(ctx) {",
+				'  writeFileSync(join(ctx.installedPath, "legacy-after-remove.txt"), "ok", "utf-8");',
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const installResult = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(installResult.handled, true);
+		assert.equal(installResult.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "legacy-before-install.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "legacy-after-install.txt"), "utf-8"), "ok");
+
+		const removeResult = await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(removeResult.handled, true);
+		assert.equal(removeResult.exitCode, 0);
+		assert.equal(readFileSync(join(extensionDir, "legacy-before-remove.txt"), "utf-8"), "ok");
+		assert.equal(readFileSync(join(extensionDir, "legacy-after-remove.txt"), "utf-8"), "ok");
 	});
 
-	it("skips lifecycle phases with no hooks declared", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-skip-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-empty");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-empty",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `export default function () {}`,
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const installResult = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-			assert.equal(installResult.handled, true);
-			assert.equal(installResult.exitCode, 0);
-
-			const removeResult = await runPackageCommand({
-				appName: "pi",
-				args: ["remove", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-			assert.equal(removeResult.handled, true);
-			assert.equal(removeResult.exitCode, 0);
-			assert.equal(stderr.getOutput().includes("Hook failed"), false);
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("skips lifecycle phases with no hooks declared", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("skip", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-empty",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": "export default function () {}",
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const installResult = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+		assert.equal(installResult.handled, true);
+		assert.equal(installResult.exitCode, 0);
+
+		const removeResult = await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+		assert.equal(removeResult.handled, true);
+		assert.equal(removeResult.exitCode, 0);
+		assert.equal(stderr.getOutput().includes("Hook failed"), false);
+	});
+
+	it("fails install when manifest runtime dependency is missing", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("deps", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-runtime-deps",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": "export default function () {}",
+			"extension-manifest.json": JSON.stringify({
+				id: "ext-runtime-deps",
+				name: "Runtime Dep Test",
+				version: "1.0.0",
+				dependencies: { runtime: ["__definitely_missing_command_for_test__"] },
+			}),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+		const result = await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		assert.equal(result.handled, true);
+		assert.equal(result.exitCode, 1);
+		assert.ok(stderr.getOutput().includes("Missing runtime dependencies"));
 	});
 
-	it("fails install when manifest runtime dependency is missing", async () => {
-		const root = mkdtempSync(join(tmpdir(), "pi-lifecycle-deps-"));
-		const cwd = join(root, "cwd");
-		const agentDir = join(root, "agent");
-		const extensionDir = join(root, "ext-runtime-deps");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		mkdirSync(extensionDir, { recursive: true });
-
-		try {
-			writePackage(extensionDir, {
-				"package.json": JSON.stringify({
-					name: "ext-runtime-deps",
-					type: "module",
-					pi: { extensions: ["./index.js"] },
-				}),
-				"index.js": `export default function () {}`,
-				"extension-manifest.json": JSON.stringify({
-					id: "ext-runtime-deps",
-					name: "Runtime Dep Test",
-					version: "1.0.0",
-					dependencies: { runtime: ["__definitely_missing_command_for_test__"] },
-				}),
-			});
-
-			const stdout = createCaptureStream();
-			const stderr = createCaptureStream();
-			const result = await runPackageCommand({
-				appName: "pi",
-				args: ["install", extensionDir],
-				cwd,
-				agentDir,
-				stdout: stdout.stream,
-				stderr: stderr.stream,
-			});
-
-			assert.equal(result.handled, true);
-			assert.equal(result.exitCode, 1);
-			assert.ok(stderr.getOutput().includes("Missing runtime dependencies"));
-		} finally {
-			rmSync(root, { recursive: true, force: true });
-		}
+	it("afterRemove hook receives installedPath even when directory is deleted", async (t) => {
+		const { cwd, agentDir, extensionDir } = createTestDirs("after-remove", t);
+
+		writePackage(extensionDir, {
+			"package.json": JSON.stringify({
+				name: "ext-after-remove",
+				type: "module",
+				pi: { extensions: ["./index.js"] },
+			}),
+			"index.js": [
+				'import { writeFileSync, existsSync } from "node:fs";',
+				'import { join } from "node:path";',
+				"export default function () {}",
+				"export async function afterRemove(ctx) {",
+				'  const marker = join(ctx.cwd, "after-remove-marker.json");',
+				"  writeFileSync(marker, JSON.stringify({",
+				"    receivedPath: ctx.installedPath,",
+				"    pathExisted: existsSync(ctx.installedPath),",
+				'  }), "utf-8");',
+				"}",
+			].join("\n"),
+		});
+
+		const stdout = createCaptureStream();
+		const stderr = createCaptureStream();
+
+		await runPackageCommand({
+			appName: "pi",
+			args: ["install", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		await runPackageCommand({
+			appName: "pi",
+			args: ["remove", extensionDir],
+			cwd,
+			agentDir,
+			stdout: stdout.stream,
+			stderr: stderr.stream,
+		});
+
+		const markerPath = join(cwd, "after-remove-marker.json");
+		assert.ok(existsSync(markerPath), "afterRemove hook must have executed and written marker");
+		const marker = JSON.parse(readFileSync(markerPath, "utf-8"));
+		assert.equal(typeof marker.receivedPath, "string", "hook must receive installedPath as string");
 	});
 });

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -151,6 +151,7 @@ export interface Settings {
 	fallback?: FallbackSettings;
 	modelDiscovery?: ModelDiscoverySettings;
 	editMode?: "standard" | "hashline"; // Edit tool mode: "standard" (text match) or "hashline" (LINE#ID anchors). Default: "standard"
+	timestampFormat?: "date-time-iso" | "date-time-us"; // Timestamp display format for messages. Default: "date-time-iso"
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -1087,4 +1088,12 @@ export class SettingsManager {
 	setEditMode(mode: "standard" | "hashline"): void {
 		this.setGlobalSetting("editMode", mode);
 	}
+
+	getTimestampFormat(): "date-time-iso" | "date-time-us" {
+		return this.settings.timestampFormat ?? "date-time-iso";
+	}
+
+	setTimestampFormat(format: "date-time-iso" | "date-time-us"): void {
+		this.setGlobalSetting("timestampFormat", format);
+	}
 }

package/packages/pi-coding-agent/src/main.ts

@@ -391,6 +391,25 @@ export async function main(args: string[]) {
 	const authStorage = AuthStorage.create();
 	const modelRegistry = new ModelRegistry(authStorage, getModelsPath());
 
+	// Offline mode validation / auto-detection
+	if (offlineMode) {
+		// --offline flag: validate all models are local
+		if (!modelRegistry.isAllLocalChain()) {
+			const remoteModel = modelRegistry.getAll().find((m) => !ModelRegistry.isLocalModel(m));
+			if (remoteModel) {
+				console.error(
+					`Error: --offline requires all configured models to be local. Found remote model: ${remoteModel.name} (${remoteModel.baseUrl || "cloud API"})`,
+				);
+				process.exit(1);
+			}
+		}
+	} else if (modelRegistry.isAllLocalChain() && modelRegistry.getAll().length > 0) {
+		// Auto-detect: all models are local, enable offline mode
+		process.env.PI_OFFLINE = "1";
+		process.env.PI_SKIP_VERSION_CHECK = "1";
+		console.log("[gsd] All configured models are local \u2014 enabling offline mode automatically.");
+	}
+
 	const resourceLoader = new DefaultResourceLoader({
 		cwd,
 		agentDir,

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/timestamp.test.ts

@@ -0,0 +1,38 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { formatTimestamp } from "../timestamp.js";
+
+describe("formatTimestamp", () => {
+	// Use a fixed local timestamp to avoid timezone issues
+	const d = new Date(2026, 2, 24, 10, 34, 0); // Mar 24, 2026 10:34:00 local time
+	const ts = d.getTime();
+
+	test("date-time-iso format (default)", () => {
+		assert.equal(formatTimestamp(ts, "date-time-iso"), "2026-03-24 10:34");
+		assert.equal(formatTimestamp(ts), "2026-03-24 10:34"); // default
+	});
+
+	test("date-time-us format", () => {
+		assert.equal(formatTimestamp(ts, "date-time-us"), "03-24-2026 10:34 AM");
+	});
+
+	test("US format handles PM correctly", () => {
+		const pm = new Date(2026, 2, 24, 14, 5, 0).getTime();
+		assert.equal(formatTimestamp(pm, "date-time-us"), "03-24-2026 2:05 PM");
+	});
+
+	test("US format handles noon as 12 PM", () => {
+		const noon = new Date(2026, 2, 24, 12, 0, 0).getTime();
+		assert.equal(formatTimestamp(noon, "date-time-us"), "03-24-2026 12:00 PM");
+	});
+
+	test("US format handles midnight as 12 AM", () => {
+		const midnight = new Date(2026, 2, 24, 0, 0, 0).getTime();
+		assert.equal(formatTimestamp(midnight, "date-time-us"), "03-24-2026 12:00 AM");
+	});
+
+	test("ISO format pads single digit months and days", () => {
+		const jan1 = new Date(2026, 0, 1, 9, 5, 0).getTime();
+		assert.equal(formatTimestamp(jan1, "date-time-iso"), "2026-01-01 09:05");
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/assistant-message.ts

@@ -1,6 +1,7 @@
 import type { AssistantMessage } from "@gsd/pi-ai";
 import { Container, Markdown, type MarkdownTheme, Spacer, Text } from "@gsd/pi-tui";
 import { getMarkdownTheme, theme } from "../theme/theme.js";
+import { formatTimestamp, type TimestampFormat } from "./timestamp.js";
 
 /**
  * Component that renders a complete assistant message
@@ -10,16 +11,19 @@ export class AssistantMessageComponent extends Container {
 	private hideThinkingBlock: boolean;
 	private markdownTheme: MarkdownTheme;
 	private lastMessage?: AssistantMessage;
+	private timestampFormat: TimestampFormat;
 
 	constructor(
 		message?: AssistantMessage,
 		hideThinkingBlock = false,
 		markdownTheme: MarkdownTheme = getMarkdownTheme(),
+		timestampFormat: TimestampFormat = "date-time-iso",
 	) {
 		super();
 
 		this.hideThinkingBlock = hideThinkingBlock;
 		this.markdownTheme = markdownTheme;
+		this.timestampFormat = timestampFormat;
 
 		// Container for text/thinking content
 		this.contentContainer = new Container();
@@ -111,5 +115,11 @@ export class AssistantMessageComponent extends Container {
 				this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 			}
 		}
+
+		// Show timestamp when the message is complete (has a stop reason)
+		if (message.stopReason && message.timestamp) {
+			const timeStr = formatTimestamp(message.timestamp, this.timestampFormat);
+			this.contentContainer.addChild(new Text(theme.fg("dim", timeStr), 1, 0));
+		}
 	}
 }

package/packages/pi-coding-agent/src/modes/interactive/components/settings-selector.ts

@@ -45,6 +45,7 @@ export interface SettingsConfig {
 	respectGitignoreInPicker: boolean;
 	quietStartup: boolean;
 	clearOnShrink: boolean;
+	timestampFormat: "date-time-iso" | "date-time-us";
 }
 
 export interface SettingsCallbacks {
@@ -69,6 +70,7 @@ export interface SettingsCallbacks {
 	onRespectGitignoreInPickerChange: (enabled: boolean) => void;
 	onQuietStartupChange: (enabled: boolean) => void;
 	onClearOnShrinkChange: (enabled: boolean) => void;
+	onTimestampFormatChange: (format: "date-time-iso" | "date-time-us") => void;
 	onCancel: () => void;
 }
 
@@ -355,6 +357,16 @@ export class SettingsSelectorComponent extends Container {
 			values: ["true", "false"],
 		});
 
+		// Timestamp format (insert after respect-gitignore-in-picker)
+		const gitignoreIndex = items.findIndex((item) => item.id === "respect-gitignore-in-picker");
+		items.splice(gitignoreIndex + 1, 0, {
+			id: "timestamp-format",
+			label: "Timestamp format",
+			description: "Date/time format for message timestamps",
+			currentValue: config.timestampFormat,
+			values: ["date-time-iso", "date-time-us"],
+		});
+
 		// Add borders
 		this.addChild(new DynamicBorder());
 
@@ -420,6 +432,9 @@ export class SettingsSelectorComponent extends Container {
 					case "respect-gitignore-in-picker":
 						callbacks.onRespectGitignoreInPickerChange(newValue === "true");
 						break;
+					case "timestamp-format":
+						callbacks.onTimestampFormatChange(newValue as "date-time-iso" | "date-time-us");
+						break;
 				}
 			},
 			callbacks.onCancel,