scream-code 0.14.8 → 0.14.9

package/dist/{dispatch-DVJhr5Rj.mjs → dispatch-CJPpI4gm.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { Kt as handleConnectCommand } from "./dispatch-usl5yQnT.mjs";
+import { Kt as handleConnectCommand } from "./dispatch-1ojfKMwf.mjs";
 export { handleConnectCommand };

package/dist/main.mjs

@@ -6,7 +6,7 @@ const __dirname = __cjsShimDirname(__filename);
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
 //#region src/main.ts
 try {
-	(await import("./app-CJCkJpo_.mjs")).main();
+	(await import("./app-2Dd57a5d.mjs")).main();
 } catch (error) {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exit(1);

package/dist/{src-DCp4eCi5.mjs → src-h6ZExh4A.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { n as multiSearchWithTrace } from "./src-BH9W5k24.mjs";
+import { n as multiSearchWithTrace } from "./src-tDEINaMV.mjs";
 export { multiSearchWithTrace };

package/dist/{src-BH9W5k24.mjs → src-tDEINaMV.mjs}

@@ -3,6 +3,7 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
+import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -203,6 +204,8 @@ function jsonToVector(json) {
 function isEntityType(value) {
 	return ENTITY_TYPES$1.has(value);
 }
+/** Meta key recording which embedding model the stored vectors came from. */
+const EMBEDDING_MODEL_META_KEY = "embedding_model";
 var KnowledgeStore = class {
 	dbPath;
 	db;
@@ -288,6 +291,22 @@ var KnowledgeStore = class {
 			this.db.exec("ROLLBACK");
 		} catch {}
 	}
+	/**
+	* Read a metadata value (e.g. the embedding model identity the library was
+	* built with). Returns null when the key is absent.
+	*/
+	async getMeta(key) {
+		await this.init();
+		if (this.db === void 0) return null;
+		const row = this.db.prepare("SELECT value FROM knowledge_meta WHERE key = ?").get(key);
+		return row === void 0 ? null : asString(row["value"]);
+	}
+	/** Write a metadata value (upsert). */
+	async setMeta(key, value) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.prepare("INSERT INTO knowledge_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+	}
 	createSchema() {
 		if (this.db === void 0) return;
 		this.db.exec(`
@@ -383,22 +402,39 @@ var KnowledgeStore = class {
       CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_entities_fts USING fts5(
         name, description, content='knowledge_entities', content_rowid='rowid'
       );
+
+      CREATE TABLE IF NOT EXISTS knowledge_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
     `);
+		try {
+			this.db.exec("ALTER TABLE knowledge_sources ADD COLUMN content_hash TEXT");
+		} catch (error) {
+			if (!(error instanceof Error ? error.message : String(error)).includes("duplicate column")) throw error;
+		}
 	}
 	async createSource(params) {
 		await this.init();
 		if (this.db === void 0) throw new Error("knowledge store not initialized");
 		const id = generateId("src");
 		const createdAt = Date.now();
-		this.db.prepare("INSERT INTO knowledge_sources (id, name, file_path, description, created_at) VALUES (?, ?, ?, ?, ?)").run(id, params.name, params.filePath ?? null, params.description ?? null, createdAt);
+		this.db.prepare("INSERT INTO knowledge_sources (id, name, file_path, description, content_hash, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(id, params.name, params.filePath ?? null, params.description ?? null, params.contentHash ?? null, createdAt);
 		return {
 			id,
 			name: params.name,
 			filePath: params.filePath ?? null,
 			description: params.description ?? null,
+			contentHash: params.contentHash ?? null,
 			createdAt
 		};
 	}
+	/** Backfill or refresh a source's content fingerprint (legacy rows / replacements). */
+	async updateSourceContentHash(id, contentHash) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.prepare("UPDATE knowledge_sources SET content_hash = ? WHERE id = ?").run(contentHash, id);
+	}
 	async findSourceByFilePath(filePath) {
 		await this.init();
 		if (this.db === void 0) return void 0;
@@ -766,6 +802,87 @@ var KnowledgeStore = class {
 		}
 		return out;
 	}
+	/**
+	* Recompute every embedding for one source from the already-stored texts
+	* (no LLM extraction). Repairs libraries whose vectors are missing
+	* (ingested while the embedding model was unavailable) or stale (produced
+	* by a different model). All texts are embedded up front — any batch
+	* failure aborts before the first write, so the library is never left
+	* half-updated. On success the embedding-model meta is stamped with the
+	* engine's identity, unblocking future ingests after a model change.
+	*/
+	async reembedSource(sourceId, engine) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		if (!engine.available) throw new Error("embedding engine unavailable");
+		const chunkRows = this.db.prepare("SELECT id, heading, content FROM knowledge_chunks WHERE source_id = ? ORDER BY rank ASC").all(sourceId);
+		const chunkTexts = chunkRows.map((c) => c.heading !== null ? `${c.heading}\n${c.content}` : c.content);
+		const eventRows = this.db.prepare("SELECT id, title, content FROM knowledge_events WHERE source_id = ? ORDER BY rank ASC").all(sourceId);
+		const eventTitleTexts = eventRows.map((e) => e.title);
+		const eventContentTexts = eventRows.map((e) => `${e.title}\n\n${e.content}`);
+		const entityRows = this.db.prepare("SELECT id, name FROM knowledge_entities WHERE source_id = ?").all(sourceId);
+		const relationRows = this.db.prepare(`SELECT ee.id, ee.description, e.title, en.name
+         FROM knowledge_event_entities ee
+         JOIN knowledge_events e ON e.id = ee.event_id
+         JOIN knowledge_entities en ON en.id = ee.entity_id
+         WHERE e.source_id = ?`).all(sourceId);
+		const relationTexts = relationRows.map((r) => r.description !== null && r.description.length > 0 ? r.description : `${r.title} ${r.name}`);
+		const embedAll = async (texts) => {
+			if (texts.length === 0) return [];
+			const vectors = await engine.embedBatch(texts);
+			if (vectors === null || vectors.length !== texts.length) throw new Error("向量嵌入失败，已取消本次重新嵌入");
+			return vectors;
+		};
+		const chunkVecs = await embedAll(chunkTexts);
+		const eventTitleVecs = await embedAll(eventTitleTexts);
+		const eventContentVecs = await embedAll(eventContentTexts);
+		const entityVecs = await embedAll(entityRows.map((e) => e.name));
+		const relationVecs = await embedAll(relationTexts);
+		this.beginTransaction();
+		try {
+			const updChunk = this.db.prepare("UPDATE knowledge_chunks SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < chunkRows.length; i++) updChunk.run(vectorToJson(chunkVecs[i] ?? null), chunkRows[i].id);
+			const updEvent = this.db.prepare("UPDATE knowledge_events SET title_embedding_json = ?, content_embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < eventRows.length; i++) updEvent.run(vectorToJson(eventTitleVecs[i] ?? null), vectorToJson(eventContentVecs[i] ?? null), eventRows[i].id);
+			const updEntity = this.db.prepare("UPDATE knowledge_entities SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < entityRows.length; i++) updEntity.run(vectorToJson(entityVecs[i] ?? null), entityRows[i].id);
+			const updRelation = this.db.prepare("UPDATE knowledge_event_entities SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < relationRows.length; i++) updRelation.run(vectorToJson(relationVecs[i] ?? null), relationRows[i].id);
+			await this.setMeta(EMBEDDING_MODEL_META_KEY, engine.modelName);
+			this.commitTransaction();
+		} catch (error) {
+			this.rollbackTransaction();
+			throw error;
+		}
+		return {
+			chunks: chunkRows.length,
+			events: eventRows.length,
+			entities: entityRows.length,
+			relations: relationRows.length
+		};
+	}
+	/**
+	* Chunk vector coverage — how many of the stored chunks carry an embedding.
+	* Used by the TUI to surface partial/skipped embedding after an ingest.
+	*/
+	async embeddingCoverage() {
+		await this.init();
+		if (this.db === void 0) return {
+			total: 0,
+			embedded: 0
+		};
+		const row = this.db.prepare(`SELECT COUNT(*) AS total,
+                SUM(CASE WHEN embedding_json IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+         FROM knowledge_chunks`).get();
+		if (row === void 0) return {
+			total: 0,
+			embedded: 0
+		};
+		return {
+			total: Number(row["total"] ?? 0),
+			embedded: Number(row["embedded"] ?? 0)
+		};
+	}
 	async stats() {
 		await this.init();
 		if (this.db === void 0) return {
@@ -825,6 +942,7 @@ function rowToSource(row) {
 		name: asString(row["name"]),
 		filePath: asNullableString(row["file_path"]),
 		description: asNullableString(row["description"]),
+		contentHash: asNullableString(row["content_hash"]),
 		createdAt: Number(row["created_at"])
 	};
 }
@@ -1487,6 +1605,22 @@ async function mapWithConcurrency(items, limit, fn, onProgress) {
 	return results;
 }
 /**
+* Stamp or verify the embedding-model identity recorded in the library.
+* A library written by a different model would mix vector spaces — block the
+* ingest with a clear message instead of silently storing incompatible
+* embeddings. A legacy library without the marker is stamped with the current
+* model (all existing data was written by it).
+*/
+async function ensureEmbeddingModelMatches(store, engine) {
+	if (engine === void 0) return;
+	const recorded = await store.getMeta(EMBEDDING_MODEL_META_KEY);
+	if (recorded === null) {
+		await store.setMeta(EMBEDDING_MODEL_META_KEY, engine.modelName);
+		return;
+	}
+	if (recorded !== engine.modelName) throw new Error(`知识库由模型 ${recorded} 嵌入，当前模型为 ${engine.modelName}，请先在 /knowledge 中重新嵌入知识库`);
+}
+/**
 * Ingest a markdown file into the knowledge base.
 *
 * Steps:
@@ -1511,34 +1645,53 @@ async function ingestFile(store, llm, filePath, onProgress) {
 		stage: "embedding-check",
 		message: "向量模型未就绪，本次摄入跳过向量嵌入"
 	});
-	const existing = await store.findSourceByFilePath(filePath);
-	if (existing !== void 0) {
-		onProgress?.({
-			stage: "error",
-			message: `文件已摄入：${existing.name}（source id=${existing.id}）`
-		});
-		throw new Error(`文件已摄入过: ${filePath} (source ${existing.id})`);
-	}
+	await ensureEmbeddingModelMatches(store, engine);
 	onProgress?.({
 		stage: "chunking",
 		message: `读取并切分文件: ${basename(filePath)}`
 	});
 	const content = await readFileContent(filePath);
-	const sections = chunkContent(content, getFileExtension(filePath));
-	if (sections.length === 0) {
+	const contentHash = createHash("sha256").update(content).digest("hex");
+	const existing = await store.findSourceByFilePath(filePath);
+	let replacedOldVersion = false;
+	if (existing !== void 0) {
+		if (existing.contentHash === contentHash || existing.contentHash === null) {
+			if (existing.contentHash === null) await store.updateSourceContentHash(existing.id, contentHash);
+			onProgress?.({
+				stage: "completed",
+				message: "内容未变化，已跳过"
+			});
+			return {
+				documentId: null,
+				chunkCount: 0,
+				eventCount: 0,
+				entityCount: 0,
+				outcome: "unchanged"
+			};
+		}
 		onProgress?.({
-			stage: "error",
-			message: "文件无有效内容"
+			stage: "chunking",
+			message: `检测到内容变更，替换旧版本: ${existing.name}`
 		});
-		throw new Error("文件无有效内容可摄入");
+		await store.deleteSource(existing.id);
+		replacedOldVersion = true;
 	}
+	const sections = chunkContent(content, getFileExtension(filePath));
 	store.beginTransaction();
 	try {
+		if (sections.length === 0) {
+			onProgress?.({
+				stage: "error",
+				message: "文件无有效内容"
+			});
+			throw new Error("文件无有效内容可摄入");
+		}
 		const fileName = basename(filePath);
 		const source = await store.createSource({
 			name: fileName,
 			filePath,
-			description: null
+			description: null,
+			contentHash
 		});
 		const document = await store.createDocument({
 			sourceId: source.id,
@@ -1687,10 +1840,15 @@ async function ingestFile(store, llm, filePath, onProgress) {
 			documentId: document.id,
 			chunkCount: chunks.length,
 			eventCount: events.length,
-			entityCount: uniqueEntities.length
+			entityCount: uniqueEntities.length,
+			outcome: replacedOldVersion ? "updated" : "created"
 		};
 	} catch (error) {
 		store.rollbackTransaction();
+		if (replacedOldVersion) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`旧版本已删除、新版本摄入失败，请重新摄入该文件: ${filePath}（${message}）`);
+		}
 		throw error;
 	}
 }
@@ -1709,6 +1867,9 @@ async function ingestDirectory(store, llm, dirPath, onProgress) {
 	if (files.length === 0) throw new Error(`目录下没有支持的文件 (.md, .markdown, .txt): ${dirPath}`);
 	const errors = [];
 	let succeeded = 0;
+	let created = 0;
+	let updated = 0;
+	let unchanged = 0;
 	let totalChunks = 0;
 	let totalEvents = 0;
 	let totalEntities = 0;
@@ -1724,6 +1885,9 @@ async function ingestDirectory(store, llm, dirPath, onProgress) {
 		try {
 			const result = await ingestFile(store, llm, filePath, fileProgress);
 			succeeded += 1;
+			if (result.outcome === "created") created += 1;
+			else if (result.outcome === "updated") updated += 1;
+			else unchanged += 1;
 			totalChunks += result.chunkCount;
 			totalEvents += result.eventCount;
 			totalEntities += result.entityCount;
@@ -1741,11 +1905,14 @@ async function ingestDirectory(store, llm, dirPath, onProgress) {
 	}
 	onProgress?.({
 		stage: "completed",
-		message: `批量摄入完成：${succeeded}/${files.length} 个文件成功，${totalChunks} chunks, ${totalEvents} events, ${totalEntities} entities`
+		message: `批量摄入完成：新增 ${created} · 更新 ${updated} · 未变化 ${unchanged} · 失败 ${errors.length}（${totalChunks} chunks, ${totalEvents} events, ${totalEntities} entities）`
 	});
 	return {
 		succeeded,
 		failed: errors.length,
+		created,
+		updated,
+		unchanged,
 		totalChunks,
 		totalEvents,
 		totalEntities,
@@ -1820,6 +1987,18 @@ async function multiSearchWithTrace(store, llm, query, options = {}) {
 			}
 		};
 	}
+	const recordedModel = await store.getMeta(EMBEDDING_MODEL_META_KEY);
+	if (recordedModel !== null && recordedModel !== engine.modelName) {
+		fallbackReason = `embedding model mismatch (library: ${recordedModel}, current: ${engine.modelName}); used FTS5 keyword fallback`;
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
 	const queryEmbeddings = await timed(onStep, "queryEmbedding", "把用户问题转成向量，用于召回相关事件和切片。", async () => engine.embedBatch([query]));
 	if (queryEmbeddings === null || queryEmbeddings.length === 0) {
 		fallbackReason = "query embedding returned null; used FTS5 fallback";

package/dist/{text-input-dialog-B0yHChBj.mjs → text-input-dialog-BUXAKycx.mjs}

@@ -302,6 +302,21 @@ const dictionaries = {
 		"knowledge.menu_title": "SAG知识库管理",
 		"knowledge.menu_hint": "选择操作（esc 退出）",
 		"knowledge.op_failed": "操作失败: {msg}",
+		"knowledge.loading_model": "加载向量模型中...",
+		"knowledge.model_missing": "尚未下载向量模型，请先在 /knowledge 菜单选择「下载向量模型」",
+		"knowledge.model_load_failed": "向量模型加载失败，本次未摄入任何内容",
+		"knowledge.vector_coverage": "向量嵌入: {embedded}/{total} chunks",
+		"knowledge.reembed": "重新嵌入",
+		"knowledge.reembed_desc": "对指定文档重算全部向量（不重新抽取，不消耗 LLM）",
+		"knowledge.reembed_pick": "选择要重新嵌入的知识",
+		"knowledge.reembed_confirm_name": "重新嵌入「{name}」？",
+		"knowledge.reembed_confirm_desc": "将重算该文档所有 chunks/events/entities 向量",
+		"knowledge.reembed_done": "重新嵌入完成",
+		"knowledge.reembed_summary": "chunks: {chunks}, events: {events}, entities: {entities}, relations: {relations}",
+		"knowledge.reembed_none": "知识库为空，无可重新嵌入的内容",
+		"knowledge.ingest_unchanged": "内容未变化，已跳过",
+		"knowledge.ingest_updated": "已替换旧版本，重新摄入完成",
+		"knowledge.sync_counts": "新增 {created} · 更新 {updated} · 未变化 {unchanged}",
 		"init.select_title": "选择 AGENTS.md 生成位置",
 		"init.select_hint": "当前目录：{currentDir} · 项目根目录：{projectRoot}",
 		"init.current_dir": "当前目录",
@@ -1018,12 +1033,6 @@ const dictionaries = {
 		"prompts.wire_openai_responses_desc": "OpenAI Responses API（推理模型）",
 		"prompts.wire_anthropic": "Anthropic 协议",
 		"prompts.wire_anthropic_desc": "Messages API 兼容的服务商",
-		"prompts.thinking_off": "关闭思考",
-		"prompts.thinking_low": "低强度思考",
-		"prompts.thinking_medium": "中强度思考",
-		"prompts.thinking_high": "高强度思考",
-		"prompts.thinking_xhigh": "超高强度思考",
-		"prompts.thinking_max": "最大强度思考",
 		"prompts.image_off": "关闭识图",
 		"prompts.image_off_desc": "模型不支持图片输入时请选择此项",
 		"prompts.image_on": "开启识图",
@@ -1199,7 +1208,11 @@ const dictionaries = {
 		"kw.embedding_ready": "向量模型已就绪",
 		"kw.embedding_not_downloaded": "向量模型未下载（选择「下载向量模型」手动下载）",
 		"kw.embedding_data_intact": " —— 你的知识数据仍然存在，下载模型后即可正常使用",
-		"kw.embedding_already_installed": "向量模型已安装，无需重新下载"
+		"kw.embedding_already_installed": "向量模型已安装，无需重新下载",
+		"kw.setup_description": "检测到向量模型尚未下载。下载后 /knowledge 知识库与 /memory 记忆将启用语义检索（模型约 95 MB，只需下载一次）。",
+		"kw.setup_download": "立即下载",
+		"kw.setup_skip": "暂不下载",
+		"kw.setup_hint": "↑↓ 选择 · Enter 确认 · Esc 跳过"
 	},
 	en: {
 		"status.not_set": "Not set",
@@ -1404,6 +1417,21 @@ const dictionaries = {
 		"knowledge.menu_title": "SAG Knowledge Base",
 		"knowledge.menu_hint": "Select an action (Esc to exit)",
 		"knowledge.op_failed": "Operation failed: {msg}",
+		"knowledge.loading_model": "Loading vector model...",
+		"knowledge.model_missing": "Vector model not downloaded yet. Select \"Download vector model\" in the /knowledge menu first.",
+		"knowledge.model_load_failed": "Vector model failed to load. Nothing was ingested.",
+		"knowledge.vector_coverage": "Vectors: {embedded}/{total} chunks embedded",
+		"knowledge.reembed": "Re-embed",
+		"knowledge.reembed_desc": "Recompute all vectors for one document (no re-extraction, no LLM cost)",
+		"knowledge.reembed_pick": "Pick knowledge to re-embed",
+		"knowledge.reembed_confirm_name": "Re-embed \"{name}\"?",
+		"knowledge.reembed_confirm_desc": "All chunk/event/entity vectors of this document will be recomputed",
+		"knowledge.reembed_done": "Re-embed completed",
+		"knowledge.reembed_summary": "chunks: {chunks}, events: {events}, entities: {entities}, relations: {relations}",
+		"knowledge.reembed_none": "Knowledge base is empty; nothing to re-embed",
+		"knowledge.ingest_unchanged": "Content unchanged, skipped",
+		"knowledge.ingest_updated": "Previous version replaced; re-ingestion completed",
+		"knowledge.sync_counts": "new: {created} · updated: {updated} · unchanged: {unchanged}",
 		"init.select_title": "Select AGENTS.md location",
 		"init.select_hint": "Current: {currentDir} · Project root: {projectRoot}",
 		"init.current_dir": "Current directory",
@@ -2120,12 +2148,6 @@ const dictionaries = {
 		"prompts.wire_openai_responses_desc": "OpenAI Responses API (reasoning models)",
 		"prompts.wire_anthropic": "Anthropic protocol",
 		"prompts.wire_anthropic_desc": "Messages API compatible providers",
-		"prompts.thinking_off": "Thinking off",
-		"prompts.thinking_low": "Low thinking",
-		"prompts.thinking_medium": "Medium thinking",
-		"prompts.thinking_high": "High thinking",
-		"prompts.thinking_xhigh": "Extra-high thinking",
-		"prompts.thinking_max": "Max thinking",
 		"prompts.image_off": "Image off",
 		"prompts.image_off_desc": "Select this when the model does not support image input",
 		"prompts.image_on": "Image on",
@@ -2301,7 +2323,11 @@ const dictionaries = {
 		"kw.embedding_ready": "Vector model ready",
 		"kw.embedding_not_downloaded": "Vector model not downloaded (select Download vector model)",
 		"kw.embedding_data_intact": " — your knowledge data is still there; download the model to use it again",
-		"kw.embedding_already_installed": "Vector model already installed, no need to re-download"
+		"kw.embedding_already_installed": "Vector model already installed, no need to re-download",
+		"kw.setup_description": "The vector model is not downloaded yet. Once downloaded, /knowledge and /memory gain semantic retrieval (about 95 MB, one-time download).",
+		"kw.setup_download": "Download now",
+		"kw.setup_skip": "Not now",
+		"kw.setup_hint": "↑↓ select · Enter confirm · Esc skip"
 	}
 };
 function detectSystemLocale() {

package/dist/{text-input-dialog-B9uwX1Uy.mjs → text-input-dialog-Dr42qLMU.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { t as TextInputDialogComponent } from "./text-input-dialog-B0yHChBj.mjs";
+import { t as TextInputDialogComponent } from "./text-input-dialog-BUXAKycx.mjs";
 export { TextInputDialogComponent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scream-code",
-  "version": "0.14.8",
+  "version": "0.14.9",
   "description": "A terminal-native AI agent for builders",
   "license": "MIT",
   "author": "ScreamCli",