zigmini 0.9.0-beta.3 → 1.0.0-beta.1

package/src/update/handoff-system.ts

@@ -7,21 +7,28 @@ import { createSnapshot, pruneSnapshots } from "../runtime/generations.ts";
 import { activeRecord, readRegistry, type SlotRecord, type SlotRegistry, slotUrl, writeRegistry } from "../runtime/slots.ts";
 import { probe } from "./cli.ts";
 import { type BridgeGeneration, type HandoffDeps, type OverlapControl, runHandoff } from "./handoff.ts";
-import { installedVersion } from "./helper.ts";
+import { followHomeLanguage, installedVersion } from "./helper.ts";
+import { say, type Text } from "../server-text.ts";
 import { initialOverlap, observe, type OverlapState } from "../runtime/overlap-policy.ts";
 import { sampleResources } from "../runtime/resource-sample.ts";
 import { agentDir } from "../model-accounts.ts";
 import { attemptRefusal, readGuardState, readStoreSchema, storeIncompatibility } from "../engine/schema-guard.ts";
 import { supportedSchema } from "../engine/thread-schema.ts";
 
-const OVERLAP_REASONS: Readonly<Record<string, string>> = {
-	critical_pressure: "메모리 압박 단계가 위험입니다",
-	insufficient_available_memory: "쓸 수 있는 메모리가 2GiB보다 적습니다",
-	sufficient_resources: "자원 충분: 최대 6시간",
-	limited_resources: "자원 부족: 최대 1시간",
-	resource_limits: "메모리 압박·두 세대 메모리 합·스왑 증가 기준을 3번 연속 넘었습니다",
+const OVERLAP_REASONS: Readonly<Record<string, Text>> = {
+	critical_pressure: { en: "The memory pressure level is critical", ko: "메모리 압박 단계가 위험입니다" },
+	insufficient_available_memory: { en: "Less than 2 GiB of memory is available", ko: "쓸 수 있는 메모리가 2GiB보다 적습니다" },
+	sufficient_resources: { en: "Enough resources: up to 6 hours", ko: "자원 충분: 최대 6시간" },
+	limited_resources: { en: "Limited resources: up to 1 hour", ko: "자원 부족: 최대 1시간" },
+	resource_limits: { en: "The limits for memory pressure, combined memory of both generations, and swap growth were exceeded 3 times in a row", ko: "메모리 압박·두 세대 메모리 합·스왑 증가 기준을 3번 연속 넘었습니다" },
 };
 
+const NOT_CONNECTED: Text = { en: "Could not connect to slot {slot}", ko: "슬롯 {slot}에 연결하지 못했습니다" };
+const NO_TEMP_SESSION: Text = { en: "Could not open a temporary session", ko: "임시 세션을 열지 못했습니다" };
+const STORE_AHEAD: Text = { en: "Store schema {store} > engine support {supported}", ko: "저장소 스키마 {store} > 엔진 지원 {supported}" };
+const LAUNCHCTL_CODE: Text = { en: "launchctl exit code {code}", ko: "launchctl 종료 코드 {code}" };
+const NO_GATEWAY_ANSWER: Text = { en: "No gateway response", ko: "게이트웨이 응답 없음" };
+
 /** Plan 5.9 with live macOS samples: the old generation's bridge tree is "active", the new one "new". */
 export function resourceOverlap(pids: () => Promise<{ readonly old: number | null; readonly fresh: number | null }>, log: (line: string) => void): OverlapControl {
 	let state: OverlapState | null = null;
@@ -34,15 +41,15 @@ export function resourceOverlap(pids: () => Promise<{ readonly old: number | nul
 	return {
 		async start(now) {
 			const initial = initialOverlap(await sample(), now);
-			if (!initial.allowed) return { refuse: OVERLAP_REASONS[initial.reason]! };
+			if (!initial.allowed) return { refuse: say(OVERLAP_REASONS[initial.reason]!) };
 			state = initial.state;
-			return { deadline: state.deadline, reason: OVERLAP_REASONS[initial.reason]! };
+			return { deadline: state.deadline, reason: say(OVERLAP_REASONS[initial.reason]!) };
 		},
 		async check(now) {
 			if (state === null) throw new Error("overlap_not_started");
 			const next = observe(state, await sample(), now);
 			state = next.state;
-			return { deadline: state.deadline, reason: next.reason === null ? null : OVERLAP_REASONS[next.reason]! };
+			return { deadline: state.deadline, reason: next.reason === null ? null : say(OVERLAP_REASONS[next.reason]!) };
 		},
 	};
 }
@@ -74,9 +81,9 @@ export async function generationHealth(record: SlotRecord, token: string, sessio
 	const timer = setTimeout(() => resolveStatus("disconnected"), timeoutMs);
 	client.start();
 	try {
-		if (await readyOrFailed !== "ready") return `슬롯 ${record.slot}에 연결하지 못했습니다`;
+		if (await readyOrFailed !== "ready") return say(NOT_CONNECTED, { slot: record.slot });
 		const opened = await client.command<{ sessionId?: unknown }>("open_session", { sessionPath, cwd, retain_on_disconnect: false, auto_title: false });
-		if (typeof opened?.sessionId !== "string") return "임시 세션을 열지 못했습니다";
+		if (typeof opened?.sessionId !== "string") return say(NO_TEMP_SESSION);
 		await client.command("close_session", { sessionId: opened.sessionId });
 		return null;
 	} catch (error) {
@@ -129,7 +136,7 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 				return null;
 			}
 			const found = storeIncompatibility(readStoreSchema(agentDir({ ...ctx.env, ...config })), supported);
-			return found === null ? null : `저장소 스키마 ${found.store} > 엔진 지원 ${found.supported}`;
+			return found === null ? null : say(STORE_AHEAD, { store: found.store, supported: found.supported });
 		},
 		startRefusal: (record) => attemptRefusal(readGuardState(paths.run), { slot: record.slot, engine: record.engine, since: record.since }),
 		startBridge: async (record) => {
@@ -145,7 +152,7 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 			if (agentState(launchd, ctx, spec.label).loaded) launchd.launchctl(["bootout", `${domain}/${spec.label}`]);
 			launchd.writeText(path, plistXml(spec));
 			const booted = await bootstrap(launchd, ctx, path);
-			return booted.code === 0 ? null : booted.stderr.trim() || `launchctl 종료 코드 ${booted.code}`;
+			return booted.code === 0 ? null : booted.stderr.trim() || say(LAUNCHCTL_CODE, { code: booted.code });
 		},
 		stopBridge: async (slot) => {
 			const label = slotLabel(paths.launchdPrefix, slot);
@@ -156,7 +163,7 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 		healthCheck: (record) => generationHealth(record, token, paths.sessions, ctx.userHome),
 		restartGateway: async () => {
 			const kicked = launchd.launchctl(["kickstart", "-k", `${domain}/${agentLabel(paths.launchdPrefix, "gateway")}`]);
-			return kicked.code === 0 ? null : kicked.stderr.trim() || `launchctl 종료 코드 ${kicked.code}`;
+			return kicked.code === 0 ? null : kicked.stderr.trim() || say(LAUNCHCTL_CODE, { code: kicked.code });
 		},
 		gatewayReady: async () => {
 			const answer = await probe(paths.ports.web);
@@ -164,7 +171,7 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 		},
 		reload: async () => {
 			const answer = await postJson(`${web}/internal/runtime`, token, { action: "reload" });
-			return answer?.status === 200 ? null : String(answer?.body.error ?? (answer === null ? "게이트웨이 응답 없음" : `HTTP ${answer.status}`));
+			return answer?.status === 200 ? null : String(answer?.body.error ?? (answer === null ? say(NO_GATEWAY_ANSWER) : `HTTP ${answer.status}`));
 		},
 		overlap: options.overlap,
 		cleanup: async (keepSnapshots, keepEngines) => {
@@ -185,6 +192,7 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 
 /** `zigmini _update-handoff <request id>`: stdout gets only the PROMOTED / FAILED line; the log goes to stderr (updater.log). */
 export async function handoffCommand(launchd: LaunchdDeps, ctx: LaunchdContext, argv: readonly string[]): Promise<number> {
+	followHomeLanguage(ctx.paths.home);
 	const log = (line: string) => process.stderr.write(`${new Date().toISOString()} handoff ${argv[0] ?? ""} ${line}\n`);
 	const out = (line: string) => process.stdout.write(`${line}\n`);
 	const legacy: SlotRecord = { slot: "a", state: "active", port: ctx.paths.ports.bridge, version: "unknown", snapshot: null, engine: null, since: "" };

package/src/update/handoff.ts

@@ -1,5 +1,6 @@
 import type { RuntimeSlot } from "../runtime/paths.ts";
 import { activeRecord, otherSlot, type SlotRecord, type SlotRegistry } from "../runtime/slots.ts";
+import { say, type Text } from "../server-text.ts";
 import { HANDOFF_FAILED, HANDOFF_PROMOTED } from "./strategy.ts";
 
 /**
@@ -63,7 +64,17 @@ export const POLL_MS = 1000;
 
 export type HandoffResult = "promoted" | "untouched_failure" | "failure";
 
-const NOT_UP = `${BRIDGE_START_WAIT_MS / 1000}초 안에 엔진이 뜨지 않았습니다`;
+const NOT_UP: Text = { en: "The engine did not start within {seconds} seconds", ko: "{seconds}초 안에 엔진이 뜨지 않았습니다" };
+const STALE_GENERATION: Text = { en: "The previous update has not finished cleaning up its old generation yet", ko: "이전 업데이트의 이전 세대 정리가 아직 끝나지 않았습니다" };
+const NO_RESOURCES: Text = { en: "Not enough resources, so the new generation was not started: {reason}", ko: "자원이 부족해 새 세대를 띄우지 않았습니다: {reason}" };
+const PREFLIGHT_BLOCKED: Text = { en: "Did not start the new generation (slot {slot}, engine {engine}): {reason}", ko: "새 세대(슬롯 {slot}, 엔진 {engine})를 시작하지 않았습니다: {reason}" };
+const START_FAILED: Text = { en: "Could not start the new generation (slot {slot}): {reason}", ko: "새 세대(슬롯 {slot})를 시작하지 못했습니다: {reason}" };
+const CHECK_FAILED: Text = { en: "Check of the new generation (slot {slot}) failed: {reason}", ko: "새 세대(슬롯 {slot}) 확인 실패: {reason}" };
+const GATEWAY_NOT_READY: Text = { en: "The gateway was not ready on the new version{detail}", ko: "게이트웨이가 새 버전으로 준비되지 않았습니다{detail}" };
+const SWITCH_FAILED: Text = { en: "The gateway could not switch to the new generation: {reason}", ko: "게이트웨이가 새 세대로 바꾸지 못했습니다: {reason}" };
+const DEADLINE_MOVED: Text = { en: "The update wrap-up deadline was moved up to {deadline}: {reason}", ko: "업데이트 마무리 마감이 {deadline}로 당겨졌습니다: {reason}" };
+const WRAP_UP_FORCED: Text = { en: "Update {version} wrapped up: the old generation ended the sessions that were not finished by the deadline and exited.", ko: "업데이트 {version} 마무리: 이전 세대가 마감까지 끝나지 않은 세션을 정리하고 종료했습니다." };
+const WRAP_UP_CLEAN: Text = { en: "Update {version} wrapped up: all sessions moved to the new generation and the old generation exited.", ko: "업데이트 {version} 마무리: 모든 세션이 새 세대로 옮겨졌고 이전 세대를 종료했습니다." };
 
 function legacyRegistry(port: number, version: string, now: number): SlotRegistry {
 	return { schema: 1, slots: [{ slot: "a", state: "active", port, version, snapshot: null, engine: null, since: new Date(now).toISOString() }] };
@@ -97,14 +108,14 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 	const old = activeRecord(listed);
 	// A slot left draining or starting by an interrupted handoff (a reboot ends the helper) is removed once its OMO is gone.
 	for (const stale of listed.slots.filter((record) => record.state !== "active")) {
-		if ((await deps.generation(stale, "status"))?.omo === "running") return fail(true, "이전 업데이트의 이전 세대 정리가 아직 끝나지 않았습니다");
+		if ((await deps.generation(stale, "status"))?.omo === "running") return fail(true, say(STALE_GENERATION));
 		deps.log(`끝나지 않은 이전 전환의 슬롯 ${stale.slot}(${stale.state})을 정리합니다`);
 		await deps.stopBridge(stale.slot);
 		stored = { schema: 1, slots: [old] };
 		deps.writeRegistry(stored);
 	}
 	const start = await deps.overlap.start(deps.now());
-	if ("refuse" in start) return fail(true, `자원이 부족해 새 세대를 띄우지 않았습니다: ${start.refuse}`);
+	if ("refuse" in start) return fail(true, say(NO_RESOURCES, { reason: start.refuse }));
 	deps.log(`최대 겹침 마감 ${new Date(start.deadline).toISOString()} (${start.reason})`);
 
 	const slot = otherSlot(old.slot);
@@ -116,27 +127,27 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 		deps.writeRegistry(stored);
 	};
 	const blocked = deps.preflight(fresh);
-	if (blocked !== null) return fail(true, `새 세대(슬롯 ${slot}, 엔진 ${fresh.engine ?? "current"})를 시작하지 않았습니다: ${blocked}`);
+	if (blocked !== null) return fail(true, say(PREFLIGHT_BLOCKED, { slot, engine: fresh.engine ?? "current", reason: blocked }));
 	deps.writeRegistry({ schema: 1, slots: [old, fresh] });
 	const started = await deps.startBridge(fresh);
 	if (started !== null) {
 		await undo();
-		return fail(true, `새 세대(슬롯 ${slot})를 시작하지 못했습니다: ${started}`);
+		return fail(true, say(START_FAILED, { slot, reason: started }));
 	}
 	let refused: string | null = null;
 	const up = await until(deps, BRIDGE_START_WAIT_MS, async () => (refused = deps.startRefusal(fresh)) !== null ||
 		(await deps.generation(fresh, "status"))?.omo === "running");
-	const unhealthy = refused ?? (up ? await deps.healthCheck(fresh) : NOT_UP);
+	const unhealthy = refused ?? (up ? await deps.healthCheck(fresh) : say(NOT_UP, { seconds: BRIDGE_START_WAIT_MS / 1000 }));
 	if (unhealthy !== null) {
 		await undo();
-		return fail(true, `새 세대(슬롯 ${slot}) 확인 실패: ${unhealthy}`);
+		return fail(true, say(CHECK_FAILED, { slot, reason: unhealthy }));
 	}
 	deps.log(`새 세대 슬롯 ${slot} 준비됨 (${snap.name}, 엔진 ${fresh.engine ?? "current"})`);
 
 	const restarted = await deps.restartGateway();
 	if (restarted !== null || !await until(deps, GATEWAY_WAIT_MS, deps.gatewayReady)) {
 		await undo();
-		return fail(false, `게이트웨이가 새 버전으로 준비되지 않았습니다${restarted === null ? "" : `: ${restarted}`}`);
+		return fail(false, say(GATEWAY_NOT_READY, { detail: restarted === null ? "" : `: ${restarted}` }));
 	}
 	const draining: SlotRecord = { ...old, state: "draining" };
 	const active: SlotRecord = { ...fresh, state: "active" };
@@ -147,7 +158,7 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 		deps.writeRegistry({ schema: 1, slots: [old, fresh] });
 		await deps.reload();
 		await undo();
-		return fail(false, `게이트웨이가 새 세대로 바꾸지 못했습니다: ${reloadError}`);
+		return fail(false, say(SWITCH_FAILED, { reason: reloadError }));
 	}
 	deps.log(`승격: 슬롯 ${slot}이 활성, 슬롯 ${old.slot}은 배수`);
 	deps.signal(HANDOFF_PROMOTED);
@@ -159,7 +170,7 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 		if ((await deps.generation(draining, "status"))?.omo === "exited") break;
 		const now = deps.now();
 		const overlap = await deps.overlap.check(now);
-		if (overlap.reason !== null) await deps.notify(`업데이트 마무리 마감이 ${new Date(overlap.deadline).toISOString()}로 당겨졌습니다: ${overlap.reason}`);
+		if (overlap.reason !== null) await deps.notify(say(DEADLINE_MOVED, { deadline: new Date(overlap.deadline).toISOString(), reason: overlap.reason }));
 		if (now >= overlap.deadline) {
 			terminated = true;
 			deps.log(`최대 겹침 마감이 지나 슬롯 ${old.slot}을 끝냅니다`);
@@ -175,8 +186,8 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 	const keep = new Set([snap.name, snapshotName(old.snapshot)].filter((name): name is string => name !== null));
 	await deps.cleanup(keep, new Set([fresh.engine].filter((name): name is string => name !== null)));
 	await deps.notify(terminated
-		? `업데이트 ${deps.version} 마무리: 이전 세대가 마감까지 끝나지 않은 세션을 정리하고 종료했습니다.`
-		: `업데이트 ${deps.version} 마무리: 모든 세션이 새 세대로 옮겨졌고 이전 세대를 종료했습니다.`);
+		? say(WRAP_UP_FORCED, { version: deps.version })
+		: say(WRAP_UP_CLEAN, { version: deps.version }));
 	deps.log("끝");
 	return "promoted";
 }

package/src/update/helper.ts

@@ -2,6 +2,8 @@ import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, read
 import { join } from "node:path";
 import { PREV_FILE, promotePending, restorePrev } from "../consent/consent.ts";
 import { type Phase, PREV_ENGINE_FILE, type UpdateRequest, type UpdateResult, updateDir, writeState } from "./state.ts";
+import { say, setServerLanguage, textIn, type Text } from "../server-text.ts";
+import { readUiLanguage } from "../ui-language.ts";
 import type { RestartTarget, UntouchedFailure, UpdateStrategy } from "./strategy.ts";
 
 /**
@@ -16,8 +18,40 @@ import type { RestartTarget, UntouchedFailure, UpdateStrategy } from "./strategy
 /** The same 600 s as `zigmini start` (bug 104): reconnect recovery can keep a correct new version from being ready for minutes. */
 export const READY_WAIT_MS = 600_000;
 export const STOP_WAIT_MS = 15_000;
-export const LOST_RECORDS = "업데이트 전 백업 뒤에 생긴 기록(대화 등)은 없어졌을 수 있습니다.";
-export const UPDATE_AGAIN = "옛 엔진이 공유 폴더 스키마를 읽지 못해 브리지가 멈췄습니다. 다시 업데이트하세요(새 엔진 필요).";
+export const LOST_RECORDS: Text = { en: "Records made after the pre-update backup (conversations and so on) may be lost.", ko: "업데이트 전 백업 뒤에 생긴 기록(대화 등)은 없어졌을 수 있습니다." };
+export const UPDATE_AGAIN: Text = { en: "The old engine could not read the shared folder schema, so the bridge stopped. Update again (a new engine is required).", ko: "옛 엔진이 공유 폴더 스키마를 읽지 못해 브리지가 멈췄습니다. 다시 업데이트하세요(새 엔진 필요)." };
+
+const INSTALL_NEW: Text = { en: "Installing the new version", ko: "새 버전 설치" };
+const INSTALL_ENGINE: Text = { en: "Installing the new engine", ko: "새 엔진 설치" };
+const INSTALL_PREV: Text = { en: "Reinstalling the previous version", ko: "이전 버전 설치" };
+const STEP_FAILED: Text = { en: "{what} failed: {detail}", ko: "{what} 실패: {detail}" };
+const SAVE_FAILED: Text = { en: "Saving the current version failed: {detail}", ko: "지금 버전 저장 실패: {detail}" };
+const NOT_STARTED: Text = { en: "Could not start the update (nothing changed): {error}", ko: "업데이트를 시작하지 못했습니다(바뀐 것 없음): {error}" };
+const WRONG_VERSION: Text = { en: "The installed version is {installed} (expected {expected})", ko: "설치된 버전이 {installed}입니다(기대 {expected})" };
+const UNKNOWN: Text = { en: "unknown", ko: "알 수 없음" };
+const NO_CONSENT: Text = { en: "There is no consent record for the new permission notice", ko: "새 권한 안내에 대한 동의 기록이 없습니다" };
+const NOT_READY: Text = { en: "The new version was not ready within {seconds} seconds (health {detail})", ko: "새 버전이 {seconds}초 안에 준비되지 않았습니다(health {detail})" };
+const NO_ANSWER: Text = { en: "no response", ko: "응답 없음" };
+const HEALTH_DETAIL: Text = { en: "omo={omo}, version {version}", ko: "omo={omo}, 버전 {version}" };
+const UPDATED: Text = { en: "Updated to {to}", ko: "{to}으로 업데이트했습니다" };
+const UPDATE_FAILED: Text = { en: "Update failed: {failure}.", ko: "업데이트에 실패했습니다: {failure}." };
+const NOT_RESTARTED: Text = { en: "The running gateway and bridge were not restarted, and the installation was rolled back to {from}.", ko: "실행 중인 게이트웨이와 브리지는 다시 시작하지 않았고, 설치를 {from}으로 되돌렸습니다." };
+const ROLLED_BACK: Text = { en: "Rolled back to {from}. {lost}", ko: "{from}으로 되돌렸습니다. {lost}" };
+const ROLLBACK_PARTLY_FAILED: Text = { en: "Rollback also partly failed: {problems}. Check the log and run `zigmini doctor`.", ko: "되돌리기도 일부 실패했습니다: {problems}. 로그를 확인하고 `zigmini doctor`를 실행하세요." };
+const OLD_WEB_DOWN: Text = { en: "The web of the previous version {from} does not respond", ko: "이전 버전 {from}의 웹이 응답하지 않습니다" };
+const STEP_STOP: Text = { en: "Stop", ko: "정지" };
+const STEP_RESTORE_DB: Text = { en: "Restore the DB", ko: "DB 복원" };
+const STEP_RESTORE_LINK: Text = { en: "Restore the engine link", ko: "엔진 링크 복원" };
+const STEP_RESTORE_CONSENT: Text = { en: "Restore the consent", ko: "동의 복원" };
+const STEP_START: Text = { en: "Start", ko: "시작" };
+
+/**
+ * The helper and the handoff command are separate processes from the gateway, so their texts follow the language saved
+ * in the install home: the file is read each time a text is made, like the gateway's own source.
+ */
+export function followHomeLanguage(home: string): void {
+	setServerLanguage(() => readUiLanguage(home));
+}
 
 /** The installer's refusal code (src/engine/install.ts ENGINE_SCHEMA_INCOMPATIBLE) as printed by `setup --engine-only`. */
 export const ENGINE_SCHEMA_REFUSAL = "engine_schema_incompatible";
@@ -98,6 +132,7 @@ export async function waitFor(deps: HelperDeps, ok: (probe: Probe | null) => boo
 }
 
 export async function runHelper(request: UpdateRequest, deps: HelperDeps): Promise<UpdateResult> {
+	followHomeLanguage(deps.home);
 	const dir = updateDir(deps.home);
 	mkdirSync(dir, { recursive: true });
 	const logPath = join(dir, `update-${request.id}.log`);
@@ -107,10 +142,10 @@ export async function runHelper(request: UpdateRequest, deps: HelperDeps): Promi
 		writeState(deps.home, { id: request.id, from: request.from, to: request.to, phase: name, at: new Date(deps.now()).toISOString(), result: null });
 	};
 	const env = { BUN_INSTALL: deps.bunInstall };
-	const bun = async (args: readonly string[], what: string) => {
+	const bun = async (args: readonly string[], what: Text) => {
 		const out = await deps.run([deps.bunPath, ...args], dir, env);
 		log(`$ bun ${args.join(" ")} -> ${out.code}`);
-		if (out.code !== 0) throw new StepError(`${what} 실패: ${tail(out.stderr || out.stdout)}`);
+		if (out.code !== 0) throw new StepError(say(STEP_FAILED, { what: say(what), detail: tail(out.stderr || out.stdout) }));
 	};
 	const prevTgz = join(dir, `prev-${request.from}.tgz`);
 	const finish = (result: Omit<UpdateResult, "from" | "to" | "logPath" | "finishedAt">): UpdateResult => {
@@ -127,27 +162,27 @@ export async function runHelper(request: UpdateRequest, deps: HelperDeps): Promi
 		await deps.run([deps.bunPath, "pm", "pack", "--filename", prevTgz, "--ignore-scripts", "--quiet"], deps.packageRoot, env)
 			.then((out) => {
 				log(`$ bun pm pack -> ${out.code}`);
-				if (out.code !== 0 || !existsSync(prevTgz)) throw new StepError(`지금 버전 저장 실패: ${tail(out.stderr || out.stdout)}`);
+				if (out.code !== 0 || !existsSync(prevTgz)) throw new StepError(say(SAVE_FAILED, { detail: tail(out.stderr || out.stdout) }));
 			});
 		writeFileSync(join(dir, PREV_ENGINE_FILE), `${engineLink(deps.omoCurrent) ?? ""}\n`);
 	} catch (error) {
-		return finish({ ok: false, rolledBack: false, omo: null, message: `업데이트를 시작하지 못했습니다(바뀐 것 없음): ${(error as Error).message}` });
+		return finish({ ok: false, rolledBack: false, omo: null, message: say(NOT_STARTED, { error: (error as Error).message }) });
 	}
 
 	let failure: string | null = null;
 	try {
 		phase("install");
-		await bun(["add", "-g", request.source, ...(deps.registry === null ? [] : ["--registry", deps.registry])], "새 버전 설치");
+		await bun(["add", "-g", request.source, ...(deps.registry === null ? [] : ["--registry", deps.registry])], INSTALL_NEW);
 		const installed = installedVersion(deps.packageRoot);
-		if (installed !== request.to) throw new StepError(`설치된 버전이 ${installed ?? "알 수 없음"}입니다(기대 ${request.to})`);
+		if (installed !== request.to) throw new StepError(say(WRONG_VERSION, { installed: installed ?? say(UNKNOWN), expected: request.to }));
 		if (request.noticeChanged) {
 			phase("consent");
-			if (!promotePending(deps.home)) throw new StepError("새 권한 안내에 대한 동의 기록이 없습니다");
+			if (!promotePending(deps.home)) throw new StepError(say(NO_CONSENT));
 		}
 		if (request.engineChanged) {
 			phase("engine");
 			try {
-				await bun([join(deps.packageRoot, "src/cli/main.ts"), "setup", "--non-interactive", "--engine-only"], "새 엔진 설치");
+				await bun([join(deps.packageRoot, "src/cli/main.ts"), "setup", "--non-interactive", "--engine-only"], INSTALL_ENGINE);
 			} catch (error) {
 				// Findings 214-217: the installer refused before selecting the engine and nothing running was restarted.
 				if (!(error instanceof StepError) || !error.message.includes(ENGINE_SCHEMA_REFUSAL)) throw error;
@@ -165,10 +200,11 @@ export async function runHelper(request: UpdateRequest, deps: HelperDeps): Promi
 		phase("health");
 		const probe = await waitFor(deps, (p) => p?.omo === "ready" && p.version === request.to, deps.readyWaitMs ?? READY_WAIT_MS);
 		if (probe?.omo !== "ready" || probe.version !== request.to) {
-			throw new StepError(`새 버전이 ${(deps.readyWaitMs ?? READY_WAIT_MS) / 1000}초 안에 준비되지 않았습니다(health ${probe === null ? "응답 없음" : `omo=${probe.omo}, 버전 ${probe.version}`})`);
+			throw new StepError(say(NOT_READY, { seconds: (deps.readyWaitMs ?? READY_WAIT_MS) / 1000,
+				detail: probe === null ? say(NO_ANSWER) : say(HEALTH_DETAIL, { omo: String(probe.omo), version: String(probe.version) }) }));
 		}
 		rmSync(join(deps.home, PREV_FILE), { force: true });
-		const done = finish({ ok: true, rolledBack: false, omo: probe.omo, message: `${request.to}으로 업데이트했습니다` });
+		const done = finish({ ok: true, rolledBack: false, omo: probe.omo, message: say(UPDATED, { to: request.to }) });
 		await deps.strategy.settle?.().catch((error: unknown) => log(`업데이트 뒤 정리 실패: ${error instanceof Error ? error.message : String(error)}`));
 		return done;
 	} catch (error) {
@@ -184,29 +220,29 @@ async function untouchedRollback(request: UpdateRequest, deps: HelperDeps, ctx:
 	readonly prevTgz: string;
 	readonly log: (line: string) => void;
 	readonly phase: (name: Phase) => void;
-	readonly bun: (args: readonly string[], what: string) => Promise<void>;
+	readonly bun: (args: readonly string[], what: Text) => Promise<void>;
 	readonly finish: (result: Omit<UpdateResult, "from" | "to" | "logPath" | "finishedAt">) => UpdateResult;
 }): Promise<UpdateResult> {
 	ctx.phase("rollback");
 	const problems: string[] = [];
-	const attempt = async (what: string, step: () => unknown) => {
+	const attempt = async (what: Text, step: () => unknown) => {
 		try {
 			await step();
 		} catch (error) {
-			problems.push(`${what}: ${error instanceof Error ? error.message : String(error)}`);
-			ctx.log(`되돌리기 ${what} 실패: ${problems.at(-1)}`);
+			problems.push(`${say(what)}: ${error instanceof Error ? error.message : String(error)}`);
+			ctx.log(`되돌리기 ${textIn("ko", what)} 실패: ${problems.at(-1)}`);
 		}
 	};
-	await attempt("이전 버전 설치", () => ctx.bun(["add", "-g", ctx.prevTgz], "이전 버전 설치"));
-	await attempt("엔진 링크 복원", () => {
+	await attempt(INSTALL_PREV, () => ctx.bun(["add", "-g", ctx.prevTgz], INSTALL_PREV));
+	await attempt(STEP_RESTORE_LINK, () => {
 		const prev = readFileSync(join(updateDir(deps.home), PREV_ENGINE_FILE), "utf8").trim();
 		if (prev !== "" && engineLink(deps.omoCurrent) !== prev) setEngineLink(deps.omoCurrent, prev);
 	});
-	await attempt("동의 복원", () => restorePrev(deps.home));
+	await attempt(STEP_RESTORE_CONSENT, () => restorePrev(deps.home));
 	const probe = await deps.probe();
-	const message = [`업데이트에 실패했습니다: ${ctx.failure.message}.`,
-		problems.length === 0 ? `실행 중인 게이트웨이와 브리지는 다시 시작하지 않았고, 설치를 ${request.from}으로 되돌렸습니다.`
-			: `되돌리기도 일부 실패했습니다: ${problems.join("; ")}. 로그를 확인하고 \`zigmini doctor\`를 실행하세요.`].join(" ");
+	const message = [say(UPDATE_FAILED, { failure: ctx.failure.message }),
+		problems.length === 0 ? say(NOT_RESTARTED, { from: request.from })
+			: say(ROLLBACK_PARTLY_FAILED, { problems: problems.join("; ") })].join(" ");
 	return ctx.finish({ ok: false, rolledBack: problems.length === 0, omo: probe?.omo ?? null, message });
 }
 
@@ -215,32 +251,32 @@ async function rollback(request: UpdateRequest, deps: HelperDeps, ctx: {
 	readonly prevTgz: string;
 	readonly log: (line: string) => void;
 	readonly phase: (name: Phase) => void;
-	readonly bun: (args: readonly string[], what: string) => Promise<void>;
+	readonly bun: (args: readonly string[], what: Text) => Promise<void>;
 	readonly finish: (result: Omit<UpdateResult, "from" | "to" | "logPath" | "finishedAt">) => UpdateResult;
 }): Promise<UpdateResult> {
 	ctx.phase("rollback");
 	const problems: string[] = [];
-	const attempt = async (what: string, step: () => unknown) => {
+	const attempt = async (what: Text, step: () => unknown) => {
 		try {
 			await step();
 		} catch (error) {
-			problems.push(`${what}: ${error instanceof Error ? error.message : String(error)}`);
-			ctx.log(`되돌리기 ${what} 실패: ${problems.at(-1)}`);
+			problems.push(`${say(what)}: ${error instanceof Error ? error.message : String(error)}`);
+			ctx.log(`되돌리기 ${textIn("ko", what)} 실패: ${problems.at(-1)}`);
 		}
 	};
-	await attempt("정지", async () => {
+	await attempt(STEP_STOP, async () => {
 		await deps.stop("gateway");
 		await deps.stop("bridge");
 		await waitFor(deps, (probe) => probe === null, STOP_WAIT_MS);
 	});
-	await attempt("DB 복원", () => restoreDatabase(request.backup, deps.dataDir));
-	await attempt("이전 버전 설치", () => ctx.bun(["add", "-g", ctx.prevTgz], "이전 버전 설치"));
-	await attempt("엔진 링크 복원", () => {
+	await attempt(STEP_RESTORE_DB, () => restoreDatabase(request.backup, deps.dataDir));
+	await attempt(INSTALL_PREV, () => ctx.bun(["add", "-g", ctx.prevTgz], INSTALL_PREV));
+	await attempt(STEP_RESTORE_LINK, () => {
 		const prev = readFileSync(join(updateDir(deps.home), PREV_ENGINE_FILE), "utf8").trim();
 		if (prev !== "" && engineLink(deps.omoCurrent) !== prev) setEngineLink(deps.omoCurrent, prev);
 	});
-	await attempt("동의 복원", () => restorePrev(deps.home));
-	await attempt("시작", async () => {
+	await attempt(STEP_RESTORE_CONSENT, () => restorePrev(deps.home));
+	await attempt(STEP_START, async () => {
 		for (const target of ["bridge", "gateway"] as const) {
 			const error = await deps.start(target);
 			if (error !== null) throw new Error(`${target}: ${error}`);
@@ -249,10 +285,10 @@ async function rollback(request: UpdateRequest, deps: HelperDeps, ctx: {
 	const settled = (p: Probe | null) => p?.status === 200 && p.version === request.from && (p.omo === "ready" || p.omo === "schema_too_new");
 	const probe = await waitFor(deps, settled, deps.readyWaitMs ?? READY_WAIT_MS);
 	const back = probe?.status === 200 && probe.version === request.from;
-	if (!back) problems.push(`이전 버전 ${request.from}의 웹이 응답하지 않습니다`);
+	if (!back) problems.push(say(OLD_WEB_DOWN, { from: request.from }));
 	const omo = probe?.omo ?? null;
-	const message = [`업데이트에 실패했습니다: ${ctx.failure}.`,
-		problems.length === 0 ? `${request.from}으로 되돌렸습니다. ${LOST_RECORDS}` : `되돌리기도 일부 실패했습니다: ${problems.join("; ")}. 로그를 확인하고 \`zigmini doctor\`를 실행하세요.`,
-		...(omo === "schema_too_new" ? [UPDATE_AGAIN] : [])].join(" ");
+	const message = [say(UPDATE_FAILED, { failure: ctx.failure }),
+		problems.length === 0 ? say(ROLLED_BACK, { from: request.from, lost: say(LOST_RECORDS) }) : say(ROLLBACK_PARTLY_FAILED, { problems: problems.join("; ") }),
+		...(omo === "schema_too_new" ? [say(UPDATE_AGAIN)] : [])].join(" ");
 	return ctx.finish({ ok: false, rolledBack: problems.length === 0, omo, message });
 }

package/src/update/request.ts

@@ -6,6 +6,7 @@ import type { InstallKind } from "../runtime/install-kind.ts";
 import { type Origin, REQUEST_FILE, type UpdateRequest, readState, updateDir, updateRunning, writeJson, writeState } from "./state.ts";
 import { TargetError, type TargetInfo } from "./target.ts";
 import { engineBuildId } from "../engine/build-id.ts";
+import { say, type Text } from "../server-text.ts";
 
 /**
  * POST /api/update and POST /api/update/consent in the gateway (plan Todo 23). The pre-check refuses with 409 and a
@@ -13,13 +14,28 @@ import { engineBuildId } from "../engine/build-id.ts";
  * connection, writes request.json and starts the one-shot helper job.
  */
 
-export const BUSY_MESSAGE = "진행 중인 턴이 끊깁니다";
-export const CONSENT_ON_MAC_MESSAGE = "맥에서 새 권한 안내에 동의해야 합니다";
-export const ROLLBACK_SCHEMA_WARNING = "되돌리면 옛 엔진이 공유 폴더를 읽지 못할 수 있습니다";
-export const UNKNOWN_SCHEMA_LINE = "새 엔진이 공유 스키마를 몇으로 올리는지 알 수 없습니다.";
-export const CHECKOUT_MESSAGE = "이 설치(checkout)는 저장소에서 배포합니다. 업데이트는 npm 설치에서만 씁니다";
-
-export const DRAINING_MESSAGE = "이전 업데이트가 아직 이전 세대를 정리하고 있습니다. 정리가 끝난 뒤 다시 하세요";
+export const BUSY_MESSAGE: Text = { en: "Running turns will be cut off", ko: "진행 중인 턴이 끊깁니다" };
+export const CONSENT_ON_MAC_MESSAGE: Text = { en: "You must agree to the new permission notice on the Mac", ko: "맥에서 새 권한 안내에 동의해야 합니다" };
+export const ROLLBACK_SCHEMA_WARNING: Text = { en: "If you roll back, the old engine may not be able to read the shared folder", ko: "되돌리면 옛 엔진이 공유 폴더를 읽지 못할 수 있습니다" };
+export const UNKNOWN_SCHEMA_LINE: Text = { en: "Cannot tell which shared schema version the new engine upgrades to.", ko: "새 엔진이 공유 스키마를 몇으로 올리는지 알 수 없습니다." };
+export const CHECKOUT_MESSAGE: Text = { en: "This installation (checkout) is deployed from the repository. Updates only work for npm installations", ko: "이 설치(checkout)는 저장소에서 배포합니다. 업데이트는 npm 설치에서만 씁니다" };
+
+export const DRAINING_MESSAGE: Text = { en: "The previous update is still cleaning up the old generation. Try again after the cleanup finishes", ko: "이전 업데이트가 아직 이전 세대를 정리하고 있습니다. 정리가 끝난 뒤 다시 하세요" };
+
+const PENDING_QUESTIONS: Text = { en: "{count} question(s) are waiting for an answer. Answer them in the Inbox first. You can update after that.", ko: "답을 기다리는 질문이 {count}개 있습니다. 확인함에서 먼저 답해 주세요. 답한 뒤 업데이트할 수 있습니다." };
+const SCHEMA_UNREADABLE: Text = { en: "Engine {omo} of {version} (supports {supported}) cannot read the shared folder schema {store}, so the update was not applied. A version that supports schema {store} is required", ko: "공유 폴더 스키마 {store}를 {version}의 엔진 {omo}(지원 {supported})이 읽지 못해 업데이트하지 않았습니다. 스키마 {store}를 지원하는 버전이 필요합니다" };
+const STORE_SCHEMA_LINE: Text = { en: "Store schema {store}", ko: "저장소 스키마 {store}" };
+const TARGET_SUPPORT_LINE: Text = { en: "Target engine supports {supported}", ko: "대상 엔진 지원 {supported}" };
+const IN_PROGRESS: Text = { en: "An update is already in progress", ko: "업데이트가 이미 진행 중입니다" };
+const SAME_VERSION: Text = { en: "Already on {version}", ko: "이미 {version}입니다" };
+const CONSENT_REQUIRED: Text = { en: "You must agree to the new permission notice (notice version {version}) before updating", ko: "새 권한 안내(안내문 버전 {version})에 동의해야 업데이트합니다" };
+const BAD_UPDATE_BODY: Text = { en: "The body must be { version?, force?, confirmSchema? }", ko: "본문은 { version?, force?, confirmSchema? } 입니다" };
+const TARGET_CHECK_FAILED: Text = { en: "Could not check the target version: {error}", ko: "대상 버전을 확인하지 못했습니다: {error}" };
+const BACKUP_FAILED: Text = { en: "DB backup failed: {error}", ko: "DB 백업 실패: {error}" };
+const HELPER_START_FAILED: Text = { en: "Could not start the update helper: {error}", ko: "업데이트 도우미를 시작하지 못했습니다: {error}" };
+const BAD_CONSENT_BODY: Text = { en: "The body must be { version, noticeVersion, answer }", ko: "본문은 { version, noticeVersion, answer } 입니다" };
+const DECLINED: Text = { en: "Update cancelled because you did not agree", ko: "동의하지 않아 업데이트하지 않습니다" };
+const NOTICE_CHANGED: Text = { en: "The permission notice changed in the meantime. Check it again", ko: "권한 안내문이 그사이 바뀌었습니다. 다시 확인하세요" };
 
 export type RefusalCode = "not_updatable" | "in_progress" | "same_version" | "busy" | "consent_on_mac" | "consent_required" | "schema_confirm" | "pending_questions" | typeof SCHEMA_INCOMPATIBLE;
 
@@ -41,7 +57,7 @@ export interface Refusal {
  */
 export function questionRefusal(titles: readonly string[]): Refusal | null {
 	if (titles.length === 0) return null;
-	return { ok: false, code: "pending_questions", message: `답을 기다리는 질문이 ${titles.length}개 있습니다. 확인함에서 먼저 답해 주세요. 답한 뒤 업데이트할 수 있습니다.`,
+	return { ok: false, code: "pending_questions", message: say(PENDING_QUESTIONS, { count: titles.length }),
 		count: titles.length, titles };
 }
 
@@ -73,9 +89,9 @@ export function pendingMatches(pending: ConsentRecord | null, notice: Permission
 /** The lines to confirm before an engine change, or null when the shared store needs no warning. */
 export function schemaLines(target: TargetInfo, store: StoreReading, globalEngine: string | null): readonly string[] | null {
 	const next = target.engine?.threadSchema ?? null;
-	if (next === null) return [UNKNOWN_SCHEMA_LINE, ROLLBACK_SCHEMA_WARNING];
+	if (next === null) return [say(UNKNOWN_SCHEMA_LINE), say(ROLLBACK_SCHEMA_WARNING)];
 	const notice = updateSchemaNotice({ store, next, other: globalEngine === null ? null : { version: globalEngine, supported: null } });
-	return notice.confirm ? [...notice.lines, ROLLBACK_SCHEMA_WARNING] : null;
+	return notice.confirm ? [...notice.lines, say(ROLLBACK_SCHEMA_WARNING)] : null;
 }
 
 /**
@@ -85,27 +101,27 @@ export function schemaLines(target: TargetInfo, store: StoreReading, globalEngin
 export function schemaRefusal(target: TargetInfo, store: StoreReading): Refusal | null {
 	const found = storeIncompatibility(store, target.engine?.threadSchema ?? null);
 	if (found === null) return null;
-	return refuse(SCHEMA_INCOMPATIBLE, `공유 폴더 스키마 ${found.store}를 ${target.version}의 엔진 ${target.engine?.omo ?? ""}(지원 ${found.supported})이 읽지 못해 업데이트하지 않았습니다. 스키마 ${found.store}를 지원하는 버전이 필요합니다`,
-		{ lines: [`저장소 스키마 ${found.store}`, `대상 엔진 지원 ${found.supported}`] });
+	return refuse(SCHEMA_INCOMPATIBLE, say(SCHEMA_UNREADABLE, { store: found.store, version: target.version, omo: target.engine?.omo ?? "", supported: found.supported }),
+		{ lines: [say(STORE_SCHEMA_LINE, { store: found.store }), say(TARGET_SUPPORT_LINE, { supported: found.supported })] });
 }
 
 export function precheck(input: PrecheckInput): Precheck {
-	if (input.kind !== "npm") return refuse("not_updatable", CHECKOUT_MESSAGE);
-	if (input.running) return refuse("in_progress", "업데이트가 이미 진행 중입니다");
-	if (input.target.version === input.current.version) return refuse("same_version", `이미 ${input.current.version}입니다`);
+	if (input.kind !== "npm") return refuse("not_updatable", say(CHECKOUT_MESSAGE));
+	if (input.running) return refuse("in_progress", say(IN_PROGRESS));
+	if (input.target.version === input.current.version) return refuse("same_version", say(SAME_VERSION, { version: input.current.version }));
 	const incompatible = schemaRefusal(input.target, input.store);
 	if (incompatible !== null) return incompatible;
-	if (input.busy && !input.force && input.target.handoff !== true) return refuse("busy", BUSY_MESSAGE);
+	if (input.busy && !input.force && input.target.handoff !== true) return refuse("busy", say(BUSY_MESSAGE));
 	const notice = input.target.notice;
 	const noticeChanged = input.consent?.noticeVersion !== notice.version;
-	if (noticeChanged && input.origin === "app") return refuse("consent_on_mac", CONSENT_ON_MAC_MESSAGE);
+	if (noticeChanged && input.origin === "app") return refuse("consent_on_mac", say(CONSENT_ON_MAC_MESSAGE));
 	if (noticeChanged && !pendingMatches(input.pending, notice)) {
-		return refuse("consent_required", `새 권한 안내(안내문 버전 ${notice.version})에 동의해야 업데이트합니다`, { notice });
+		return refuse("consent_required", say(CONSENT_REQUIRED, { version: notice.version }), { notice });
 	}
 	const engineChanged = input.target.engine !== null && (input.current.engineOmo === null ||
 		engineBuildId(input.target.engine.omo, input.target.engine.revision) !== engineBuildId(input.current.engineOmo, input.current.engineRevision));
 	const lines = engineChanged && !input.confirmSchema ? schemaLines(input.target, input.store, input.globalEngine) : null;
-	if (lines !== null) return refuse("schema_confirm", ROLLBACK_SCHEMA_WARNING, { lines });
+	if (lines !== null) return refuse("schema_confirm", say(ROLLBACK_SCHEMA_WARNING), { lines });
 	return { ok: true, noticeChanged, engineChanged };
 }
 
@@ -150,17 +166,17 @@ function stamp(now: Date): string {
 
 export async function requestUpdate(raw: unknown, origin: Origin, deps: UpdateApiDeps): Promise<ApiAnswer> {
 	const body = parseUpdateBody(raw);
-	if (body === null) return { status: 400, body: { ok: false, code: "bad_request", message: "본문은 { version?, force?, confirmSchema? } 입니다" } };
-	if (deps.kind !== "npm") return { status: 409, body: refuse("not_updatable", CHECKOUT_MESSAGE) };
-	if (updateRunning(readState(deps.home), deps.now().getTime())) return { status: 409, body: refuse("in_progress", "업데이트가 이미 진행 중입니다") };
-	if (deps.draining?.() === true) return { status: 409, body: refuse("in_progress", DRAINING_MESSAGE) };
+	if (body === null) return { status: 400, body: { ok: false, code: "bad_request", message: say(BAD_UPDATE_BODY) } };
+	if (deps.kind !== "npm") return { status: 409, body: refuse("not_updatable", say(CHECKOUT_MESSAGE)) };
+	if (updateRunning(readState(deps.home), deps.now().getTime())) return { status: 409, body: refuse("in_progress", say(IN_PROGRESS)) };
+	if (deps.draining?.() === true) return { status: 409, body: refuse("in_progress", say(DRAINING_MESSAGE)) };
 	const waiting = questionRefusal(deps.questions());
 	if (waiting !== null) return { status: 409, body: waiting };
 	let target: TargetInfo;
 	try {
 		target = await deps.resolve(body.version);
 	} catch (error) {
-		const message = error instanceof TargetError ? error.message : `대상 버전을 확인하지 못했습니다: ${error instanceof Error ? error.message : String(error)}`;
+		const message = error instanceof TargetError ? error.message : say(TARGET_CHECK_FAILED, { error: error instanceof Error ? error.message : String(error) });
 		return { status: 502, body: { ok: false, code: "target_unavailable", message } };
 	}
 	const check = precheck({ kind: deps.kind, origin, current: deps.current, target, consent: deps.consent(), pending: deps.pending(), busy: deps.busy(),
@@ -173,7 +189,7 @@ export async function requestUpdate(raw: unknown, origin: Origin, deps: UpdateAp
 	try {
 		deps.snapshot(backup);
 	} catch (error) {
-		return { status: 500, body: { ok: false, code: "backup_failed", message: `DB 백업 실패: ${error instanceof Error ? error.message : String(error)}` } };
+		return { status: 500, body: { ok: false, code: "backup_failed", message: say(BACKUP_FAILED, { error: error instanceof Error ? error.message : String(error) }) } };
 	}
 	const request: UpdateRequest = { id, from: deps.current.version, to: target.version, source: target.source, noticeChanged: check.noticeChanged,
 		engineChanged: check.engineChanged, backup, origin, requestedAt: now.toISOString() };
@@ -182,7 +198,7 @@ export async function requestUpdate(raw: unknown, origin: Origin, deps: UpdateAp
 	const failed = await deps.launch();
 	if (failed !== null) {
 		writeState(deps.home, { id, from: request.from, to: request.to, phase: "done", at: now.toISOString(), result: { ok: false, from: request.from, to: request.to,
-			rolledBack: false, logPath: "", message: `업데이트 도우미를 시작하지 못했습니다: ${failed}`, omo: null, finishedAt: now.toISOString() } });
+			rolledBack: false, logPath: "", message: say(HELPER_START_FAILED, { error: failed }), omo: null, finishedAt: now.toISOString() } });
 		return { status: 500, body: { ok: false, code: "helper_failed", message: failed } };
 	}
 	return { status: 202, body: { ok: true, id, from: request.from, to: request.to } };
@@ -191,18 +207,18 @@ export async function requestUpdate(raw: unknown, origin: Origin, deps: UpdateAp
 /** The web window's (or the terminal's) `동의` for the target's new notice, kept as consent.pending.json until the helper promotes it. */
 export async function acceptUpdateConsent(raw: unknown, deps: Pick<UpdateApiDeps, "kind" | "home" | "resolve" | "now">): Promise<ApiAnswer> {
 	const { version, noticeVersion, answer } = (raw ?? {}) as Record<string, unknown>;
-	if (deps.kind !== "npm") return { status: 409, body: refuse("not_updatable", CHECKOUT_MESSAGE) };
+	if (deps.kind !== "npm") return { status: 409, body: refuse("not_updatable", say(CHECKOUT_MESSAGE)) };
 	if (typeof version !== "string" || typeof noticeVersion !== "number" || typeof answer !== "string") {
-		return { status: 400, body: { ok: false, code: "bad_request", message: "본문은 { version, noticeVersion, answer } 입니다" } };
+		return { status: 400, body: { ok: false, code: "bad_request", message: say(BAD_CONSENT_BODY) } };
 	}
-	if (answer.normalize("NFC") !== CONSENT_WORD) return { status: 400, body: { ok: false, code: "declined", message: "동의하지 않아 업데이트하지 않습니다" } };
+	if (answer.normalize("NFC") !== CONSENT_WORD) return { status: 400, body: { ok: false, code: "declined", message: say(DECLINED) } };
 	let target: TargetInfo;
 	try {
 		target = await deps.resolve(version);
 	} catch (error) {
 		return { status: 502, body: { ok: false, code: "target_unavailable", message: error instanceof Error ? error.message : String(error) } };
 	}
-	if (target.notice.version !== noticeVersion) return { status: 409, body: { ok: false, code: "notice_changed", message: "권한 안내문이 그사이 바뀌었습니다. 다시 확인하세요" } };
+	if (target.notice.version !== noticeVersion) return { status: 409, body: { ok: false, code: "notice_changed", message: say(NOTICE_CHANGED) } };
 	writePending(deps.home, { noticeVersion, noticeSha256: noticeSha256(target.notice.text), acceptedAt: deps.now().toISOString(), zigminiVersion: target.version });
 	return { status: 200, body: { ok: true } };
 }