framer-code-link 0.1.3 → 0.2.0

package/dist/{index.js → index.mjs}

@@ -4,15 +4,109 @@ import fs from "fs/promises";
 import { WebSocketServer } from "ws";
 import chokidar from "chokidar";
 import path from "path";
-import "url";
 import { createHash } from "crypto";
 import { setupTypeAcquisition } from "@typescript/ata";
 import ts from "typescript";
 
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+
+//#endregion
 //#region src/utils/logging.ts
-/**
-* Logging utilities for consistent output
-*/
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
 	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
 	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
@@ -21,28 +115,182 @@ let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
 	return LogLevel$1;
 }({});
 let currentLevel = LogLevel.INFO;
+let lastMessage = "";
+let lastMessageCount = 0;
+const CLEAR_LINE = "\x1B[2K";
+const MOVE_CURSOR_UP = "\x1B[1A";
+function rewriteLastLine(text) {
+	if (process.stdout.isTTY) process.stdout.write(`${MOVE_CURSOR_UP}\r${CLEAR_LINE}${text}\n`);
+	else process.stdout.write(`${text}\n`);
+}
+let disconnectTimer = null;
+let isShowingDisconnect = false;
+let hadRecentDisconnect = false;
+const DISCONNECT_DELAY_MS = 4e3;
 function setLogLevel(level) {
 	currentLevel = level;
 }
+function dedupeMessage(message, count) {
+	rewriteLastLine(`${message} ${import_picocolors.default.dim(`(x${count})`)}`);
+}
+/**
+* Flush any pending deduplicated message
+*/
+function flushDedupe() {
+	if (lastMessageCount > 1) dedupeMessage(lastMessage, lastMessageCount);
+	lastMessage = "";
+	lastMessageCount = 0;
+}
+/**
+* Log with deduplication - repeated messages within window get counted
+*/
+function logWithDedupe(message, writer) {
+	if (message === lastMessage) {
+		lastMessageCount++;
+		dedupeMessage(message, lastMessageCount);
+		return;
+	}
+	lastMessage = message;
+	lastMessageCount = 1;
+	writer();
+}
+/**
+* Print the startup banner - one colored line
+*/
+function banner(version, port) {
+	console.log();
+	let message = `  ${import_picocolors.default.cyan(import_picocolors.default.bold("⚡ Code Link"))} ${import_picocolors.default.dim(`v${version}`)}`;
+	if (currentLevel <= LogLevel.DEBUG) message += `  ${import_picocolors.default.dim("Port")} ${import_picocolors.default.yellow(port)}`;
+	console.log(message);
+	console.log();
+}
+/**
+* Debug-level logging - only shown with --verbose flag
+*/
 function debug(message, ...args) {
-	if (currentLevel <= LogLevel.DEBUG) console.debug(`[DEBUG] ${message}`, ...args);
+	if (currentLevel <= LogLevel.DEBUG) console.debug(import_picocolors.default.dim(`[DEBUG] ${message}`), ...args);
 }
+/**
+* Info-level logging - shown by default, no prefix
+*/
 function info(message, ...args) {
-	if (currentLevel <= LogLevel.INFO) console.info(`[INFO] ${message}`, ...args);
+	if (currentLevel <= LogLevel.INFO) {
+		const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+		logWithDedupe(formatted, () => console.log(formatted));
+	}
 }
+/**
+* Warning-level logging
+*/
 function warn(message, ...args) {
-	if (currentLevel <= LogLevel.WARN) console.warn(`[WARN] ${message}`, ...args);
+	if (currentLevel <= LogLevel.WARN) {
+		if (message === lastMessage) return;
+		flushDedupe();
+		lastMessage = message;
+		lastMessageCount = 1;
+		console.warn(import_picocolors.default.yellow(`⚠ ${message}`), ...args);
+	}
 }
+/**
+* Error-level logging
+*/
 function error(message, ...args) {
-	if (currentLevel <= LogLevel.ERROR) console.error(`[ERROR] ${message}`, ...args);
+	if (currentLevel <= LogLevel.ERROR) {
+		flushDedupe();
+		console.error(import_picocolors.default.red(`✗ ${message}`), ...args);
+	}
 }
+/**
+* Success message with checkmark
+*/
 function success(message, ...args) {
-	if (currentLevel <= LogLevel.INFO) console.log(`✓ ${message}`, ...args);
+	if (currentLevel <= LogLevel.INFO) {
+		flushDedupe();
+		console.log(import_picocolors.default.green(`✓ ${message}`), ...args);
+	}
+}
+/**
+* File sync indicators
+*/
+function fileDown(fileName) {
+	if (currentLevel <= LogLevel.INFO) {
+		const msg = `  ${import_picocolors.default.blue("↓")} ${fileName}`;
+		logWithDedupe(msg, () => console.log(msg));
+	}
+}
+function fileUp(fileName) {
+	if (currentLevel <= LogLevel.INFO) {
+		const msg = `  ${import_picocolors.default.green("↑")} ${fileName}`;
+		logWithDedupe(msg, () => console.log(msg));
+	}
+}
+function fileDelete(fileName) {
+	if (currentLevel <= LogLevel.INFO) {
+		const msg = `  ${import_picocolors.default.red("×")} ${fileName}`;
+		logWithDedupe(msg, () => console.log(msg));
+	}
+}
+/**
+* Status message (dimmed, for "watching for changes..." etc)
+*/
+function status(message) {
+	if (currentLevel <= LogLevel.INFO) {
+		flushDedupe();
+		console.log(import_picocolors.default.dim(`  ${message}`));
+	}
+}
+/**
+* Schedule a delayed disconnect message.
+* If reconnection happens before the delay, the message is cancelled.
+*/
+function scheduleDisconnectMessage(callback) {
+	if (disconnectTimer) clearTimeout(disconnectTimer);
+	hadRecentDisconnect = true;
+	isShowingDisconnect = false;
+	disconnectTimer = setTimeout(() => {
+		isShowingDisconnect = true;
+		callback();
+		disconnectTimer = null;
+	}, DISCONNECT_DELAY_MS);
+}
+/**
+* Cancel pending disconnect message (called on reconnect)
+*/
+function cancelDisconnectMessage() {
+	if (disconnectTimer) {
+		clearTimeout(disconnectTimer);
+		disconnectTimer = null;
+	}
+}
+/**
+* Check if we showed a disconnect message (need to show reconnect)
+*/
+function didShowDisconnect() {
+	return isShowingDisconnect;
+}
+/**
+* Check if we recently saw a disconnect (even if the message was suppressed)
+*/
+function wasRecentlyDisconnected() {
+	return hadRecentDisconnect;
+}
+/**
+* Reset disconnect state after successful reconnect
+*/
+function resetDisconnectState() {
+	isShowingDisconnect = false;
+	hadRecentDisconnect = false;
 }
 
 //#endregion
 //#region src/helpers/connection.ts
 /**
+* WebSocket connection helper
+*
+* Thin wrapper around ws.Server that normalizes handshake and surfaces
+* simple callbacks. Keeps raw socket API localized.
+*/
+/**
 * Initializes a WebSocket server and returns a connection interface
 * Returns a Promise that resolves when the server is ready, or rejects on startup errors
 */
@@ -62,7 +310,7 @@ function initConnection(port) {
 					error(`  1. Close any other terminal running Code Link for this project`);
 					error(`  2. Or run: lsof -i :${port} | grep LISTEN`);
 					error(`     Then kill the process: kill -9 <PID>`);
-					reject(new Error(`Port ${port} is already in use`));
+					reject(/* @__PURE__ */ new Error(`Port ${port} is already in use`));
 				} else {
 					error(`Failed to start WebSocket server: ${err.message}`);
 					reject(err);
@@ -73,27 +321,30 @@ function initConnection(port) {
 		});
 		wss.on("listening", () => {
 			isReady = true;
-			info(`WebSocket server listening on port ${port}`);
+			debug(`WebSocket server listening on port ${port}`);
 			wss.on("connection", (ws) => {
 				const connId = ++connectionId;
-				info(`[CONN ${connId}] Client connected (readyState: ${ws.readyState})`);
+				let handshakeReceived = false;
+				debug(`Client connected (conn ${connId})`);
 				ws.on("message", (data) => {
 					try {
 						const message = JSON.parse(data.toString());
 						if (message.type === "handshake") {
-							info(`[CONN ${connId}] Received handshake`);
+							debug(`Received handshake (conn ${connId})`);
+							handshakeReceived = true;
 							handlers.onHandshake?.(ws, message);
-						} else handlers.onMessage?.(message);
+						} else if (handshakeReceived) handlers.onMessage?.(message);
+						else debug(`Ignoring ${message.type} before handshake (conn ${connId})`);
 					} catch (err) {
-						error(`[CONN ${connId}] Failed to parse message:`, err);
+						error(`Failed to parse message:`, err);
 					}
 				});
 				ws.on("close", (code, reason) => {
-					info(`[CONN ${connId}] Client disconnected (code: ${code}, reason: ${reason?.toString() || "none"})`);
+					debug(`Client disconnected (code: ${code}, reason: ${reason?.toString() || "none"})`);
 					handlers.onDisconnect?.();
 				});
 				ws.on("error", (err) => {
-					error(`[CONN ${connId}] WebSocket error:`, err);
+					error(`WebSocket error:`, err);
 				});
 			});
 			resolve({
@@ -136,19 +387,74 @@ function sendMessage(socket, message) {
 	return new Promise((resolve) => {
 		if (socket.readyState !== READY_STATE.OPEN) {
 			const stateStr = readyStateToString(socket.readyState);
-			info(`[WS] Cannot send ${message.type}: socket is ${stateStr}`);
+			debug(`Cannot send ${message.type}: socket is ${stateStr}`);
 			resolve(false);
 			return;
 		}
 		socket.send(JSON.stringify(message), (err) => {
 			if (err) {
-				error(`[WS] Send error for ${message.type}:`, err.message);
+				debug(`Send error for ${message.type}: ${err.message}`);
 				resolve(false);
 			} else resolve(true);
 		});
 	});
 }
 
+//#endregion
+//#region ../shared/dist/hash.js
+/**
+* Base58 alphabet (no 0/O/I/l to avoid confusion)
+*/
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+* Derive a short, deterministic hash from the full Framer project hash.
+* Uses a simple numeric hash encoded in base58 for compactness.
+* Idempotent: if input is already the target length, returns it unchanged.
+*/
+function shortProjectHash(fullHash, length = 8) {
+	if (fullHash.length === length) return fullHash;
+	let h1 = 0;
+	let h2 = 0;
+	for (let i = 0; i < fullHash.length; i++) {
+		const char = fullHash.charCodeAt(i);
+		h1 = Math.imul(h1 ^ char, 2246822507);
+		h2 = Math.imul(h2 ^ char, 3266489909);
+	}
+	h1 ^= h2 >>> 16;
+	h2 ^= h1 >>> 13;
+	let result = "";
+	const combined = [Math.abs(h1), Math.abs(h2)];
+	for (const num of combined) {
+		let n = num >>> 0;
+		while (n > 0 && result.length < length) {
+			result += BASE58[n % 58];
+			n = Math.floor(n / 58);
+		}
+	}
+	while (result.length < length) result += BASE58[0];
+	return result.slice(0, length);
+}
+
+//#endregion
+//#region ../shared/dist/ports.js
+/**
+* Generate a deterministic port number from a project hash (full or short).
+* Port range: 3847-4096 (250 possible ports)
+* Must match between CLI and plugin.
+*
+* Internally normalizes to the short id so both full and short inputs yield the same port.
+*/
+function getPortFromHash(projectHash) {
+	const shortId = shortProjectHash(projectHash);
+	let hash = 0;
+	for (let i = 0; i < shortId.length; i++) {
+		const char = shortId.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return 3847 + Math.abs(hash) % 250;
+}
+
 //#endregion
 //#region ../shared/dist/paths.js
 /**
@@ -241,9 +547,8 @@ function sanitizeFilePath(input, capitalizeReactComponent = true) {
 	const dirName = dirname(trimmed).split("/").map((part) => sanitizedDirectoryName(part)).filter((part) => Boolean(part)).join("/");
 	let name = sanitizedVariableName(inputName) ?? "MyComponent";
 	if ((!hasValidExtension(extension) || extension === tsxExtension) && capitalizeReactComponent) name = capitalizeFirstLetter(name);
-	const sanitizedPath = pathJoin(dirName, name + extension);
 	return {
-		path: sanitizedPath,
+		path: pathJoin(dirName, name + extension),
 		dirName,
 		name,
 		extension
@@ -252,10 +557,22 @@ function sanitizeFilePath(input, capitalizeReactComponent = true) {
 function isSupportedExtension$1(filePath) {
 	return /\.(tsx?|jsx?|json)$/i.test(filePath);
 }
+/**
+* Pluralize a word based on count
+* @example pluralize(1, "file") => "1 file"
+* @example pluralize(3, "file") => "3 files"
+* @example pluralize(0, "conflict") => "0 conflicts"
+*/
+function pluralize(count, singular, plural) {
+	return `${count} ${count === 1 ? singular : plural ?? `${singular}s`}`;
+}
 
 //#endregion
 //#region src/utils/paths.ts
 /**
+* Path manipulation utilities
+*/
+/**
 * Gets a relative path from the project directory
 */
 function getRelativePath(projectDir, absolutePath) {
@@ -288,6 +605,13 @@ function normalizePath$1(filePath) {
 //#endregion
 //#region src/helpers/watcher.ts
 /**
+* File watcher helper
+*
+* Thin wrapper around chokidar that normalizes file paths and emits
+* only supported file types (ts, tsx, js, json). Controller never worries
+* about addDir or platform separators.
+*/
+/**
 * Initializes a file watcher for the given directory
 */
 function initWatcher(filesDir) {
@@ -297,22 +621,21 @@ function initWatcher(filesDir) {
 		persistent: true,
 		ignoreInitial: false
 	});
-	info(`Watching directory: ${filesDir}`);
+	debug(`Watching directory: ${filesDir}`);
 	const emitEvent = async (kind, absolutePath) => {
 		if (!isSupportedExtension$1(absolutePath)) return;
 		const rawRelativePath = normalizePath(getRelativePath(filesDir, absolutePath));
-		const sanitized = sanitizeFilePath(rawRelativePath, false);
-		const relativePath = sanitized.path;
+		const relativePath = sanitizeFilePath(rawRelativePath, false).path;
 		let effectiveAbsolutePath = absolutePath;
 		if (relativePath !== rawRelativePath && kind === "add") {
 			const newAbsolutePath = path.join(filesDir, relativePath);
 			try {
 				await fs.mkdir(path.dirname(newAbsolutePath), { recursive: true });
 				await fs.rename(absolutePath, newAbsolutePath);
-				info(`Renamed ${rawRelativePath} -> ${relativePath} to match Framer rules`);
+				debug(`Renamed ${rawRelativePath} -> ${relativePath}`);
 				effectiveAbsolutePath = newAbsolutePath;
 			} catch (err) {
-				warn(`Failed to rename ${rawRelativePath} to ${relativePath}, syncing with original name`, err);
+				warn(`Failed to rename ${rawRelativePath}`, err);
 			}
 		}
 		let content;
@@ -345,6 +668,13 @@ function initWatcher(filesDir) {
 
 //#endregion
 //#region src/utils/state-persistence.ts
+/**
+* State persistence helper
+*
+* Persists last sync timestamps along with content hashes.
+* We only trust persisted timestamps if the file content hasn't changed
+* (hash matches), because that means the file wasn't edited while CLI was offline.
+*/
 const STATE_FILE_NAME = ".framer-sync-state.json";
 const CURRENT_VERSION = 2;
 const SUPPORTED_EXTENSIONS$1 = [
@@ -414,6 +744,17 @@ async function savePersistedState(projectDir, state) {
 
 //#endregion
 //#region src/helpers/files.ts
+/**
+* File operations helper
+*
+* Single place that understands disk + conflicts. Provides:
+* - listFiles: returns current filesystem state
+* - detectConflicts: compares remote vs local and returns conflicts + safe writes
+* - writeRemoteFiles: applies writes/deletes from remote
+* - deleteLocalFile: removes a file from disk
+*
+* Controller decides WHEN to call these, but never computes conflicts itself.
+*/
 const SUPPORTED_EXTENSIONS = [
 	".ts",
 	".tsx",
@@ -423,6 +764,10 @@ const SUPPORTED_EXTENSIONS = [
 ];
 const DEFAULT_EXTENSION = ".tsx";
 const DEFAULT_REMOTE_DRIFT_MS = 2e3;
+/** Normalize file name for case-insensitive comparison (macOS/Windows compat) */
+function normalizeForComparison(fileName) {
+	return fileName.toLowerCase();
+}
 /**
 * Lists all supported files in the files directory
 */
@@ -437,9 +782,7 @@ async function listFiles(filesDir) {
 				continue;
 			}
 			if (!isSupportedExtension(entry.name)) continue;
-			const relativePath = path.relative(filesDir, entryPath);
-			const normalizedPath = normalizePath(relativePath);
-			const sanitizedPath = sanitizeFilePath(normalizedPath, false).path;
+			const sanitizedPath = sanitizeFilePath(normalizePath(path.relative(filesDir, entryPath)), false).path;
 			try {
 				const [content, stats] = await Promise.all([fs.readFile(entryPath, "utf-8"), fs.stat(entryPath)]);
 				files.push({
@@ -463,29 +806,51 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 	const conflicts = [];
 	const writes = [];
 	const localOnly = [];
+	const unchanged = [];
 	const detect = options.detectConflicts ?? true;
 	const preferRemote = options.preferRemote ?? false;
 	const persistedState = options.persistedState;
+	const getPersistedState = (fileName) => persistedState?.get(normalizeForComparison(fileName)) ?? persistedState?.get(fileName);
 	debug(`Detecting conflicts for ${remoteFiles.length} remote files`);
 	const localFiles = await listFiles(filesDir);
-	const localFileMap = new Map(localFiles.map((f) => [f.name, f]));
+	const localFileMap = new Map(localFiles.map((f) => [normalizeForComparison(f.name), f]));
+	const remoteFileMap = new Map(remoteFiles.map((f) => {
+		return [normalizeForComparison(resolveRemoteReference(filesDir, f.name).relativePath), f];
+	}));
 	const processedFiles = /* @__PURE__ */ new Set();
 	for (const remote of remoteFiles) {
 		const normalized = resolveRemoteReference(filesDir, remote.name);
-		const local = localFileMap.get(normalized.relativePath);
-		processedFiles.add(normalized.relativePath);
-		const persisted = persistedState?.get(normalized.relativePath);
+		const normalizedKey = normalizeForComparison(normalized.relativePath);
+		const local = localFileMap.get(normalizedKey);
+		processedFiles.add(normalizedKey);
+		const persisted = getPersistedState(normalized.relativePath);
 		const localHash = local ? hashFileContent(local.content) : null;
 		const localMatchesPersisted = !!persisted && !!local && localHash === persisted.contentHash;
 		if (!local) {
-			writes.push({
+			if (persisted) {
+				debug(`Conflict: ${normalized.relativePath} deleted locally while offline`);
+				conflicts.push({
+					fileName: normalized.relativePath,
+					localContent: null,
+					remoteContent: remote.content,
+					remoteModifiedAt: remote.modifiedAt,
+					lastSyncedAt: persisted?.timestamp
+				});
+			} else writes.push({
+				name: normalized.relativePath,
+				content: remote.content,
+				modifiedAt: remote.modifiedAt
+			});
+			continue;
+		}
+		if (local.content === remote.content) {
+			unchanged.push({
 				name: normalized.relativePath,
 				content: remote.content,
 				modifiedAt: remote.modifiedAt
 			});
 			continue;
 		}
-		if (local.content === remote.content) continue;
 		if (!detect || preferRemote) {
 			writes.push({
 				name: normalized.relativePath,
@@ -505,15 +870,39 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 			localClean
 		});
 	}
-	for (const local of localFiles) if (!processedFiles.has(local.name)) localOnly.push({
-		name: local.name,
-		content: local.content,
-		modifiedAt: local.modifiedAt
-	});
+	for (const local of localFiles) {
+		const localKey = normalizeForComparison(local.name);
+		if (!processedFiles.has(localKey)) {
+			const persisted = getPersistedState(local.name);
+			if (persisted) {
+				const localClean = hashFileContent(local.content) === persisted.contentHash;
+				debug(`Conflict: ${local.name} deleted in Framer (localClean=${localClean})`);
+				conflicts.push({
+					fileName: local.name,
+					localContent: local.content,
+					remoteContent: null,
+					localModifiedAt: local.modifiedAt,
+					lastSyncedAt: persisted?.timestamp,
+					localClean
+				});
+			} else localOnly.push({
+				name: local.name,
+				content: local.content,
+				modifiedAt: local.modifiedAt
+			});
+		}
+	}
+	if (persistedState) for (const [fileName] of persistedState) {
+		const normalizedKey = normalizeForComparison(fileName);
+		const inLocal = localFileMap.has(normalizedKey);
+		const inRemote = remoteFileMap.has(normalizedKey);
+		if (!inLocal && !inRemote) debug(`[AUTO-RESOLVE] ${fileName}: deleted on both sides, no conflict`);
+	}
 	return {
 		conflicts,
 		writes,
-		localOnly
+		localOnly,
+		unchanged
 	};
 }
 function autoResolveConflicts(conflicts, versions, options = {}) {
@@ -525,30 +914,40 @@ function autoResolveConflicts(conflicts, versions, options = {}) {
 	for (const conflict of conflicts) {
 		const latestRemoteVersionMs = versionMap.get(conflict.fileName);
 		const lastSyncedAt = conflict.lastSyncedAt;
-		info(`[AUTO-RESOLVE] Checking ${conflict.fileName}...`);
+		const localClean = conflict.localClean === true;
+		debug(`Auto-resolve checking ${conflict.fileName}`);
+		if (conflict.remoteContent === null) {
+			if (localClean) {
+				debug(`  Remote deleted, local clean -> REMOTE (delete locally)`);
+				autoResolvedRemote.push(conflict);
+			} else {
+				debug(`  Remote deleted, local modified -> conflict`);
+				remainingConflicts.push(conflict);
+			}
+			continue;
+		}
 		if (!latestRemoteVersionMs) {
-			info(`-> No remote version data, keeping conflict`);
+			debug(`  No remote version data, keeping conflict`);
 			remainingConflicts.push(conflict);
 			continue;
 		}
 		if (!lastSyncedAt) {
-			info(`-> No last sync timestamp, keeping conflict`);
+			debug(`  No last sync timestamp, keeping conflict`);
 			remainingConflicts.push(conflict);
 			continue;
 		}
-		info(`-> Latest remote: ${new Date(latestRemoteVersionMs).toISOString()} (${latestRemoteVersionMs})`);
-		info(`-> Last synced: ${new Date(lastSyncedAt).toISOString()} (${lastSyncedAt})`);
+		debug(`  Remote: ${new Date(latestRemoteVersionMs).toISOString()}`);
+		debug(`  Synced: ${new Date(lastSyncedAt).toISOString()}`);
 		const remoteUnchanged = latestRemoteVersionMs <= lastSyncedAt + remoteDriftMs;
-		const localClean = conflict.localClean === true;
 		if (remoteUnchanged && !localClean) {
-			info(`  -> Remote unchanged, local changed. Auto-applying LOCAL.`);
+			debug(`  Remote unchanged, local changed -> LOCAL`);
 			autoResolvedLocal.push(conflict);
 		} else if (localClean && !remoteUnchanged) {
-			info(`  -> Local unchanged, remote changed. Auto-applying REMOTE.`);
+			debug(`  Local unchanged, remote changed -> REMOTE`);
 			autoResolvedRemote.push(conflict);
-		} else if (remoteUnchanged && localClean) info(`  -> Both unchanged. Skipping (no conflict).`);
+		} else if (remoteUnchanged && localClean) debug(`  Both unchanged, skipping`);
 		else {
-			info(`  -> Both sides changed. Real conflict.`);
+			debug(`  Both changed, real conflict`);
 			remainingConflicts.push(conflict);
 		}
 	}
@@ -563,7 +962,7 @@ function autoResolveConflicts(conflicts, versions, options = {}) {
 * CRITICAL: Update hashTracker BEFORE writing to disk
 */
 async function writeRemoteFiles(files, filesDir, hashTracker, installer) {
-	info(`Writing ${files.length} remote files`);
+	debug(`Writing ${files.length} remote files`);
 	for (const file of files) try {
 		const normalized = resolveRemoteReference(filesDir, file.name);
 		const fullPath = normalized.absolutePath;
@@ -585,12 +984,11 @@ async function deleteLocalFile(fileName, filesDir, hashTracker) {
 		hashTracker.markDelete(normalized.relativePath);
 		await fs.unlink(normalized.absolutePath);
 		hashTracker.forget(normalized.relativePath);
-		info(`Deleted file: ${normalized.relativePath}`);
+		debug(`Deleted file: ${normalized.relativePath}`);
 	} catch (err) {
-		const nodeError = err;
-		if (nodeError?.code === "ENOENT") {
+		if (err?.code === "ENOENT") {
 			hashTracker.forget(normalized.relativePath);
-			info(`File already deleted: ${normalized.relativePath}`);
+			debug(`File already deleted: ${normalized.relativePath}`);
 			return;
 		}
 		hashTracker.clearDelete(normalized.relativePath);
@@ -618,9 +1016,7 @@ function resolveRemoteReference(filesDir, rawName) {
 }
 function sanitizeRelativePath(relativePath) {
 	const trimmed = normalizePath(relativePath.trim());
-	const hasExtension = SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext));
-	const candidate = hasExtension ? trimmed : `${trimmed}${DEFAULT_EXTENSION}`;
-	const sanitized = sanitizeFilePath(candidate, false);
+	const sanitized = sanitizeFilePath(SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext)) ? trimmed : `${trimmed}${DEFAULT_EXTENSION}`, false);
 	const normalized = normalizePath(sanitized.path);
 	return {
 		relativePath: normalized,
@@ -672,12 +1068,14 @@ function extractImports(code) {
 * Attempt to derive an npm-style package specifier from a URL import.
 */
 function extractPackageFromUrl(url) {
-	const match = url.match(/\/(@?[^@\/]+(?:\/[^@\/]+)?)/);
-	return match?.[1] ?? null;
+	return url.match(/\/(@?[^@\/]+(?:\/[^@\/]+)?)/)?.[1] ?? null;
 }
 
 //#endregion
 //#region src/helpers/installer.ts
+/**
+* Type installer helper using @typescript/ata
+*/
 const FETCH_TIMEOUT_MS = 6e4;
 const MAX_FETCH_RETRIES = 3;
 const REACT_TYPES_VERSION = "18.3.12";
@@ -716,11 +1114,8 @@ var Installer = class {
 					const normalized = receivedPath.replace(/^\//, "");
 					const destination = path.join(this.projectDir, normalized);
 					const pkgMatch = receivedPath.match(/\/node_modules\/(@?[^\/]+(?:\/[^\/]+)?)\//);
-					let isFromCache = false;
 					try {
-						const existing = await fs.readFile(destination, "utf-8");
-						if (existing === code) {
-							isFromCache = true;
+						if (await fs.readFile(destination, "utf-8") === code) {
 							if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
 								seenPackages.add(pkgMatch[1]);
 								debug(`📦 Types: ${pkgMatch[1]} (from disk cache)`);
@@ -730,13 +1125,13 @@ var Installer = class {
 					} catch {}
 					if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
 						seenPackages.add(pkgMatch[1]);
-						info(`📦 Types: ${pkgMatch[1]}`);
+						debug(`📦 Types: ${pkgMatch[1]}`);
 					}
 					await this.writeTypeFile(receivedPath, code);
 				}
 			}
 		});
-		info("Type installer initialized");
+		debug("Type installer initialized");
 	}
 	/**
 	* Ensure the project scaffolding exists (tsconfig, declarations, etc.)
@@ -784,7 +1179,7 @@ var Installer = class {
 		const hash = imports.map((imp) => imp.name).sort().join(",");
 		if (this.processedImports.has(hash)) return;
 		this.processedImports.add(hash);
-		info(`Processing imports for ${fileName} (${imports.length} packages)`);
+		debug(`Processing imports for ${fileName} (${imports.length} packages)`);
 		try {
 			await this.ata(content);
 		} catch (err) {
@@ -819,15 +1214,9 @@ var Installer = class {
 			const pkg = npmData.versions[version];
 			if (pkg.exports && typeof pkg.exports === "object") {
 				const fixExport = (value) => {
-					if (typeof value === "string") {
-						const tsPath = value.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
-						return { types: tsPath };
-					}
+					if (typeof value === "string") return { types: value.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts") };
 					if (value && typeof value === "object") {
-						if ((value.import || value.require) && !value.types) {
-							const base = value.import || value.require;
-							value.types = base.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
-						}
+						if ((value.import || value.require) && !value.types) value.types = (value.import || value.require).replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
 					}
 					return value;
 				};
@@ -854,7 +1243,7 @@ var Installer = class {
 			await fs.access(tsconfigPath);
 			debug("tsconfig.json already exists");
 		} catch {
-			const config = {
+			await fs.writeFile(tsconfigPath, JSON.stringify({
 				compilerOptions: {
 					noEmit: true,
 					target: "ES2021",
@@ -877,9 +1266,8 @@ var Installer = class {
 					typeRoots: ["./node_modules/@types"]
 				},
 				include: ["files/**/*", "framer-modules.d.ts"]
-			};
-			await fs.writeFile(tsconfigPath, JSON.stringify(config, null, 2));
-			info("Created tsconfig.json");
+			}, null, 2));
+			debug("Created tsconfig.json");
 		}
 	}
 	async ensurePrettierConfig() {
@@ -888,13 +1276,12 @@ var Installer = class {
 			await fs.access(prettierPath);
 			debug(".prettierrc already exists");
 		} catch {
-			const config = {
+			await fs.writeFile(prettierPath, JSON.stringify({
 				tabWidth: 4,
 				semi: false,
 				trailingComma: "es5"
-			};
-			await fs.writeFile(prettierPath, JSON.stringify(config, null, 2));
-			info("Created .prettierrc");
+			}, null, 2));
+			debug("Created .prettierrc");
 		}
 	}
 	async ensureFramerDeclarations() {
@@ -903,15 +1290,14 @@ var Installer = class {
 			await fs.access(declarationsPath);
 			debug("framer-modules.d.ts already exists");
 		} catch {
-			const declarations = `// Type declarations for Framer URL imports
+			await fs.writeFile(declarationsPath, `// Type declarations for Framer URL imports
 declare module "https://framer.com/m/*"
 
 declare module "https://framerusercontent.com/*"
 
 declare module "*.json"
-`;
-			await fs.writeFile(declarationsPath, declarations);
-			info("Created framer-modules.d.ts");
+`);
+			debug("Created framer-modules.d.ts");
 		}
 	}
 	async ensurePackageJson() {
@@ -927,7 +1313,7 @@ declare module "*.json"
 				description: "Framer files synced with framer-code-link"
 			};
 			await fs.writeFile(packagePath, JSON.stringify(pkg, null, 2));
-			info("Created package.json");
+			debug("Created package.json");
 		}
 	}
 	async ensureReact18Types() {
@@ -939,9 +1325,9 @@ declare module "*.json"
 			"jsx-runtime.d.ts",
 			"jsx-dev-runtime.d.ts"
 		];
-		if (await this.hasTypePackage(reactTypesDir, REACT_TYPES_VERSION, reactFiles)) info("📦 React types (from cache)");
+		if (await this.hasTypePackage(reactTypesDir, REACT_TYPES_VERSION, reactFiles)) debug("📦 React types (from cache)");
 		else {
-			info("Downloading React 18 types for Framer compatibility...");
+			debug("Downloading React 18 types...");
 			await this.downloadTypePackage("@types/react", REACT_TYPES_VERSION, reactTypesDir, reactFiles);
 		}
 		const reactDomDir = path.join(this.projectDir, "node_modules/@types/react-dom");
@@ -950,15 +1336,14 @@ declare module "*.json"
 			"index.d.ts",
 			"client.d.ts"
 		];
-		if (await this.hasTypePackage(reactDomDir, REACT_DOM_TYPES_VERSION, reactDomFiles)) info("📦 React DOM types (from cache)");
+		if (await this.hasTypePackage(reactDomDir, REACT_DOM_TYPES_VERSION, reactDomFiles)) debug("📦 React DOM types (from cache)");
 		else await this.downloadTypePackage("@types/react-dom", REACT_DOM_TYPES_VERSION, reactDomDir, reactDomFiles);
 	}
 	async hasTypePackage(destinationDir, version, files) {
 		try {
 			const pkgJsonPath = path.join(destinationDir, "package.json");
 			const pkgJson = await fs.readFile(pkgJsonPath, "utf-8");
-			const parsed = JSON.parse(pkgJson);
-			if (parsed.version !== version) return false;
+			if (JSON.parse(pkgJson).version !== version) return false;
 			for (const file of files) {
 				if (file === "package.json") continue;
 				await fs.access(path.join(destinationDir, file));
@@ -1015,7 +1400,13 @@ async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
 }
 
 //#endregion
-//#region src/utils/hashing.ts
+//#region src/utils/hash-tracker.ts
+/**
+* Hash tracking utilities for echo prevention
+*
+* The hash tracker prevents echo loops by remembering content hashes
+* and skipping watcher events for files we just wrote.
+*/
 /**
 * Creates a hash tracker instance for echo prevention
 */
@@ -1029,8 +1420,7 @@ function createHashTracker() {
 		},
 		shouldSkip(filePath, content) {
 			const currentHash = hashContent(content);
-			const storedHash = hashes.get(filePath);
-			return storedHash === currentHash;
+			return hashes.get(filePath) === currentHash;
 		},
 		forget(filePath) {
 			hashes.delete(filePath);
@@ -1057,26 +1447,11 @@ function createHashTracker() {
 	};
 }
 /**
-* Computes a hash of file content for comparison
+* Computes a SHA256 hash of file content for comparison
 */
 function hashContent(content) {
 	return createHash("sha256").update(content).digest("hex");
 }
-/**
-* Generate a deterministic port number from a project hash
-* Port range: 3847-4096 (250 possible ports)
-* Uses simple hash to match client-side implementation
-*/
-function getPortFromHash(projectHash) {
-	let hash = 0;
-	for (let i = 0; i < projectHash.length; i++) {
-		const char = projectHash.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
-	}
-	const portOffset = Math.abs(hash) % 250;
-	return 3847 + portOffset;
-}
 
 //#endregion
 //#region src/utils/file-metadata-cache.ts
@@ -1183,7 +1558,7 @@ var UserActionCoordinator = class {
 				return await confirmationPromise;
 			} catch (err) {
 				if (err instanceof PluginDisconnectedError) {
-					info(`[USER-ACTION] Plugin disconnected while waiting for delete confirmation: ${fileName}`);
+					debug(`Plugin disconnected while waiting for delete confirmation: ${fileName}`);
 					return false;
 				}
 				throw err;
@@ -1215,7 +1590,7 @@ var UserActionCoordinator = class {
 			return new Map(results);
 		} catch (err) {
 			if (err instanceof PluginDisconnectedError) {
-				info("[USER-ACTION] Plugin disconnected while awaiting conflict decisions");
+				debug("Plugin disconnected while awaiting conflict decisions");
 				return /* @__PURE__ */ new Map();
 			}
 			throw err;
@@ -1230,7 +1605,7 @@ var UserActionCoordinator = class {
 				resolve,
 				reject
 			});
-			info(`[USER-ACTION] Awaiting ${description}: ${actionId}`);
+			debug(`Awaiting ${description}: ${actionId}`);
 		});
 	}
 	/**
@@ -1239,12 +1614,12 @@ var UserActionCoordinator = class {
 	handleConfirmation(actionId, value) {
 		const pending = this.pendingActions.get(actionId);
 		if (!pending) {
-			warn(`[USER-ACTION] Unexpected confirmation for ${actionId}`);
+			debug(`Unexpected confirmation for ${actionId}`);
 			return false;
 		}
 		this.pendingActions.delete(actionId);
 		pending.resolve(value);
-		info(`[USER-ACTION] Confirmed: ${actionId}`);
+		debug(`Confirmed: ${actionId}`);
 		return true;
 	}
 	/**
@@ -1253,7 +1628,7 @@ var UserActionCoordinator = class {
 	cleanup() {
 		for (const [actionId, pending] of this.pendingActions.entries()) {
 			pending.reject(new PluginDisconnectedError());
-			warn(`[USER-ACTION] Cancelled pending action: ${actionId}`);
+			debug(`Cancelled pending action: ${actionId}`);
 		}
 		this.pendingActions.clear();
 	}
@@ -1301,14 +1676,13 @@ function toPackageName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
 }
 function toDirName(name) {
-	return name.replace(/[^a-zA-Z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+	return name.replace(/[^a-zA-Z0-9- ]/g, "-").replace(/^[-\s]+|[-\s]+$/g, "").replace(/-+/g, "-");
 }
 async function getProjectHashFromCwd() {
 	try {
 		const packageJsonPath = path.join(process.cwd(), "package.json");
 		const content = await fs.readFile(packageJsonPath, "utf-8");
-		const pkg = JSON.parse(content);
-		return pkg.framerProjectId ?? null;
+		return JSON.parse(content).shortProjectHash ?? null;
 	} catch {
 		return null;
 	}
@@ -1325,21 +1699,22 @@ async function findOrCreateProjectDir(projectHash, projectName, explicitDir) {
 	if (!projectName) throw new Error("Project name is required when creating a new workspace. Pass --name <project name>.");
 	const dirName = toDirName(projectName);
 	const pkgName = toPackageName(projectName);
-	const projectDir = path.join(cwd, dirName || projectHash.slice(0, 6));
+	const shortId = shortProjectHash(projectHash);
+	const projectDir = path.join(cwd, dirName || shortId);
 	await fs.mkdir(path.join(projectDir, "files"), { recursive: true });
 	const pkg = {
-		name: pkgName || projectHash,
+		name: pkgName || shortId,
 		version: "1.0.0",
 		private: true,
-		framerProjectId: projectHash,
+		shortProjectHash: shortId,
+		framerProjectHash: projectHash,
 		framerProjectName: projectName
 	};
 	await fs.writeFile(path.join(projectDir, "package.json"), JSON.stringify(pkg, null, 2));
 	return projectDir;
 }
 async function findExistingProjectDir(baseDir, projectHash) {
-	const candidate = path.join(baseDir, "package.json");
-	if (await matchesProject(candidate, projectHash)) return baseDir;
+	if (await matchesProject(path.join(baseDir, "package.json"), projectHash)) return baseDir;
 	const entries = await fs.readdir(baseDir, { withFileTypes: true });
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
@@ -1352,7 +1727,8 @@ async function matchesProject(packageJsonPath, projectHash) {
 	try {
 		const content = await fs.readFile(packageJsonPath, "utf-8");
 		const pkg = JSON.parse(content);
-		return pkg.framerProjectId === projectHash;
+		const inputShort = shortProjectHash(projectHash);
+		return pkg.shortProjectHash === inputShort;
 	} catch {
 		return false;
 	}
@@ -1360,6 +1736,11 @@ async function matchesProject(packageJsonPath, projectHash) {
 
 //#endregion
 //#region src/controller.ts
+/**
+* Controller
+* Single source of truth for all runtime state and orchestrates the sync lifecycle.
+* Helpers are functions that provide data - they never hold control or callbacks.
+*/
 /** Log helper */
 function log(level, message) {
 	return {
@@ -1369,13 +1750,23 @@ function log(level, message) {
 	};
 }
 /**
+* Filter out files whose content matches the last remembered hash.
+* Used to skip inbound echoes of our own local sends.
+*/
+function filterEchoedFiles(files, hashTracker) {
+	return files.filter((file) => {
+		if (file.content === void 0) return true;
+		return !hashTracker.shouldSkip(file.name, file.content);
+	});
+}
+/**
 * Pure state transition function
 * Takes current state + event, returns new state + effects to execute
 */
 function transition(state, event) {
 	const effects = [];
 	switch (event.type) {
-		case "HANDSHAKE": {
+		case "HANDSHAKE":
 			if (state.mode !== "disconnected") {
 				effects.push(log("warn", `Received HANDSHAKE in mode ${state.mode}, ignoring`));
 				return {
@@ -1398,9 +1789,8 @@ function transition(state, event) {
 				},
 				effects
 			};
-		}
-		case "FILE_SYNCED": {
-			effects.push(log("info", `Remote confirmed sync: ${event.fileName}`), {
+		case "FILE_SYNCED":
+			effects.push(log("debug", `Remote confirmed sync: ${event.fileName}`), {
 				type: "UPDATE_FILE_METADATA",
 				fileName: event.fileName,
 				remoteModifiedAt: event.remoteModifiedAt
@@ -1409,11 +1799,10 @@ function transition(state, event) {
 				state,
 				effects
 			};
-		}
-		case "DISCONNECT": {
-			effects.push({ type: "PERSIST_STATE" }, log("info", "Disconnected, persisting state"));
+		case "DISCONNECT":
+			effects.push({ type: "PERSIST_STATE" }, log("debug", "Disconnected, persisting state"));
 			if (state.mode === "conflict_resolution") {
-				const { pendingConflicts: _discarded,...rest } = state;
+				const { pendingConflicts: _discarded, ...rest } = state;
 				return {
 					state: {
 						...rest,
@@ -1431,8 +1820,7 @@ function transition(state, event) {
 				},
 				effects
 			};
-		}
-		case "REQUEST_FILES": {
+		case "REQUEST_FILES":
 			if (state.mode === "disconnected") {
 				effects.push(log("warn", "Received REQUEST_FILES while disconnected, ignoring"));
 				return {
@@ -1440,13 +1828,12 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", "Plugin requested file list"), { type: "LIST_LOCAL_FILES" });
+			effects.push(log("debug", "Plugin requested file list"), { type: "LIST_LOCAL_FILES" });
 			return {
 				state,
 				effects
 			};
-		}
-		case "FILE_LIST": {
+		case "FILE_LIST":
 			if (state.mode !== "handshaking") {
 				effects.push(log("warn", `Received FILE_LIST in mode ${state.mode}, ignoring`));
 				return {
@@ -1454,7 +1841,7 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", `Received file list: ${event.files.length} files`));
+			effects.push(log("debug", `Received file list: ${event.files.length} files`));
 			effects.push({
 				type: "DETECT_CONFLICTS",
 				remoteFiles: event.files
@@ -1467,7 +1854,6 @@ function transition(state, event) {
 				},
 				effects
 			};
-		}
 		case "CONFLICTS_DETECTED": {
 			if (state.mode !== "snapshot_processing") {
 				effects.push(log("warn", `Received CONFLICTS_DETECTED in mode ${state.mode}, ignoring`));
@@ -1477,12 +1863,13 @@ function transition(state, event) {
 				};
 			}
 			const { conflicts, safeWrites, localOnly } = event;
-			if (safeWrites.length > 0) effects.push(log("info", `Applying ${safeWrites.length} safe writes`), {
+			if (safeWrites.length > 0) effects.push(log("debug", `Applying ${safeWrites.length} safe writes`), {
 				type: "WRITE_FILES",
-				files: safeWrites
+				files: safeWrites,
+				silent: true
 			});
 			if (localOnly.length > 0) {
-				effects.push(log("info", `Uploading ${localOnly.length} local-only files`));
+				effects.push(log("debug", `Uploading ${localOnly.length} local-only files`));
 				for (const file of localOnly) effects.push({
 					type: "SEND_MESSAGE",
 					payload: {
@@ -1493,7 +1880,7 @@ function transition(state, event) {
 				});
 			}
 			if (conflicts.length > 0) {
-				effects.push(log("warn", `${conflicts.length} conflicts require version verification`), log("info", "[CONFLICTS] Requesting remote version data from plugin..."), {
+				effects.push(log("debug", `${pluralize(conflicts.length, "conflict")} require version check`), {
 					type: "REQUEST_CONFLICT_VERSIONS",
 					conflicts
 				});
@@ -1506,7 +1893,16 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", "Initial sync complete, entering watch mode"), { type: "PERSIST_STATE" });
+			const remoteTotal = state.queuedDiffs.length;
+			const totalCount = remoteTotal + localOnly.length;
+			const updatedCount = safeWrites.length + localOnly.length;
+			const unchangedCount = Math.max(0, remoteTotal - safeWrites.length);
+			effects.push({ type: "PERSIST_STATE" }, {
+				type: "SYNC_COMPLETE",
+				totalCount,
+				updatedCount,
+				unchangedCount
+			});
 			return {
 				state: {
 					...state,
@@ -1535,16 +1931,17 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", `Applying remote change: ${event.file.name}`), {
+			effects.push(log("debug", `Applying remote change: ${event.file.name}`), {
 				type: "WRITE_FILES",
-				files: [event.file]
+				files: [event.file],
+				skipEcho: true
 			});
 			return {
 				state,
 				effects
 			};
 		}
-		case "REMOTE_FILE_DELETE": {
+		case "REMOTE_FILE_DELETE":
 			if (state.mode === "disconnected") {
 				effects.push(log("warn", `Rejected delete while disconnected: ${event.fileName}`));
 				return {
@@ -1552,7 +1949,7 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", `Remote delete applied: ${event.fileName}`), {
+			effects.push(log("debug", `Remote delete applied: ${event.fileName}`), {
 				type: "DELETE_LOCAL_FILES",
 				names: [event.fileName]
 			}, { type: "PERSIST_STATE" });
@@ -1560,9 +1957,8 @@ function transition(state, event) {
 				state,
 				effects
 			};
-		}
-		case "REMOTE_DELETE_CONFIRMED": {
-			effects.push(log("info", `Delete confirmed: ${event.fileName}`), {
+		case "REMOTE_DELETE_CONFIRMED":
+			effects.push(log("debug", `Delete confirmed: ${event.fileName}`), {
 				type: "DELETE_LOCAL_FILES",
 				names: [event.fileName]
 			}, { type: "PERSIST_STATE" });
@@ -1570,9 +1966,8 @@ function transition(state, event) {
 				state,
 				effects
 			};
-		}
-		case "REMOTE_DELETE_CANCELLED": {
-			effects.push(log("info", `Delete cancelled: ${event.fileName}`));
+		case "REMOTE_DELETE_CANCELLED":
+			effects.push(log("debug", `Delete cancelled: ${event.fileName}`));
 			effects.push({
 				type: "WRITE_FILES",
 				files: [{
@@ -1585,7 +1980,6 @@ function transition(state, event) {
 				state,
 				effects
 			};
-		}
 		case "CONFLICTS_RESOLVED": {
 			if (state.mode !== "conflict_resolution") {
 				effects.push(log("warn", `Received CONFLICTS_RESOLVED in mode ${state.mode}, ignoring`));
@@ -1595,18 +1989,28 @@ function transition(state, event) {
 				};
 			}
 			if (event.resolution === "remote") {
-				const remoteFiles = state.pendingConflicts.map((c) => ({
-					name: c.fileName,
-					content: c.remoteContent,
-					modifiedAt: c.remoteModifiedAt
-				}));
-				effects.push(log("info", `Applying ${remoteFiles.length} remote versions`), {
+				for (const conflict of state.pendingConflicts) if (conflict.remoteContent === null) effects.push({
+					type: "DELETE_LOCAL_FILES",
+					names: [conflict.fileName]
+				});
+				else effects.push({
 					type: "WRITE_FILES",
-					files: remoteFiles
+					files: [{
+						name: conflict.fileName,
+						content: conflict.remoteContent,
+						modifiedAt: conflict.remoteModifiedAt
+					}]
 				});
+				effects.push(log("debug", `Applied ${state.pendingConflicts.length} remote versions`));
 			} else {
-				effects.push(log("info", `Applying ${state.pendingConflicts.length} local versions`));
-				for (const conflict of state.pendingConflicts) effects.push({
+				for (const conflict of state.pendingConflicts) if (conflict.localContent === null) effects.push({
+					type: "SEND_MESSAGE",
+					payload: {
+						type: "file-delete",
+						fileNames: [conflict.fileName]
+					}
+				});
+				else effects.push({
 					type: "SEND_MESSAGE",
 					payload: {
 						type: "file-change",
@@ -1614,9 +2018,15 @@ function transition(state, event) {
 						content: conflict.localContent
 					}
 				});
+				effects.push(log("debug", `Applied ${state.pendingConflicts.length} local versions`));
 			}
-			effects.push(log("info", "All conflicts resolved, entering watch mode"), { type: "PERSIST_STATE" });
-			const { pendingConflicts: _discarded,...rest } = state;
+			effects.push({ type: "PERSIST_STATE" }, {
+				type: "SYNC_COMPLETE",
+				totalCount: state.pendingConflicts.length,
+				updatedCount: state.pendingConflicts.length,
+				unchangedCount: 0
+			});
+			const { pendingConflicts: _discarded, ...rest } = state;
 			return {
 				state: {
 					...rest,
@@ -1636,7 +2046,7 @@ function transition(state, event) {
 			}
 			switch (kind) {
 				case "add":
-				case "change": {
+				case "change":
 					if (content === void 0) {
 						effects.push(log("warn", `Watcher event missing content: ${relativePath}`));
 						return {
@@ -1644,22 +2054,19 @@ function transition(state, event) {
 							effects
 						};
 					}
-					effects.push(log("info", `Local change detected: ${relativePath}`));
 					effects.push({
 						type: "SEND_LOCAL_CHANGE",
 						fileName: relativePath,
 						content
 					});
 					break;
-				}
-				case "delete": {
-					effects.push(log("info", `Local delete detected: ${relativePath}`), {
+				case "delete":
+					effects.push(log("debug", `Local delete detected: ${relativePath}`), {
 						type: "REQUEST_LOCAL_DELETE_DECISION",
 						fileName: relativePath,
 						requireConfirmation: true
 					});
 					break;
-				}
 			}
 			return {
 				state,
@@ -1676,23 +2083,37 @@ function transition(state, event) {
 			}
 			const { autoResolvedLocal, autoResolvedRemote, remainingConflicts } = autoResolveConflicts(state.pendingConflicts, event.versions);
 			if (autoResolvedLocal.length > 0) {
-				effects.push(log("info", `[AUTO-RESOLVE] Applying ${autoResolvedLocal.length} local changes`));
-				for (const conflict of autoResolvedLocal) effects.push({
+				effects.push(log("debug", `Auto-resolved ${autoResolvedLocal.length} local changes`));
+				for (const conflict of autoResolvedLocal) if (conflict.localContent === null) effects.push({
+					type: "SEND_MESSAGE",
+					payload: {
+						type: "file-delete",
+						fileNames: [conflict.fileName]
+					}
+				});
+				else effects.push({
 					type: "SEND_LOCAL_CHANGE",
 					fileName: conflict.fileName,
 					content: conflict.localContent
 				});
 			}
-			if (autoResolvedRemote.length > 0) effects.push(log("info", `[AUTO-RESOLVE] Applying ${autoResolvedRemote.length} remote changes`), {
-				type: "WRITE_FILES",
-				files: autoResolvedRemote.map((conflict) => ({
-					name: conflict.fileName,
-					content: conflict.remoteContent,
-					modifiedAt: conflict.remoteModifiedAt ?? Date.now()
-				}))
-			});
+			if (autoResolvedRemote.length > 0) {
+				effects.push(log("debug", `Auto-resolved ${autoResolvedRemote.length} remote changes`));
+				for (const conflict of autoResolvedRemote) if (conflict.remoteContent === null) effects.push({
+					type: "DELETE_LOCAL_FILES",
+					names: [conflict.fileName]
+				});
+				else effects.push({
+					type: "WRITE_FILES",
+					files: [{
+						name: conflict.fileName,
+						content: conflict.remoteContent,
+						modifiedAt: conflict.remoteModifiedAt ?? Date.now()
+					}]
+				});
+			}
 			if (remainingConflicts.length > 0) {
-				effects.push(log("warn", `[AUTO-RESOLVE] ${remainingConflicts.length} conflicts require user resolution`), {
+				effects.push(log("warn", `${pluralize(remainingConflicts.length, "conflict")} require resolution`), {
 					type: "REQUEST_CONFLICT_DECISIONS",
 					conflicts: remainingConflicts
 				});
@@ -1704,8 +2125,14 @@ function transition(state, event) {
 					effects
 				};
 			}
-			effects.push(log("info", "[AUTO-RESOLVE] All conflicts auto-resolved!"), { type: "PERSIST_STATE" });
-			const { pendingConflicts: _discarded,...rest } = state;
+			const resolvedCount = autoResolvedLocal.length + autoResolvedRemote.length;
+			effects.push({ type: "PERSIST_STATE" }, {
+				type: "SYNC_COMPLETE",
+				totalCount: resolvedCount,
+				updatedCount: resolvedCount,
+				unchangedCount: 0
+			});
+			const { pendingConflicts: _discarded, ...rest } = state;
 			return {
 				state: {
 					...rest,
@@ -1715,13 +2142,12 @@ function transition(state, event) {
 				effects
 			};
 		}
-		default: {
+		default:
 			effects.push(log("warn", `Unhandled event type in transition`));
 			return {
 				state,
 				effects
 			};
-		}
 	}
 }
 /**
@@ -1731,23 +2157,21 @@ function transition(state, event) {
 async function executeEffect(effect, context) {
 	const { config, hashTracker, installer, fileMetadataCache, userActions, syncState } = context;
 	switch (effect.type) {
-		case "INIT_WORKSPACE": {
+		case "INIT_WORKSPACE":
 			if (!config.projectDir) {
 				const projectName = config.explicitName ?? effect.projectInfo.projectName;
 				config.projectDir = await findOrCreateProjectDir(config.projectHash, projectName, config.explicitDir);
 				config.filesDir = `${config.projectDir}/files`;
-				info(`Files directory: ${config.filesDir}`);
+				debug(`Files directory: ${config.filesDir}`);
 				await fs.mkdir(config.filesDir, { recursive: true });
 			}
 			return [];
-		}
-		case "LOAD_PERSISTED_STATE": {
+		case "LOAD_PERSISTED_STATE":
 			if (config.projectDir) {
 				await fileMetadataCache.initialize(config.projectDir);
-				info(`Loaded persisted metadata for ${fileMetadataCache.size()} files`);
+				debug(`Loaded persisted metadata for ${fileMetadataCache.size()} files`);
 			}
 			return [];
-		}
 		case "LIST_LOCAL_FILES": {
 			if (!config.filesDir) return [];
 			const files = await listFiles(config.filesDir);
@@ -1759,7 +2183,8 @@ async function executeEffect(effect, context) {
 		}
 		case "DETECT_CONFLICTS": {
 			if (!config.filesDir) return [];
-			const { conflicts, writes, localOnly } = await detectConflicts(effect.remoteFiles, config.filesDir, { persistedState: fileMetadataCache.getPersistedState() });
+			const { conflicts, writes, localOnly, unchanged } = await detectConflicts(effect.remoteFiles, config.filesDir, { persistedState: fileMetadataCache.getPersistedState() });
+			for (const file of unchanged) fileMetadataCache.recordRemoteWrite(file.name, file.content, file.modifiedAt ?? Date.now());
 			return [{
 				type: "CONFLICTS_DETECTED",
 				conflicts,
@@ -1767,34 +2192,34 @@ async function executeEffect(effect, context) {
 				localOnly
 			}];
 		}
-		case "SEND_MESSAGE": {
+		case "SEND_MESSAGE":
 			if (syncState.socket) {
-				const sent = await sendMessage(syncState.socket, effect.payload);
-				if (!sent) warn(`Failed to send message: ${effect.payload.type}`);
+				if (!await sendMessage(syncState.socket, effect.payload)) warn(`Failed to send message: ${effect.payload.type}`);
 			} else warn(`No socket available to send: ${effect.payload.type}`);
 			return [];
-		}
-		case "WRITE_FILES": {
+		case "WRITE_FILES":
 			if (config.filesDir) {
-				await writeRemoteFiles(effect.files, config.filesDir, hashTracker, installer ?? void 0);
-				for (const file of effect.files) {
+				const filesToWrite = effect.skipEcho === true ? filterEchoedFiles(effect.files, hashTracker) : effect.files;
+				if (effect.skipEcho && filesToWrite.length !== effect.files.length) debug(`Skipped ${pluralize(effect.files.length - filesToWrite.length, "echoed change")}`);
+				if (filesToWrite.length === 0) return [];
+				await writeRemoteFiles(filesToWrite, config.filesDir, hashTracker, installer ?? void 0);
+				for (const file of filesToWrite) {
+					if (!effect.silent) fileDown(file.name);
 					const remoteTimestamp = file.modifiedAt ?? Date.now();
 					fileMetadataCache.recordRemoteWrite(file.name, file.content, remoteTimestamp);
 				}
 			}
 			return [];
-		}
-		case "DELETE_LOCAL_FILES": {
+		case "DELETE_LOCAL_FILES":
 			if (config.filesDir) for (const fileName of effect.names) {
 				await deleteLocalFile(fileName, config.filesDir, hashTracker);
+				fileDelete(fileName);
 				fileMetadataCache.recordDelete(fileName);
 			}
 			return [];
-		}
-		case "REQUEST_CONFLICT_DECISIONS": {
+		case "REQUEST_CONFLICT_DECISIONS":
 			await userActions.requestConflictDecisions(syncState.socket, effect.conflicts);
 			return [];
-		}
 		case "REQUEST_CONFLICT_VERSIONS": {
 			if (!syncState.socket) {
 				warn("Cannot request conflict versions without active socket");
@@ -1808,21 +2233,20 @@ async function executeEffect(effect, context) {
 					lastSyncedAt: conflict.lastSyncedAt ?? persisted?.timestamp
 				};
 			});
-			info(`[CONFLICTS] Requesting remote version data for ${versionRequests.length} file(s)`);
+			debug(`Requesting remote version data for ${pluralize(versionRequests.length, "file")}`);
 			await sendMessage(syncState.socket, {
 				type: "conflict-version-request",
 				conflicts: versionRequests
 			});
 			return [];
 		}
-		case "REQUEST_DELETE_CONFIRMATION": {
+		case "REQUEST_DELETE_CONFIRMATION":
 			if (syncState.socket) await sendMessage(syncState.socket, {
 				type: "file-delete",
 				fileNames: [effect.fileName],
 				requireConfirmation: effect.requireConfirmation
 			});
 			return [];
-		}
 		case "UPDATE_FILE_METADATA": {
 			if (!config.filesDir || !config.projectDir) return [];
 			const currentContent = await readFileSafe(effect.fileName, config.filesDir);
@@ -1833,32 +2257,39 @@ async function executeEffect(effect, context) {
 			return [];
 		}
 		case "SEND_LOCAL_CHANGE": {
+			const contentHash = hashFileContent(effect.content);
+			if (fileMetadataCache.get(effect.fileName)?.lastSyncedHash === contentHash) {
+				debug(`Skipping local change for ${effect.fileName}: matches last synced content`);
+				return [];
+			}
 			if (hashTracker.shouldSkip(effect.fileName, effect.content)) return [];
+			debug(`Local change detected: ${effect.fileName}`);
 			try {
-				if (syncState.socket) await sendMessage(syncState.socket, {
-					type: "file-change",
-					fileName: effect.fileName,
-					content: effect.content
-				});
+				if (syncState.socket) {
+					await sendMessage(syncState.socket, {
+						type: "file-change",
+						fileName: effect.fileName,
+						content: effect.content
+					});
+					fileUp(effect.fileName);
+				}
 				hashTracker.remember(effect.fileName, effect.content);
 				if (installer) installer.process(effect.fileName, effect.content);
 			} catch (err) {
-				console.warn(`Failed to push change for ${effect.fileName}, will re-sync on next diff:`, err);
+				warn(`Failed to push ${effect.fileName}`);
 			}
 			return [];
 		}
-		case "REQUEST_LOCAL_DELETE_DECISION": {
-			const shouldSkip = hashTracker.shouldSkipDelete(effect.fileName);
-			if (shouldSkip) {
+		case "REQUEST_LOCAL_DELETE_DECISION":
+			if (hashTracker.shouldSkipDelete(effect.fileName)) {
 				hashTracker.clearDelete(effect.fileName);
 				return [];
 			}
 			try {
-				const shouldDelete = await userActions.requestDeleteDecision(syncState.socket, {
+				if (await userActions.requestDeleteDecision(syncState.socket, {
 					fileName: effect.fileName,
 					requireConfirmation: !config.dangerouslyAutoDelete
-				});
-				if (shouldDelete) {
+				})) {
 					hashTracker.forget(effect.fileName);
 					fileMetadataCache.recordDelete(effect.fileName);
 					if (syncState.socket) await sendMessage(syncState.socket, {
@@ -1870,25 +2301,34 @@ async function executeEffect(effect, context) {
 				console.warn(`Failed to handle deletion for ${effect.fileName}:`, err);
 			}
 			return [];
-		}
-		case "PERSIST_STATE": {
+		case "PERSIST_STATE":
 			await fileMetadataCache.flush();
 			return [];
-		}
-		case "LOG": {
-			const logFn = effect.level === "info" ? info : effect.level === "warn" ? warn : debug;
-			logFn(effect.message);
+		case "SYNC_COMPLETE": {
+			const wasDisconnected = wasRecentlyDisconnected();
+			if (syncState.socket) await sendMessage(syncState.socket, { type: "sync-complete" });
+			if (wasDisconnected) {
+				if (didShowDisconnect()) {
+					success(`Reconnected, synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`);
+					status("Watching for changes...");
+				}
+				resetDisconnectState();
+				return [];
+			}
+			success(`Synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`);
+			status("Watching for changes...");
 			return [];
 		}
+		case "LOG":
+			(effect.level === "info" ? info : effect.level === "warn" ? warn : debug)(effect.message);
+			return [];
 	}
 }
 /**
 * Starts the sync controller with the given configuration
 */
 async function start(config) {
-	info("🚀 Starting Code Link");
-	info(`Project: ${config.projectHash}`);
-	info(`Port: ${config.port} (auto-selected from project hash)`);
+	status("Waiting for Plugin connection...");
 	const hashTracker = createHashTracker();
 	const fileMetadataCache = new FileMetadataCache();
 	let installer = null;
@@ -1902,13 +2342,13 @@ async function start(config) {
 	const userActions = new UserActionCoordinator();
 	async function processEvent(event) {
 		const socketState = syncState.socket?.readyState;
-		info(`[STATE] Processing event: ${event.type} (mode: ${syncState.mode}, socket: ${socketState ?? "none"})`);
+		debug(`[STATE] Processing event: ${event.type} (mode: ${syncState.mode}, socket: ${socketState ?? "none"})`);
 		const result = transition(syncState, event);
 		syncState = result.state;
-		if (result.effects.length > 0) info(`[STATE] Event produced ${result.effects.length} effects: ${result.effects.map((e) => e.type).join(", ")}`);
+		if (result.effects.length > 0) debug(`[STATE] Event produced ${result.effects.length} effects: ${result.effects.map((e) => e.type).join(", ")}`);
 		for (const effect of result.effects) {
 			const currentSocketState = syncState.socket?.readyState;
-			if (currentSocketState !== void 0 && currentSocketState !== 1) warn(`[STATE] Socket not open (state: ${currentSocketState}) before executing ${effect.type}`);
+			if (currentSocketState !== void 0 && currentSocketState !== 1) debug(`[STATE] Socket not open (state: ${currentSocketState}) before executing ${effect.type}`);
 			const followUpEvents = await executeEffect(effect, {
 				config,
 				hashTracker,
@@ -1922,10 +2362,11 @@ async function start(config) {
 	}
 	const connection = await initConnection(config.port);
 	connection.on("handshake", async (client, message) => {
-		info("Received handshake from plugin");
-		info(`Project: ${message.projectName} (${message.projectId})`);
-		if (message.projectId !== config.projectHash) {
-			warn(`Project ID mismatch: expected ${config.projectHash}, got ${message.projectId}`);
+		debug(`Received handshake: ${message.projectName} (${message.projectId})`);
+		const expectedShort = shortProjectHash(config.projectHash);
+		const receivedShort = shortProjectHash(message.projectId);
+		if (receivedShort !== expectedShort) {
+			warn(`Project ID mismatch: expected ${expectedShort}, got ${receivedShort}`);
 			client.close();
 			return;
 		}
@@ -1942,7 +2383,8 @@ async function start(config) {
 			await installer.initialize();
 			startWatcher();
 		}
-		success("Handshake successful - connection established");
+		cancelDisconnectMessage();
+		if (!wasRecentlyDisconnected() && !didShowDisconnect()) success(`Connected to ${message.projectName}`);
 	});
 	async function handleMessage(message) {
 		if (!config.projectDir || !installer) {
@@ -1956,7 +2398,7 @@ async function start(config) {
 				break;
 			case "file-list": {
 				const totalSize = message.files.reduce((sum, f) => sum + (f.content?.length ?? 0), 0);
-				info(`[FILE_LIST] Received ${message.files.length} files (${(totalSize / 1024).toFixed(1)}KB total)`);
+				debug(`Received file list: ${message.files.length} files (${(totalSize / 1024).toFixed(1)}KB)`);
 				event = {
 					type: "FILE_LIST",
 					files: message.files
@@ -1974,26 +2416,22 @@ async function start(config) {
 					fileMeta: fileMetadataCache.get(message.fileName)
 				};
 				break;
-			case "file-delete": {
+			case "file-delete":
 				for (const fileName of message.fileNames) await processEvent({
 					type: "REMOTE_FILE_DELETE",
 					fileName
 				});
 				return;
-			}
 			case "delete-confirmed": {
 				const unmatched = [];
-				for (const fileName of message.fileNames) {
-					const handled = userActions.handleConfirmation(`delete:${fileName}`, true);
-					if (!handled) unmatched.push(fileName);
-				}
+				for (const fileName of message.fileNames) if (!userActions.handleConfirmation(`delete:${fileName}`, true)) unmatched.push(fileName);
 				for (const fileName of unmatched) await processEvent({
 					type: "REMOTE_DELETE_CONFIRMED",
 					fileName
 				});
 				return;
 			}
-			case "delete-cancelled": {
+			case "delete-cancelled":
 				for (const file of message.files) {
 					userActions.handleConfirmation(`delete:${file.fileName}`, false);
 					await processEvent({
@@ -2003,7 +2441,6 @@ async function start(config) {
 					});
 				}
 				return;
-			}
 			case "file-synced":
 				event = {
 					type: "FILE_SYNCED",
@@ -2037,10 +2474,11 @@ async function start(config) {
 		}
 	});
 	connection.on("disconnect", async () => {
-		warn("Plugin disconnected");
+		scheduleDisconnectMessage(() => {
+			status("Disconnected, waiting to reconnect...");
+		});
 		await processEvent({ type: "DISCONNECT" });
 		userActions.cleanup();
-		info("Will perform full diff on reconnect");
 	});
 	connection.on("error", (err) => {
 		error("Error on WebSocket connection:", err);
@@ -2056,10 +2494,9 @@ async function start(config) {
 			});
 		});
 	};
-	info("✓ Controller initialized and ready");
-	info(`Waiting for plugin connection on port ${config.port}...`);
 	process.on("SIGINT", async () => {
-		info("\nShutting down gracefully...");
+		console.log();
+		status("Shutting down...");
 		if (watcher) await watcher.close();
 		connection.close();
 		process.exit(0);
@@ -2068,6 +2505,12 @@ async function start(config) {
 
 //#endregion
 //#region src/index.ts
+/**
+* Framer Code Link CLI - Next Generation
+*
+* Entry point for the CLI tool. Parses command-line arguments and starts
+* the controller with the appropriate configuration.
+*/
 const program = new Command();
 program.exitOverride((err) => {
 	if (err.code === "commander.missingArgument") {
@@ -2088,16 +2531,16 @@ program.name("code-link").description("Sync Framer code components to your local
 	}
 	const isDev = process.env.NODE_ENV === "development";
 	if (options.logLevel) {
-		const levelMap = {
+		const level = {
 			debug: LogLevel.DEBUG,
 			info: LogLevel.INFO,
 			warn: LogLevel.WARN,
 			error: LogLevel.ERROR
-		};
-		const level = levelMap[options.logLevel.toLowerCase()];
+		}[options.logLevel.toLowerCase()];
 		if (level !== void 0) setLogLevel(level);
 	} else if (options.verbose || isDev) setLogLevel(LogLevel.DEBUG);
 	const port = getPortFromHash(projectHash);
+	banner("0.1.3", port);
 	const config = {
 		port,
 		projectHash,
@@ -2107,7 +2550,7 @@ program.name("code-link").description("Sync Framer code components to your local
 		explicitDir: options.dir,
 		explicitName: options.name
 	};
-	if (config.dangerouslyAutoDelete) info("⚠️  Auto-delete mode enabled - files will be deleted without confirmation");
+	if (config.dangerouslyAutoDelete) warn("Auto-delete mode enabled - files will be deleted without confirmation");
 	try {
 		await start(config);
 	} catch (err) {