@buzzni/saycode-cli 0.2.2 → 0.3.1

package/index.mjs

@@ -16,7 +16,7 @@ import require$$3$1 from "net";
 import require$$4$1 from "tls";
 import require$$0$5 from "stream";
 import require$$0$3 from "zlib";
-import { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$1, appendFileSync } from "node:fs";
+import { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$1, appendFileSync, accessSync, statSync } from "node:fs";
 import { dirname, join, basename, extname, delimiter } from "node:path";
 import { readFile, stat, mkdtemp, access, rm, mkdir, appendFile, writeFile, chmod } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
@@ -40,11 +40,24 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.2.2";
+const version = "0.3.1";
 const manifest = {
   version
 };
-const AGENT_VERBS = ["whoami", "ls", "read", "wait", "prompt", "spawn"];
+const AGENT_CONTROL_VERBS = ["steer", "stop"];
+function parseAgentControlArgs(verb, target, rest) {
+  if (verb === "steer") {
+    if (!target) return { command: "error", message: "agent steer needs a session id (see `saycode agent ls`)" };
+    const text2 = rest.slice(1).join(" ").trim();
+    return text2 ? { command: "agent", verb: "steer", sessionId: target, text: text2 } : { command: "error", message: "agent steer needs the text to send" };
+  }
+  if (verb === "stop") {
+    if (!target) return { command: "error", message: "agent stop needs a session id (see `saycode agent ls`)" };
+    return rest.length === 1 ? { command: "agent", verb: "stop", sessionId: target } : { command: "error", message: "agent stop takes exactly one session id" };
+  }
+  return null;
+}
+const AGENT_VERBS = ["whoami", "ls", "read", "wait", "prompt", "spawn", ...AGENT_CONTROL_VERBS];
 function fail(message) {
   return { command: "error", message };
 }
@@ -55,6 +68,8 @@ function parseAgentArgs(flags, positionals) {
   }
   const timeout = flags.timeoutMs !== void 0 ? { timeoutMs: flags.timeoutMs } : {};
   const target = rest[0] ?? flags.sessionId;
+  const control = parseAgentControlArgs(verb, target, rest);
+  if (control) return control;
   switch (verb) {
     case "whoami":
       return { command: "agent", verb: "whoami" };
@@ -85,10 +100,14 @@ function parseAgentArgs(flags, positionals) {
       };
     }
     case "spawn": {
+      const files = flags.files ?? [];
       if (flags.handoff) {
         if (flags.prompt !== void 0) {
           return fail("agent spawn --handoff sends the conversation, so it cannot also take --prompt");
         }
+        if (files.length > 0) {
+          return fail("agent spawn --handoff sends the conversation, so it cannot also take --file");
+        }
         const mode = flags.mode?.trim() || "summary";
         if (mode === "full") {
           return fail("agent spawn --handoff does not support --mode full yet; only summary is available");
@@ -104,8 +123,16 @@ function parseAgentArgs(flags, positionals) {
       }
       const text2 = flags.prompt?.trim();
       if (!text2) return fail("agent spawn needs --prompt <text>");
-      return { command: "agent", verb: "spawn", text: text2, ...flags.agent ? { agent: flags.agent } : {} };
+      return {
+        command: "agent",
+        verb: "spawn",
+        text: text2,
+        ...flags.agent ? { agent: flags.agent } : {},
+        ...files.length > 0 ? { files } : {}
+      };
     }
+    default:
+      return fail(`unsupported agent verb: ${verb}`);
   }
 }
 function fencedMarkdownRanges(content) {
@@ -389,7 +416,17 @@ const agentBoardKo = {
   "agentBoard.autopilot.loopStopFailed": "반복을 감지했지만 세션 중지에 실패했습니다: {detail}",
   "agentBoard.autopilot.forceProceed": "그래도 진행",
   "agentBoard.autopilot.forceProceedTitle": "리뷰어가 완료를 명시적으로 선언하지 않았습니다. 그래도 Commit & PR을 진행합니다.",
-  "agentBoard.autopilot.dismiss": "오토파일럿 기록 지우기"
+  "agentBoard.autopilot.dismiss": "오토파일럿 기록 지우기",
+  "agentBoard.verify.run": "변경 검증",
+  "agentBoard.verify.title": "프로젝트의 빌드·테스트·구동 레시피를 실행합니다.",
+  "agentBoard.verify.running": "검증 중 · {phase}",
+  "agentBoard.verify.passed": "검증 통과",
+  "agentBoard.verify.failed": "검증 실패",
+  "agentBoard.verify.phase.detect": "레시피 확인",
+  "agentBoard.verify.phase.bootstrap": "준비",
+  "agentBoard.verify.phase.build": "빌드",
+  "agentBoard.verify.phase.test": "테스트",
+  "agentBoard.verify.phase.start": "구동 확인"
 };
 const fanoutLifecycleKo = {
   "fanoutSection.restoreGroupAria": "병렬 그룹 복원: {title} · 실행 {run}",
@@ -585,8 +622,30 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.scheduleDaily": "매일 지정 시각",
   "scheduledAutomations.intervalMinutesLabel": "실행 주기(분, 최소 {min}분)",
   "scheduledAutomations.dailyTimeLabel": "실행 시각",
-  "scheduledAutomations.scriptLabel": "감시 스크립트 커맨드 (선택)",
+  "scheduledAutomations.monitorLabel": "변화 감지 커맨드 (선택)",
+  "scheduledAutomations.executionConditionLabel": "실행 조건",
+  "scheduledAutomations.executionEverySchedule": "예약마다 실행",
+  "scheduledAutomations.executionOnChange": "감시 결과가 바뀔 때만 실행",
+  "scheduledAutomations.advancedOptions": "고급 옵션 보기",
+  "scheduledAutomations.changeDetectionBadge": "변화 감지",
+  "scheduledAutomations.executionDetails": "실행 상세",
+  "scheduledAutomations.lastChange": "마지막 변화: {time}",
+  "scheduledAutomations.monitorOutputTitle": "최근 감시 출력",
+  "scheduledAutomations.monitorRequired": "변화 감지 명령을 입력하세요.",
+  "scheduledAutomations.templateLabel": "시작 템플릿",
+  "scheduledAutomations.templateNone": "직접 설정",
+  "scheduledAutomations.templateService": "서비스 상태 변화",
+  "scheduledAutomations.templateCommand": "명령 출력 변화",
+  "scheduledAutomations.templateHint": "템플릿은 폼만 채웁니다. 명령을 입력하고 확인한 뒤 직접 저장하세요.",
+  "scheduledAutomations.templateServiceName": "서비스 상태 감시",
+  "scheduledAutomations.templateCommandName": "명령 출력 감시",
+  "scheduledAutomations.templateServicePrompt": "서비스 상태가 어떻게 바뀌었는지 분석하고 필요한 조치를 제안해줘.",
+  "scheduledAutomations.templateCommandPrompt": "명령 출력의 변화를 분석하고 중요한 차이와 필요한 조치를 알려줘.",
+  "scheduledAutomations.monitorHint": "출력이 이전 성공 실행과 정확히 같으면 gate와 세션 실행을 생략합니다.",
+  "scheduledAutomations.notepadTitle": "자동화 메모장",
+  "scheduledAutomations.scriptLabel": "실행 gate 커맨드 (선택)",
   "scheduledAutomations.scriptHint": '마지막 줄이 {"wakeAgent": false} JSON이면 세션을 깨우지 않습니다.',
+  "scheduledAutomations.scriptHintFallback": '마지막 줄 JSON의 {"wakeAgent": false}는 세션을 깨우지 않고, {"notepad": {"key": "value"}}는 읽기 전용 메모장을 갱신합니다.',
   "scheduledAutomations.scriptWarning": "이 커맨드는 프로젝트 머신에서 사용자 권한으로 실행됩니다.",
   "scheduledAutomations.suppressSilentLabel": "응답이 [SILENT]면 알림 배지 생략",
   "scheduledAutomations.save": "저장",
@@ -600,6 +659,7 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.nextRun": "다음 실행: {time}",
   "scheduledAutomations.historyTitle": "최근 실행",
   "scheduledAutomations.outcomeWoke": "세션 실행",
+  "scheduledAutomations.outcomeNoChange": "모니터 변화 없음(스킵)",
   "scheduledAutomations.outcomeSkippedGate": "변화 없음(스킵)",
   "scheduledAutomations.outcomeSkippedOverlap": "이전 실행 진행 중(스킵)",
   "scheduledAutomations.outcomeSilent": "이상 없음([SILENT])",
@@ -619,6 +679,7 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.errorViewerKeyInUse": "기존 DB 자동화가 다른 암호화 키를 사용하고 있어 자동으로 전환할 수 없습니다. 기존 DB 자동화를 삭제한 뒤 다시 시도하세요.",
   "scheduledAutomations.errorWorkspaceMissing": "프로젝트 작업 폴더를 찾을 수 없습니다.",
   "scheduledAutomations.errorMachineOffline": "프로젝트 머신이 오프라인입니다.",
+  "scheduledAutomations.errorMonitorUnsupported": "대상 daemon이 변화 감지 자동화를 지원하지 않습니다. 연결 상태를 확인한 뒤 다시 시도하세요.",
   "scheduledAutomations.errorUnavailable": "자동화 서비스를 현재 사용할 수 없습니다.",
   "scheduledAutomations.runNow": "바로 실행",
   "scheduledAutomations.runRequestedNotice": "자동화 실행을 요청했습니다."
@@ -787,6 +848,9 @@ const personalChatsKo = {
   "personalChats.send": "전송",
   "personalChats.creating": "채팅을 시작하는 중…",
   "personalChats.noOnlineMachine": "온라인 머신이 없습니다. 채팅을 시작하려면 머신을 시작해주세요.",
+  "personalChats.localMachinePreparing": "이 컴퓨터를 Saycode에 연결하는 중이에요. 잠시 후 바로 시작할 수 있어요.",
+  "personalChats.localMachineAsk": "이 컴퓨터를 바로 사용할 수 있어요. 클릭 한 번으로 연결을 마치세요.",
+  "personalChats.localMachineFailed": "이 컴퓨터 자동 연결에 실패했어요. 다른 방법으로 연결할 수 있어요.",
   "personalChats.pickMachine": "이 채팅을 실행할 머신을 선택하세요",
   "personalChats.back": "뒤로",
   "personalChats.stop": "중지",
@@ -851,6 +915,44 @@ const agentLoopDetectionKo = {
   "settings.agentLoopAutoStop.help": "오토파일럿이 관리하는 세션이 같은 툴 호출이나 텍스트를 반복하며 멈춘 것으로 보이면 자동으로 응답을 중지합니다. 기본은 꺼짐 — 오탐으로 정상 작업을 멈추는 것이 놓치는 것보다 나쁩니다.",
   "settings.agentLoopAutoStop.saveFailed": "설정을 저장하지 못했습니다."
 };
+const autopilotSelfReviewRoundsKo = {
+  "settings.autopilotSelfReviewRounds.label": "오토파일럿 셀프 리뷰 반복 횟수",
+  "settings.autopilotSelfReviewRounds.help": '오토파일럿이 "현재 에이전트로 점검"을 몇 번까지 이어서 시킬지 정합니다. 점검 결과에 아직 해결하지 못한 문제가 남아 있으면 남은 횟수만큼 다시 점검하게 하고, 문제가 없어지면 남은 횟수와 상관없이 바로 Commit & PR로 넘어갑니다. 지정한 횟수를 다 쓰고도 문제가 남으면 지금처럼 멈추고 사람에게 넘깁니다. 기본은 1회(지금까지와 동일).',
+  "settings.autopilotSelfReviewRounds.once": "1회 (반복 없음)",
+  "settings.autopilotSelfReviewRounds.times": "{count}회",
+  "settings.autopilotSelfReviewRounds.saveFailed": "설정을 저장하지 못했습니다.",
+  "agentBoard.autopilot.reviewingSelfRound": "오토파일럿 · 셀프 리뷰 중 {round}/{total}"
+};
+const externalWorktreeInboxKo = {
+  "externalWorktreeInbox.title": "앱 밖에서 만든 worktree",
+  "externalWorktreeInbox.description": "이 저장소에 앱이 만들지 않은 worktree 가 있습니다. 채택하면 목록과 새 대화 시작에서 고를 수 있어요.",
+  "externalWorktreeInbox.adopt": "채택",
+  "externalWorktreeInbox.ignore": "무시",
+  "externalWorktreeInbox.adoptAria": "외부 worktree {name} 채택",
+  "externalWorktreeInbox.ignoreAria": "외부 worktree {name} 무시",
+  "externalWorktreeInbox.externalBadge": "외부",
+  "externalWorktreeInbox.deleteBlocked": "앱 밖에서 만든 worktree 라 앱에서 삭제하지 않습니다.",
+  "externalWorktreeInbox.adoptRejectedStaleScan": "worktree 목록이 최신이 아닙니다. 새로고침한 뒤 다시 채택하세요.",
+  "externalWorktreeInbox.adoptRejectedNotOwned": "이 프로젝트 저장소의 worktree 가 아니라서 채택하지 않았습니다."
+};
+const externalSessionVaultKo = {
+  "externalSessionVault.openCommand": "앱 밖에서 시작한 대화 이어가기",
+  "externalSessionVault.dialogAria": "{name}의 앱 밖에서 시작한 대화",
+  "externalSessionVault.title": "앱 밖에서 시작한 대화",
+  "externalSessionVault.description": "이 프로젝트 폴더에서 터미널로 돌린 Claude Code 세션입니다. 이어가면 그 대화를 그대로 잇는 앱 대화가 시작됩니다.",
+  "externalSessionVault.closeAria": "닫기",
+  "externalSessionVault.loading": "앱 밖에서 시작한 대화를 찾는 중입니다…",
+  "externalSessionVault.empty": "이 프로젝트에서 앱 밖 대화를 찾지 못했습니다.",
+  "externalSessionVault.failed": "앱 밖에서 시작한 대화를 읽지 못했습니다.",
+  "externalSessionVault.untitled": "제목 없는 대화",
+  "externalSessionVault.resume": "이어가기",
+  "externalSessionVault.ignore": "무시",
+  "externalSessionVault.resumeAria": "{title} 대화 이어가기",
+  "externalSessionVault.ignoreAria": "{title} 대화 무시",
+  "externalSessionVault.rejectedStaleScan": "목록이 최신이 아닙니다. 새로고침한 뒤 다시 시도하세요.",
+  "externalSessionVault.rejectedNotOwned": "이 프로젝트 폴더에서 돌린 대화가 아니라서 이어가지 않았습니다.",
+  "externalSessionVault.resumeFailed": "그 대화를 이어가지 못했습니다."
+};
 const operationModelRetryKo = {
   "review.job.fallbackModelUsed": "폴백 모델 사용됨: {model}"
 };
@@ -1184,9 +1286,84 @@ const sidebarUpdateKo = {
   "sidebarUpdate.retry": "업데이트 확인 실패 — 다시 시도",
   "sidebarUpdate.unsupported": "이 빌드에서는 자동 업데이트를 쓸 수 없습니다",
   "sidebarUpdate.currentVersion": "현재 v{version}",
-  "sidebarUpdate.newVersion": "v{version}"
+  "sidebarUpdate.newVersion": "v{version}",
+  "sidebarUpdate.installFailed": "업데이트가 적용되지 않았습니다 — v{expected} 로 바뀌었어야 하는데 여전히 v{actual} 입니다. 다시 확인"
+};
+const globalPauseKo = {
+  "settings.globalPause.enable": "전역 일시정지 (새 자동 액션 차단)",
+  "settings.globalPause.help": "켜면 예약 자동화 실행, GitHub 이벤트 트리거 발화, 보드 오토파일럿의 다음 단계가 시작되지 않습니다. 이미 진행 중인 대화는 중단되지 않으며, 끄면 보류된 작업이 다음 주기에 이어서 진행됩니다.",
+  "settings.globalPause.scope": "이 스위치는 이 데스크탑 앱이 직접 실행하는 자동화에만 적용됩니다. 머신 데몬이 소유한 실행 경로는 막지 않습니다.",
+  "settings.globalPause.saveFailed": "전역 일시정지를 전환하지 못했습니다."
+};
+const terminalFontKo = {
+  "settings.terminalFont.cardTitle": "터미널 폰트",
+  "settings.terminalFont.sizeLabel": "글자 크기",
+  "settings.terminalFont.sizeHelp": "{min}~{max} 사이의 정수를 입력하세요.",
+  "settings.terminalFont.sizeInvalid": "{min}~{max} 사이의 정수만 적용됩니다.",
+  "settings.terminalFont.familyLabel": "폰트 이름",
+  "settings.terminalFont.familyHelp": "CSS font-family 값입니다. 쉼표로 여러 폰트를 적으면 앞에서부터 사용할 수 있는 것을 씁니다. 비워 두면 기본 폰트로 돌아갑니다.",
+  "settings.terminalFont.cardHelp": "이 기기의 원격 터미널에 적용됩니다. 열려 있는 터미널에도 재연결 없이 바로 반영됩니다.",
+  "settings.terminalFont.reset": "기본값으로 되돌리기"
+};
+const subagentKo = {
+  "subagent.title": "자식 에이전트 {count}개",
+  "subagent.open": "자식 대화 열기",
+  "subagent.status.responding": "응답 중",
+  "subagent.status.waiting": "입력 대기",
+  "subagent.status.completed": "완료",
+  "subagent.status.stopped": "중단됨",
+  "subagent.steer.placeholder": "현재 턴에 전달할 지시",
+  "subagent.steer.action": "지시 전달",
+  "subagent.stop.action": "중단",
+  "subagent.steer.requested": "전달 요청됨 · 다음 tool 경계에서 적용 예정",
+  "subagent.steer.applied": "지시가 자식 대화에 적용됨",
+  "subagent.steer.missed": "지시가 적용되지 못한 채 턴이 끝남",
+  "subagent.error.notOwned": "이 대화에서 제어할 수 없는 세션입니다.",
+  "subagent.error.empty": "전달할 지시를 입력하세요.",
+  "subagent.error.inFlight": "이전 제어 요청을 처리하는 중입니다.",
+  "subagent.error.rejected": "요청이 거부됐습니다: {detail}"
 };
-const catalogExtensionsKo = { ...taskNotificationKo, ...machineUsageKo, ...completionInboxKo, ...agentBoardKo, ...fanoutLifecycleKo, ...conversationSearchKo, ...browserCookieImportKo, ...orcaPortKo, ...usageAnalyticsKo, ...outboundWebhookKo, ...scheduledAutomationsKo, ...githubTriggersKo, ...memoryHubKo, ...extensionPanelKo, ...extensionInstallKo, ...personalChatsKo, ...newSessionStarterKo, ...browserConsoleCaptureKo, ...completionSignalKo, ...agentLoopDetectionKo, ...operationModelRetryKo, ...skillCatalogKo, ...ciAutoFixKo, ...collaborationKo, ...backgroundTaskKo, ...sessionTitleKo, ...accountSettingsKo, ...projectScopeKo, ...machineSettingsConsoleKo, ...sessionTokenUsageKo, ...worktreeSetupKo, ...connectionIndicatorKo, ...voiceDictationKo, ...newSessionProfileKo, ...agentBoardBroadcastKo, ...judgementEvidenceKo, ...releaseNoteKo, ...notificationSoundKo, ...officeViewerKo, ...additionalDirectoriesKo, ...agentHandoffKo, ...sidebarUpdateKo };
+const aiCommitPrKo = {
+  "aiCommitPr.stagedCount": "스테이지된 파일 {count}개",
+  "aiCommitPr.noStaged": "스테이지된 변경이 없습니다.",
+  "aiCommitPr.stageAll": "모든 변경 스테이지",
+  "aiCommitPr.staging": "스테이지하는 중…",
+  "aiCommitPr.messagePlaceholder": "커밋 메시지",
+  "aiCommitPr.messageAria": "커밋 메시지",
+  "aiCommitPr.stagedListAria": "스테이지된 파일 목록",
+  "aiCommitPr.commit": "커밋",
+  "aiCommitPr.committing": "커밋하는 중…",
+  "aiCommitPr.committed": "커밋했습니다 ({hash})",
+  "aiCommitPr.generate": "AI 생성",
+  "aiCommitPr.cancelGenerate": "생성 취소",
+  "aiCommitPr.overwriteConfirm": "이미 적어둔 메시지를 AI가 만든 것으로 바꿀까요?",
+  "aiCommitPr.error.nothingStaged": "스테이지된 변경이 없어 커밋할 수 없습니다.",
+  "aiCommitPr.error.commitFailed": "커밋하지 못했습니다.",
+  "aiCommitPr.error.claudeMissing": "이 컴퓨터에서 claude 명령을 찾지 못했습니다.",
+  "aiCommitPr.error.generationFailed": "메시지를 만들지 못했습니다.",
+  "aiCommitPr.error.timedOut": "생성이 너무 오래 걸려 중단했습니다.",
+  "aiCommitPr.error.nothingToDescribe": "설명할 변경이 없습니다.",
+  "aiCommitPr.error.emptyOutput": "생성 결과가 비어 있습니다.",
+  "aiCommitPr.error.machineOffline": "이 컴퓨터가 오프라인입니다.",
+  "aiCommitPr.error.noResponse": "응답을 받지 못했습니다.",
+  "aiCommitPr.error.cancelled": "생성을 취소했습니다.",
+  "aiCommitPr.error.daemonBusy": "머신이 다른 작업으로 바쁩니다. 잠시 후 다시 시도하세요.",
+  "aiCommitPr.error.commitNoResponse": "응답을 받지 못했습니다. 커밋이 완료됐을 수도 있으니 패널을 다시 열어 확인하세요.",
+  "aiCommitPr.error.gitFailed": "git 명령이 실패했습니다.",
+  "aiCommitPr.error.stagedProbeFailed": "스테이지된 변경을 읽지 못했습니다.",
+  "aiCommitPr.error.stageFailed": "변경을 스테이지하지 못했습니다.",
+  "aiCommitPr.settings.enable": "커밋 메시지와 PR 설명을 AI로 생성",
+  "aiCommitPr.settings.help": "켜면 git 패널과 PR 만들기 화면에 “AI 생성” 버튼이 나타납니다. 생성은 이 컴퓨터에서 한 번 실행되며, 결과는 입력란에 채워질 뿐 자동으로 커밋하거나 PR을 만들지 않습니다. 기본은 꺼짐.",
+  "aiCommitPr.settings.saveFailed": "설정을 저장하지 못했습니다.",
+  "aiCommitPr.pr.dialogTitle": "Pull Request 만들기",
+  "aiCommitPr.pr.dialogAria": "{branch} 브랜치의 Pull Request 내용 작성",
+  "aiCommitPr.pr.titleLabel": "제목",
+  "aiCommitPr.pr.bodyLabel": "설명",
+  "aiCommitPr.pr.base": "{base} 브랜치로 병합",
+  "aiCommitPr.pr.create": "Pull Request 만들기",
+  "aiCommitPr.pr.creating": "만드는 중…"
+};
+const catalogExtensionsKo = { ...taskNotificationKo, ...machineUsageKo, ...completionInboxKo, ...agentBoardKo, ...fanoutLifecycleKo, ...conversationSearchKo, ...browserCookieImportKo, ...orcaPortKo, ...usageAnalyticsKo, ...outboundWebhookKo, ...scheduledAutomationsKo, ...githubTriggersKo, ...memoryHubKo, ...extensionPanelKo, ...extensionInstallKo, ...personalChatsKo, ...newSessionStarterKo, ...browserConsoleCaptureKo, ...completionSignalKo, ...agentLoopDetectionKo, ...operationModelRetryKo, ...skillCatalogKo, ...ciAutoFixKo, ...collaborationKo, ...backgroundTaskKo, ...sessionTitleKo, ...accountSettingsKo, ...projectScopeKo, ...machineSettingsConsoleKo, ...sessionTokenUsageKo, ...worktreeSetupKo, ...connectionIndicatorKo, ...voiceDictationKo, ...newSessionProfileKo, ...agentBoardBroadcastKo, ...judgementEvidenceKo, ...releaseNoteKo, ...notificationSoundKo, ...officeViewerKo, ...additionalDirectoriesKo, ...agentHandoffKo, ...sidebarUpdateKo, ...autopilotSelfReviewRoundsKo, ...aiCommitPrKo, ...externalWorktreeInboxKo, ...externalSessionVaultKo, ...terminalFontKo, ...globalPauseKo, ...subagentKo };
 const onboardingKo = {
   "onboarding.dialogAria": "시작 설정",
   "onboarding.eyebrow": "처음 시작하기",
@@ -1208,6 +1385,14 @@ const onboardingKo = {
   "onboarding.oneCommand.copy": "명령어 복사",
   "onboarding.oneCommand.copied": "복사됨",
   "onboarding.oneCommand.advanced": "고급: 수동 설치",
+  "onboarding.localMachine.registering": "이 컴퓨터를 등록하는 중…",
+  "onboarding.localMachine.registered": "✓ 이 컴퓨터가 등록되었습니다. 바로 작업할 수 있어요.",
+  "onboarding.localMachine.askTitle": "이 컴퓨터를 바로 사용",
+  "onboarding.localMachine.askBody": "이 컴퓨터에 이미 Happy 설정이 있습니다. 지금 설정으로 바꾸기 전에 원래 파일을 백업해 두고, 실패하면 되돌립니다.",
+  "onboarding.localMachine.askAction": "이 컴퓨터를 바로 사용",
+  "onboarding.localMachine.failed": "자동 등록에 실패했습니다. 아래 명령으로 직접 설정할 수 있어요.",
+  "onboarding.localMachine.retry": "다시 시도",
+  "onboarding.localMachine.remoteHint": "다른 컴퓨터나 조직 공유 머신은 머신 설정에서 추가할 수 있어요.",
   "onboarding.machineDetected": "✓ {name} 연결됨",
   "onboarding.standalone.title": "내장 서버와 로컬 머신",
   "onboarding.standalone.body": "앱이 서버와 로컬 실행 머신을 자동으로 준비합니다. 별도 서버 명령은 필요하지 않습니다.",
@@ -1270,10 +1455,10 @@ const previewTunnelKo = {
 };
 const ko = {
   // Common actions
-  "common.save": "Save",
-  "common.reset": "Reset",
-  "common.cancel": "Cancel",
-  "common.close": "Close",
+  "common.save": "저장",
+  "common.reset": "초기화",
+  "common.cancel": "취소",
+  "common.close": "닫기",
   "happyCliUpdate.title": "Happy CLI 업데이트가 있습니다",
   "happyCliUpdate.checkTitle": "Happy CLI 업데이트 확인",
   "happyCliUpdate.managerTitle": "Happy CLI 업데이트 관리",
@@ -1307,30 +1492,42 @@ const ko = {
   "language.select.subtitle": "앱에서 사용할 언어를 선택하세요. 나중에 설정에서 바꿀 수 있습니다.",
   // Login screen
   "login.lead": "모바일 앱의 프로젝트, 대화, 문서 흐름을 데스크톱 작업 화면으로 옮긴 Electron 클라이언트입니다.",
-  "login.secureWorkspace": "Secure Workspace",
-  "login.description": "saycode.ai 계정으로 로그인하거나 데모 워크스페이스를 열어 로컬에서 검토하세요.",
+  "login.stepsTitle": "시작 방법",
+  "login.step1Title": "시작 방식 선택",
+  "login.step1Body": "계정 없이 이 컴퓨터에서, 또는 Saycode 계정으로 시작해요.",
+  "login.step2Title": "이 컴퓨터 자동 연결",
+  "login.step2Body": "터미널 없이 이 컴퓨터가 자동으로 준비돼요. 로그인하면 개인 머신으로 등록돼요.",
+  "login.step3Title": "바로 대화 시작",
+  "login.step3Body": "프로젝트를 열고 첫 메시지를 보내면 끝이에요.",
+  "login.localCardTitle": "이 컴퓨터에서 바로 시작",
+  "login.localCardBody": "계정 없이 로컬 전용(Standalone) 모드로 시작해요.",
+  "login.localCardAction": "계정 없이 시작하기",
+  "login.localDataNotice": "데이터는 이 컴퓨터에만 저장되며 로그인 계정과는 별개예요.",
+  "login.localUnavailable": "이 빌드에는 로컬 전용 런타임이 포함되어 있지 않아요.",
+  "login.cloudCardTitle": "Saycode 계정으로 로그인",
+  "login.cloudCardBody": "팀 공유, 원격 머신, 커뮤니티까지 모든 기능을 사용해요.",
+  "login.localDataStaysNotice": "로컬 전용 모드의 데이터는 이 컴퓨터에 남아 있어요. 로그인 계정과는 별개예요.",
   "login.email": "이메일",
   "login.password": "비밀번호",
   "login.passwordPlaceholder": "비밀번호",
-  "login.loggingIn": "Logging in...",
+  "login.loggingIn": "로그인 중...",
   "login.login": "로그인",
   "login.demoWorkspace": "데모 워크스페이스",
   "login.standaloneStarting": "로컬 서버 시작 중...",
-  "login.standalone": "로컬 전용 모드 (Standalone)",
   "login.signupPrompt": "처음이신가요?",
   "login.signupLink": "saycode.ai에서 계정 만들기",
   "login.orgJoinHint": "회사 조직에 참여하려면 계정을 만든 뒤 saycode.ai에서 초대 코드를 입력하거나 관리자가 보낸 초대를 수락하세요. 그다음 같은 계정으로 여기에 로그인합니다.",
   // Settings — Language tab
-  "settings.tab.language": "Language",
+  "settings.tab.language": "언어",
   "settings.language.help": "앱의 모든 화면에 사용할 언어를 선택합니다.",
   "settings.language.current": "현재 적용: {language}",
   "settings.language.updated": "언어가 변경되었습니다.",
   "settings.language.loadFailed": "언어 설정을 불러오지 못했습니다.",
   "settings.language.saveFailed": "언어 설정을 저장하지 못했습니다.",
   // Sidebar / workspace chrome
-  "account.unknownUser": "Unknown",
-  "account.demoWorkspace": "Demo workspace",
-  "account.connectedWorkspace": "Connected workspace",
+  "account.unknownUser": "알 수 없음",
+  "account.demoWorkspace": "데모 워크스페이스",
+  "account.connectedWorkspace": "연결된 워크스페이스",
   "account.syncing": "캐시된 워크스페이스를 최신 정보로 동기화하는 중입니다.",
   "sidebar.newProject": "새 프로젝트",
   "sidebar.modeChats": "대화",
@@ -1372,6 +1569,32 @@ const ko = {
   "pendingConversation.failed": "이 대화를 시작하지 못했습니다.",
   "pendingConversation.retry": "다시 시도",
   "newProject.title": "새 프로젝트",
+  "machineDisplayName.dialogAria": "머신 이름 변경",
+  "machineDisplayName.title": "머신 이름",
+  "machineDisplayName.closeAria": "머신 이름 편집 닫기",
+  "machineDisplayName.label": "표시명",
+  "machineDisplayName.placeholder": "예: 작업 서버",
+  "machineDisplayName.hint": "비워두고 저장하면 원래 host 이름으로 표시합니다.",
+  "machineDisplayName.clear": "이름 지우기",
+  "machineDisplayName.saving": "저장 중...",
+  "newProject.eyebrow": "시작",
+  "newProject.contextOrganization": "조직 컨텍스트",
+  "newProject.contextPersonal": "개인 컨텍스트",
+  "newProject.closeAria": "새 프로젝트 닫기",
+  "newProject.sourceAria": "프로젝트 소스",
+  "newProject.sourceBlank": "빈 프로젝트",
+  "newProject.sourceFolder": "폴더",
+  "newProject.nameLabel": "프로젝트 이름",
+  "newProject.existingFolderLabel": "기존 폴더",
+  "newProject.choose": "선택",
+  "newProject.summaryBlank": "빈 동기화 프로젝트를 만듭니다.",
+  "newProject.summaryGit": "프로젝트를 만들고 선택한 머신에서 Git 가져오기를 시작합니다.",
+  "newProject.summaryZip": "프로젝트를 만들고 선택한 머신에서 선택한 ZIP/파일을 가져옵니다.",
+  "newProject.summaryExistingFolder": "기존 절대 경로 폴더를 동기화 프로젝트로 등록합니다.",
+  "newProject.creating": "만드는 중...",
+  "newProject.createAction": "프로젝트 만들기",
+  "newProject.importAction": "프로젝트 가져오기",
+  "newProject.gitUrlLabel": "Git 저장소 주소",
   "newProject.importTab": "Zip/파일 가져오기",
   "newProject.importSection": "Zip/파일 가져오기",
   "newProject.importPickAria": "Zip/파일 선택",
@@ -1403,7 +1626,7 @@ const ko = {
   "upload.failed": "파일을 업로드하지 못했습니다.",
   "upload.machineOffline": "선택한 머신이 오프라인입니다.",
   "workspace.label": "작업공간",
-  "workspace.contextAria": "Workspace context",
+  "workspace.contextAria": "워크스페이스 컨텍스트",
   "workspace.personal": "개인 작업공간",
   "workspace.personalProjects": "개인 프로젝트",
   "workspace.orgHome": "조직 홈",
@@ -1664,6 +1887,11 @@ const ko = {
   "orgAdmin.vault.machineNotConfigured": "인증이 적용되지 않음",
   "orgAdmin.vault.captureSucceeded": "인증 세트를 저장했습니다.",
   "orgAdmin.vault.deploySucceeded": "머신 {count}대에 적용했습니다.",
+  "myAiCredentials.title": "저장된 AI 인증 세트 적용",
+  "myAiCredentials.description": "조직에 저장된 AI 인증 세트를 내 개인 머신이나 내가 등록한 공용 머신에 적용합니다. 인증 세트를 새로 저장하거나 삭제하려면 조직 관리자에게 문의하세요.",
+  "myAiCredentials.noMachines": "적용할 수 있는 머신이 없습니다. 개인 머신을 등록하거나, 공용 머신을 직접 등록한 경우에만 여기에 나타납니다.",
+  "myAiCredentials.targetMachines": "적용할 내 머신",
+  "myAiCredentials.deploySucceeded": "{machines}에 인증 세트를 적용했습니다.",
   "orgAdmin.vault.deleteSucceeded": "인증 세트를 삭제했습니다.",
   "orgAdmin.vault.rotationStarted": "자동 회전을 시작했습니다.",
   "orgAdmin.vault.rotationStopped": "자동 회전을 중지했습니다.",
@@ -1685,20 +1913,20 @@ const ko = {
   "session.newConversation": "새 대화",
   "session.lastConversation": "최근 대화 {time}",
   // Settings dialog chrome
-  "settings.eyebrow": "Preferences",
-  "settings.title": "Desktop settings",
-  "settings.close": "Close settings",
+  "settings.eyebrow": "환경설정",
+  "settings.title": "데스크톱 설정",
+  "settings.close": "설정 닫기",
   // Settings — Notifications tab
-  "settings.notifications.loading": "Loading notification settings...",
-  "settings.notifications.mobilePush": "Mobile completion push",
-  "settings.notifications.updated": "Notification settings saved.",
+  "settings.notifications.loading": "알림 설정을 불러오는 중...",
+  "settings.notifications.mobilePush": "모바일 완료 푸시",
+  "settings.notifications.updated": "알림 설정을 저장했습니다.",
   "settings.notifications.loadFailed": "알림 설정을 불러오지 못했습니다.",
   "settings.notifications.saveFailed": "알림 설정을 저장하지 못했습니다.",
   // Settings — Visual effects tab
   "settings.visualEffects.loadFailed": "시각 효과 설정을 불러오지 못했습니다.",
   "settings.visualEffects.saveFailed": "시각 효과 설정을 저장하지 못했습니다.",
-  "settings.visualEffects.updated": "Visual effects updated.",
-  "settings.visualEffects.loading": "Loading visual effects...",
+  "settings.visualEffects.updated": "시각 효과를 업데이트했습니다.",
+  "settings.visualEffects.loading": "시각 효과를 불러오는 중...",
   "settings.visualEffects.help": "저사양 환경에서는 흐림, 큰 그림자와 장식 애니메이션을 줄여 스크롤과 창 이동을 부드럽게 합니다.",
   "settings.visualEffects.auto": "자동",
   "settings.visualEffects.full": "전체 효과",
@@ -1706,7 +1934,7 @@ const ko = {
   "settings.visualEffects.currentAuto": "현재 적용: 자동 ({result})",
   "settings.visualEffects.current": "현재 적용: {result}",
   // Project list / sidebar sections
-  "project.ownershipAria": "Project ownership",
+  "project.ownershipAria": "프로젝트 소유",
   "project.mine": "내 프로젝트",
   "project.shared": "공유받은 프로젝트",
   "project.recent": "최근 프로젝트",
@@ -1715,7 +1943,7 @@ const ko = {
   "project.backToList": "프로젝트 목록으로",
   "project.allProjects": "모든 프로젝트",
   "project.navigationAria": "프로젝트 위치",
-  "project.listAria": "Projects",
+  "project.listAria": "프로젝트",
   "project.emptyMineTitle": "내 프로젝트가 없습니다",
   "project.emptySharedTitle": "공유받은 프로젝트가 없습니다",
   "project.emptySearchHint": "검색 조건에 맞는 프로젝트가 없습니다.",
@@ -1723,7 +1951,7 @@ const ko = {
   "sidebar.clickTarget": "프로젝트 클릭 시: {target} 에 열림",
   "sidebar.newWindow": "새 창",
   "sidebar.settings": "환경설정",
-  "sidebar.logout": "Logout",
+  "sidebar.logout": "로그아웃",
   // Content pane / unified workspace
   "runningIndicator.title": "실행 중인 작업 열기",
   "runningIndicator.label": "실행 중 {count}",
@@ -1746,13 +1974,13 @@ const ko = {
   "panel.recovery.demoDesc": "Demo workspace에서는 네트워크 연결을 열지 않습니다.",
   "panel.recovery.loginDesc": "로그인 후 터미널을 시작할 수 있습니다.",
   // Chat composer
-  "composer.messageAria": "Message",
+  "composer.messageAria": "메시지",
   "composer.placeholder": "데스크톱에서 보낼 메시지를 입력",
   "composer.promptSuggestionPaused": "{window} 사용량 {percent}% — 사용량 경고 중에는 Claude가 추천 질문을 만들지 않습니다",
   "composer.promptSuggestionPausedReset": "{reset} 초기화",
-  "composer.starting": "Starting...",
-  "composer.sending": "Sending...",
-  "composer.working": "Working...",
+  "composer.starting": "시작 중...",
+  "composer.sending": "전송 중...",
+  "composer.working": "작업 중...",
   "composer.queue.limitReached": "대기열이 가득 찼습니다(최대 3개)",
   "composer.queue.title": "대기 중인 요청",
   "composer.queue.edit": "편집",
@@ -1760,11 +1988,11 @@ const ko = {
   "composer.queue.steerNow": "즉시 요청",
   "composer.queue.add": "대기열에 추가",
   "composer.queue.editBlocked": "입력창을 비운 뒤 편집할 수 있습니다",
-  "composer.send": "Send",
+  "composer.send": "보내기",
   "composer.stopping": "중단 중...",
   "composer.stop": "중단",
   // Common (shared)
-  "common.refresh": "Refresh",
+  "common.refresh": "새로고침",
   // Project worktree dialog
   "worktreeDialog.listFailed": "worktree 목록을 불러오지 못했습니다.",
   "worktreeDialog.startFailed": "새 대화를 시작하지 못했습니다.",
@@ -1783,9 +2011,9 @@ const ko = {
   "worktreeDialog.delete": "삭제",
   "worktreeDialog.forceDelete": "강제 삭제",
   "worktreeDialog.cancel": "취소",
-  "worktreeDialog.dialogAria": "{name} worktrees",
-  "worktreeDialog.closeAria": "Close worktree dialog",
-  "worktreeDialog.listAria": "{name} worktree list",
+  "worktreeDialog.dialogAria": "{name} 워크트리",
+  "worktreeDialog.closeAria": "워크트리 다이얼로그 닫기",
+  "worktreeDialog.listAria": "{name} 워크트리 목록",
   "worktreeDialog.loading": "Worktree 목록을 불러오는 중입니다.",
   "worktreeDialog.empty": "이 프로젝트에는 관리 중인 worktree가 없습니다.",
   "worktreeDialog.rowAria": "worktree {name}",
@@ -1793,6 +2021,13 @@ const ko = {
   "worktreeDialog.startSessionTitle": "이 worktree에서 새 대화를 시작합니다 (새 worktree를 만들지 않습니다)",
   "worktreeDialog.startSession": "이 worktree에서 새 대화",
   "worktreeDialog.removeAria": "{name} 삭제",
+  "worktreePathCopy.copy": "worktree 경로 복사",
+  "worktreePathCopy.copied": "worktree 경로 복사됨",
+  "worktreePathCopy.failed": "worktree 경로 복사 실패",
+  "sessionWorktree.worktree": "워크트리: {name}",
+  "sessionWorktree.branch": "브랜치: {branch}",
+  "sessionWorktree.path": "경로: {path}",
+  "sessionWorktree.merged": "병합됨",
   // Project git controls
   "gitControls.branchLoading": "Git branch 확인 중",
   "gitControls.noRemote": "origin remote 또는 branch를 찾을 수 없습니다.",
@@ -1801,12 +2036,13 @@ const ko = {
   "gitControls.manageBranchAria": "{branch} branch 관리",
   "gitControls.manageBranchTitle": "Branch 변경 및 생성",
   "gitControls.manageBranchTitleWithDesc": "Branch 변경 및 생성 · {description}",
-  "gitControls.pullAria": "{branch} branch pull",
+  "gitControls.pullAria": "{branch} 브랜치 pull",
   "gitControls.pullTitle": "{branch} pull",
-  "gitControls.pushAria": "{branch} branch push",
+  "gitControls.pushAria": "{branch} 브랜치 push",
   "gitControls.pushTitle": "{branch} push",
   "gitControls.manageWorktreeAria": "{name} worktree 관리",
   "gitControls.manageWorktreeTitle": "Worktree 관리",
+  "gitControls.operationResultDialogTitle": "{label} 결과",
   // Fan-out group section
   "fanoutSection.groupsAria": "병렬 실행 그룹",
   "fanoutSection.openGroupAria": "병렬 그룹 열기: {title} · 실행 {run}",
@@ -2340,6 +2576,11 @@ const ko = {
   "git.branchNameRequired": "생성할 Git branch 이름을 입력해주세요.",
   "git.noBranchCreateResponse": "머신이 Git branch 생성 응답을 반환하지 않았습니다.",
   "git.branchCreateFailed": "Git branch 생성에 실패했습니다.",
+  "git.branchNameUnchanged": "바꿀 Git branch 이름이 지금과 같습니다.",
+  "git.noBranchRenameResponse": "머신이 Git branch 이름 변경 응답을 반환하지 않았습니다.",
+  "git.branchRenameFailed": "Git branch 이름 변경에 실패했습니다.",
+  "git.noBranchDeleteResponse": "머신이 Git branch 삭제 응답을 반환하지 않았습니다.",
+  "git.branchDeleteFailed": "Git branch 삭제에 실패했습니다.",
   "git.repoRootFailed": "Git 저장소 루트를 확인하지 못했습니다.",
   "git.worktreeCreateFailed": "Git worktree 생성에 실패했습니다.",
   "git.diffPathNotAllowed": "worktree diff 는 {segment} 하위 경로만 허용됩니다: {path}",
@@ -2507,6 +2748,25 @@ const ko = {
   "standalone.startFailed": "로컬 standalone 서버를 시작하지 못했습니다.",
   "workspace.loadFailed": "워크스페이스를 불러오지 못했습니다.",
   "standalone.modeStartFailed": "로컬 standalone 모드를 시작하지 못했습니다.",
+  "modeSwitch.toLocal": "로컬 전용 모드로 전환",
+  "modeSwitch.toCloud": "계정으로 돌아가기",
+  "standaloneImport.title": "로컬 전용 데이터 가져오기",
+  "standaloneImport.introBody": "이 컴퓨터의 로컬 전용(Standalone) 모드 데이터(프로젝트·대화 기록)를 지금 로그인한 계정으로 복사해요. 원본은 그대로 남아요.",
+  "standaloneImport.listOrderNotice": "가져온 대화 내용의 시각은 유지되지만, 세션 목록에서는 가져온 시점에 모여 보여요.",
+  "standaloneImport.start": "가져오기 시작",
+  "standaloneImport.later": "나중에",
+  "standaloneImport.close": "닫기",
+  "standaloneImport.running": "가져오는 중... ({completed}/{total} 세션)",
+  "standaloneImport.machineNotReady": "이 컴퓨터의 개인 머신 등록이 끝난 뒤 다시 시도해주세요.",
+  "standaloneImport.doneSummary": "프로젝트 {projects}개, 세션 {sessions}개를 가져왔어요.",
+  "standaloneImport.doneSkipped": "이미 가져온 세션 {count}개는 건너뛰었어요.",
+  "standaloneImport.undecryptable": "복호화할 수 없어 건너뛴 메시지가 {count}개 있어요.",
+  "standaloneImport.undecryptableMetadata": "세션 {count}개의 메타데이터 또는 에이전트 상태를 복호화하지 못해 일부 상태 없이 가져왔어요.",
+  "standaloneImport.failedProjects": "프로젝트 {count}개를 가져오지 못했어요. 가능한 세션은 프로젝트 연결 없이 가져왔어요.",
+  "standaloneImport.failedSessions": "세션 {count}개를 가져오지 못했어요. 다시 실행하면 이어서 시도해요.",
+  "standaloneImport.fatalError": "가져오기를 시작하지 못했어요: {error}",
+  "standaloneImport.settingsBody": "이 컴퓨터의 로컬 전용 모드 데이터를 현재 계정으로 복사해요.",
+  "standaloneImport.settingsOpen": "열기",
   // Workspace / project / file flow toasts + errors
   "workspace.contextSwitchFailed": "워크스페이스 컨텍스트를 전환하지 못했습니다.",
   "error.loginRequired": "로그인이 필요합니다.",
@@ -2659,6 +2919,8 @@ const ko = {
   "gitOp.failed": "{label} 실패",
   "gitOp.branchChanged": "Branch 변경 완료",
   "gitOp.branchCreated": "Branch 생성 완료",
+  "gitOp.branchRenamed": "Branch 이름 변경 완료",
+  "gitOp.branchDeleted": "Branch 삭제 완료",
   "worktreeOp.noGithub": "GitHub 저장소가 연결돼 있지 않습니다.",
   "worktreeOp.pushingBranch": "브랜치 푸시 중...",
   "worktreeOp.creatingPr": "Pull request 생성 중...",
@@ -2788,6 +3050,20 @@ const ko = {
   "preview.tokenUrlInvalid": "Preview 토큰 URL이 올바르지 않습니다.",
   "branchDialog.loading": "Branch 목록을 불러오는 중입니다.",
   "branchDialog.empty": "표시할 branch가 없습니다.",
+  "branchDialog.actionsAria": "{name} 브랜치 작업",
+  "branchDialog.rowAria": "{name} {meta}",
+  "branchDialog.switch": "브랜치 이동",
+  "branchDialog.rename": "브랜치 이름 변경",
+  "branchDialog.delete": "브랜치 삭제",
+  "branchDialog.switchConfirm": "'{name}' 브랜치로 이동할까요? 커밋되지 않은 변경이 있으면 Git이 거부할 수 있습니다.",
+  "branchDialog.switchConfirmAction": "이동",
+  "branchDialog.renameConfirm": "'{from}' 브랜치의 이름을 바꿀까요?",
+  "branchDialog.renamePlaceholder": "새 브랜치 이름",
+  "branchDialog.renameInputAria": "{from} 새 이름",
+  "branchDialog.renameConfirmAction": "이름 변경",
+  "branchDialog.deleteConfirm": "'{name}' 브랜치를 삭제할까요? 머지되지 않은 커밋이 있으면 Git이 거부합니다.",
+  "branchDialog.deleteConfirmAction": "삭제",
+  "branchDialog.cancel": "취소",
   "message.deleteConfirm": "이 메시지를 삭제할까요? 이 작업은 새로고침 후에도 유지됩니다.",
   "message.deleteFailed": "메시지를 삭제할 수 없습니다.",
   "message.sendFailed": "메시지를 보낼 수 없습니다.",
@@ -2805,7 +3081,7 @@ const ko = {
   "projectDelete.cancel": "취소",
   "projectDelete.confirm": "삭제",
   "projectDelete.deleting": "삭제 중…",
-  "projectCopy.eyebrow": "Organization project",
+  "projectCopy.eyebrow": "조직 프로젝트",
   "projectCopy.title": "프로젝트 복사",
   "projectCopy.description": "'{name}' 프로젝트를 내 프로젝트로 복사합니다.",
   "projectCopy.close": "프로젝트 복사 닫기",
@@ -2949,6 +3225,11 @@ const ko = {
   "askUser.customPlaceholder": "답을 입력하세요",
   "askUser.submitting": "제출 중...",
   "askUser.submit": "제출",
+  "conversationFilter.hideAutomated": "자동 실행 대화 숨기기",
+  "conversationFilter.showAutomated": "자동 실행 대화 보기",
+  "conversationFilter.hideAutomatedHint": "자동 리뷰·예약 자동화·GitHub 트리거가 실행한 대화를 목록에서 뺍니다.",
+  "conversationFilter.hiddenCount": "{count}개 숨김",
+  "conversationFilter.allHidden": "자동 실행 대화 {count}개만 있습니다. 보려면 필터를 끄세요.",
   "sessionsTab.hideArchived": "완료된 대화 숨기기",
   "sessionsTab.showArchived": "완료된 대화 보기",
   "sessionsTab.emptyBody": "모바일 앱처럼 프로젝트에 연결된 대화가 여기에 표시됩니다.",
@@ -2960,6 +3241,8 @@ const ko = {
   "sessionsTab.searchFailed": "사용자 프롬프트를 검색하지 못했습니다. 제목 검색 결과만 표시합니다.",
   "sessionsTab.noSearchResults": "“{query}”와 일치하는 대화가 없습니다.",
   "sessionsTab.clearSearch": "검색 지우기",
+  "sessionsTab.noVisibleMessage": "표시할 메시지가 아직 없습니다",
+  "sessionsTab.updated": "업데이트",
   // Planning / preview sidecar / preview tab
   "previewSidecar.closeAria": "Preview 닫기",
   "preview.serverStarting": "서버 시작 중...",
@@ -3013,6 +3296,29 @@ const ko = {
   "cloudMobileLogin.refresh": "새 QR 만들기",
   "systemPrompt.loadFailed": "설정을 불러오지 못했습니다.",
   "systemPrompt.saveFailed": "시스템 프롬프트를 저장하지 못했습니다.",
+  "saycodePromptPreference.dialogAria": "Saycode 지시 사용 설정",
+  "saycodePromptPreference.eyebrow": "에이전트 지시 선택",
+  "saycodePromptPreference.title": "Saycode 기본 지시를 사용할까요?",
+  "saycodePromptPreference.body": "내가 만든 Claude/Codex 스킬과 하네스를 그대로 쓰려면 꺼진 상태를 유지하세요. 나중에 환경설정에서 언제든 바꿀 수 있습니다.",
+  "saycodePromptPreference.keepOff": "꺼진 상태 유지",
+  "saycodePromptPreference.enable": "Saycode 지시 켜기",
+  "saycodePromptPreference.saving": "저장 중…",
+  "saycodePromptPreference.retryHint": "선택을 다시 눌러 저장을 재시도하세요.",
+  "saycodePromptPreference.settingsTitle": "Saycode 기본 지시",
+  "saycodePromptPreference.settingsEnable": "Saycode가 제공하는 기본 행동 지시 사용",
+  "saycodePromptPreference.settingsHelp": "사용자 시스템 프롬프트, 프로젝트 지침, 설치한 스킬과 하네스는 이 설정과 관계없이 유지됩니다.",
+  "saycodePromptPreference.blocksTitle": "개별 지시 선택",
+  "saycodePromptPreference.blocksHelp": "Saycode 지시를 항목별로 켜고 끕니다. 선택하지 않은 항목은 위의 전체 설정을 따릅니다.",
+  "saycodePromptPreference.alwaysOnNotice": "채팅 제목 생성은 항상 켜져 있으며 끌 수 없습니다. 채팅 목록에서 대화를 다시 찾으려면 필요합니다.",
+  "saycodePromptPreference.block.workerDelegation.label": "작업 위임",
+  "saycodePromptPreference.block.workerDelegation.description": "기계적인 작업을 저렴한 worker 에이전트에 넘기도록 지시합니다.",
+  "saycodePromptPreference.block.axBase.label": "기획부터 시작 워크플로우",
+  "saycodePromptPreference.block.axBase.description": "AX 워크플로우의 기본 지시를 사용합니다.",
+  "saycodePromptPreference.block.coAuthoredCredit.label": "커밋 크레딧",
+  "saycodePromptPreference.block.coAuthoredCredit.description": "커밋 메시지에 Claude와 Happy 공동 작성자 표시를 추가합니다.",
+  "saycodePromptPreference.block.inlinePreview.label": "결과물 인라인 미리보기",
+  "saycodePromptPreference.block.inlinePreview.description": "HTML 결과물을 만들면 답변 안에 미리보기를 띄우도록 지시합니다.",
+  "saycodePromptPreference.loading": "계정 설정을 불러오는 중…",
   "standalone.zrokStatus": "zrok 상태",
   "standalone.zrokNeeded": "zrok2 설정이 필요합니다",
   "standalone.zrokNeededBody": "다른 네트워크의 머신을 등록하려면 접속 가능한 서버 URL이 필요합니다.",
@@ -3240,6 +3546,8 @@ const ko = {
   "sidebarFiles.invalidName": '이름에 "/", "\\"를 쓰거나 "." 또는 ".."로 지을 수 없습니다.',
   "sidebarFiles.daemonTooOld": "이 머신의 Happy CLI가 오래되어 이름변경·복사본·삭제를 할 수 없습니다. 1.1.10-aplus.74 이상으로 업데이트하세요.",
   // ProjectDocumentViewer
+  "inlinePreview.openInViewer": "파일 뷰어로 열기",
+  "inlinePreview.loading": "미리보기를 불러오는 중",
   "documentViewer.docxConvertFailed": "DOCX 문서를 변환하지 못했습니다.",
   "documentViewer.pdfViewer": "{name} PDF 뷰어",
   "documentViewer.pdfPreparing": "PDF를 준비하는 중...",
@@ -3305,6 +3613,14 @@ const ko = {
   "fileDownload.tooLarge": "다운로드 파일은 100 MiB 이하만 지원합니다.",
   "codex.needsLatestCli": "GPT-5.6을 사용하려면 최신 Codex CLI가 필요합니다. `npm install -g @openai/codex@latest`로 업데이트한 뒤 새 대화를 시작해 주세요.",
   "codex.error": "Codex 오류: {detail}",
+  // specs/desktop-error-surface — 실패 알림의 계층 배지와 복구 액션
+  "errorSurface.layer.provider": "Provider 오류",
+  "errorSurface.layer.runtime": "런타임 오류",
+  "errorSurface.layer.auth": "인증 오류",
+  "errorSurface.retry": "다시 시도",
+  "errorSurface.retrying": "보내는 중…",
+  "errorSurface.retryFailed": "다시 보내지 못했습니다.",
+  "errorSurface.openCredentials": "내 AI 자격증명 열기",
   "fanout.slotCountRange": "병렬 실행 후보 수는 2~4개여야 합니다 (요청: {count}개).",
   "deployPlan.contractNotFound": "배포 실행 계약을 찾지 못했습니다",
   // Voice input
@@ -3366,6 +3682,8 @@ const ko = {
   "projectGitView.noRemote": "remote 없음",
   "projectGitView.branchSwitch": "Branch 변경",
   "projectGitView.branchCreate": "Branch 생성",
+  "projectGitView.branchRename": "Branch 이름 변경",
+  "projectGitView.branchDelete": "Branch 삭제",
   // Remote terminal + API client (non-hook)
   "terminal.connectTimeout": "터미널 연결 시간이 초과되었습니다.",
   "terminal.connectFailed": "터미널 연결에 실패했습니다.",
@@ -3376,7 +3694,7 @@ const ko = {
   // Merge with main: git-controls dropdown + worktree section
   "gitControls.branchMenu": "Branch 메뉴",
   "gitControls.branchMenuWithDesc": "Branch 메뉴 · {description}",
-  "gitControls.gitActionsAria": "{branch} git actions",
+  "gitControls.gitActionsAria": "{branch} git 작업",
   "gitControls.pullLabel": "가져오기 (pull)",
   "gitControls.pushLabel": "보내기 (push)",
   "gitControls.switchAria": "{branch} branch 전환",
@@ -3424,6 +3742,7 @@ const ko = {
   "settingsTab.security": "보안",
   "settingsTab.memory": "Memory",
   "settingsTab.connectors": "커넥터",
+  "settingsTab.myAiCredentials": "내 AI 계정",
   "settingsTab.extensions": "확장",
   "settingsTab.about": "정보",
   "settingsTab.shortcuts": "단축키",
@@ -3444,6 +3763,13 @@ const ko = {
   "extensions.confirmEnableAction": "권한 승인 및 활성화",
   "extensions.confirmUninstall": "이 확장과 설치된 파일을 제거할까요?",
   "extensions.shellUnavailable": "확장 관리는 최신 Desktop 앱에서 사용할 수 있습니다.",
+  "extensions.developerMode": "개발자 모드",
+  "extensions.developerModeHint": "압축을 풀어둔 확장 폴더를 불러옵니다. 무결성 검사만 면제되고 권한·격리는 그대로 적용됩니다.",
+  "extensions.loadUnpacked": "폴더 불러오기",
+  "extensions.unloadDevelopment": "내리기",
+  "extensions.developmentSource": "개발 빌드: {directory}",
+  "extensions.apiDeprecated": "업데이트 필요",
+  "extensions.apiDeprecatedHint": "이전 확장 API({apiVersion})로 동작 중이며, 다음 업데이트에서 지원이 끝납니다.",
   "extensions.runtime.inactive": "비활성",
   "extensions.runtime.active": "실행 중",
   "extensions.runtime.quarantined": "격리됨",
@@ -3537,10 +3863,12 @@ const ko = {
   "review.self.disabledWaiting": "먼저 대기 중인 질문이나 권한 요청에 응답해주세요.",
   "review.self.rounds": "반복 횟수",
   "review.self.roundsHint": "medium 이상 지적이 나오면 남은 횟수만큼 리뷰를 자동으로 이어갑니다. low·nit만 남으면 바로 끝냅니다.",
+  "review.self.appOpenHint": "앱이 실행 중일 때만 이어집니다. 앱을 완전히 종료하면 멈추고, 다시 열면 남은 횟수부터 이어갑니다.",
   "review.self.loopActive": "반복 리뷰 {round}/{total} 진행 중",
   "review.self.loopStop": "반복 중지",
   "review.self.loopDismiss": "기록 지우기",
   "review.self.loopDone": "반복 리뷰 종료 ({rounds}회) — {reason}",
+  "review.self.startCancelled": "다른 창의 작업으로 반복 리뷰 시작이 취소됐어요.",
   "review.self.loopReason.clean": "지적 없음",
   "review.self.loopReason.belowThreshold": "low·nit만 남아 조기 종료",
   "review.self.loopReason.roundsExhausted": "지정한 횟수를 모두 사용",
@@ -3648,7 +3976,7 @@ function isAskUserQuestionToolName(value2) {
   const normalized = value2.replace(/^functions\./i, "").replace(/^mcp__.+?__/i, "").replace(/\s+call$/i, "").replace(/[._\-\s]+/g, "").trim().toLowerCase();
   return normalized === "askuserquestion" || normalized === "requestuserinput" || normalized === "사용자에게질문";
 }
-function isRecord$4(value2) {
+function isRecord$5(value2) {
   return !!value2 && typeof value2 === "object" && !Array.isArray(value2);
 }
 function firstString(...values) {
@@ -3658,11 +3986,11 @@ function firstString(...values) {
   return void 0;
 }
 function recordValue(value2) {
-  if (isRecord$4(value2)) return value2;
+  if (isRecord$5(value2)) return value2;
   if (typeof value2 !== "string" || !value2.trim()) return void 0;
   try {
     const parsed = JSON.parse(value2);
-    return isRecord$4(parsed) ? parsed : void 0;
+    return isRecord$5(parsed) ? parsed : void 0;
   } catch {
     return void 0;
   }
@@ -3681,9 +4009,9 @@ function timestampValue(value2) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
 function normalizePendingPermissionEnvelope(requestId, value2) {
-  if (!isRecord$4(value2)) return null;
-  const nestedTool = isRecord$4(value2.tool) ? value2.tool : null;
-  const nestedFunction = nestedTool && isRecord$4(nestedTool.function) ? nestedTool.function : null;
+  if (!isRecord$5(value2)) return null;
+  const nestedTool = isRecord$5(value2.tool) ? value2.tool : null;
+  const nestedFunction = nestedTool && isRecord$5(nestedTool.function) ? nestedTool.function : null;
   const toolName = firstString(
     value2.name,
     value2.toolName,
@@ -3733,7 +4061,7 @@ function permissionKind(toolName) {
   return "generic";
 }
 function pendingPermissionRequestsFromState(state) {
-  if (!isRecord$4(state) || !isRecord$4(state.requests)) return [];
+  if (!isRecord$5(state) || !isRecord$5(state.requests)) return [];
   return Object.entries(state.requests).map(([requestId, value2]) => {
     const envelope = normalizePendingPermissionEnvelope(requestId, value2);
     const toolName = envelope?.toolName ?? "unknown";
@@ -3748,7 +4076,7 @@ function pendingPermissionRequestsFromState(state) {
   });
 }
 function agentControlledByUserFromState(state) {
-  return isRecord$4(state) && state.controlledByUser === true;
+  return isRecord$5(state) && state.controlledByUser === true;
 }
 function createChatState() {
   return { phase: "idle", pendingPermission: null };
@@ -4099,7 +4427,6 @@ const HELP_TEXT = `saycode — drive Saycode sessions across your machines from
 
 Usage
   saycode <command> [options]
-
 Commands
   (no arguments)                 Interactive browser: workspace -> machine ->
                                  project -> conversation, then open it
@@ -4117,7 +4444,6 @@ Commands
   login / logout                 Manage stored credentials
   agent <verb>                   For AI agents inside a Saycode session, not
                                  for people — see \`saycode agent whoami\`
-
 Options
   -w, --workspace <id|name> Workspace to act in (see \`saycode workspaces\`)
   -m, --machine <id|host>   Machine id prefix or hostname substring
@@ -4145,7 +4471,10 @@ Agent commands (machine-readable JSON on stdout, exit 3 on failure)
   agent read <session> [--last n]        Recent messages + completion signal
   agent wait <session> --until <state>   turn-end | waiting-input | completed
   agent prompt <session> <text> [--wait] Send a prompt, optionally wait for it
+  agent steer <session> <text>        Redirect an owned child's active response
+  agent stop <session>                Stop an owned child's active response
   agent spawn --prompt <text> [--agent n]  Start a sibling in the same directory
+  agent spawn --prompt <text> --file <path>  ...with context files it reads first
   Only works inside a session Saycode started (SAYCODE_AGENT_ENV).
 
 Workspaces
@@ -6528,6 +6857,21 @@ function decryptJsonWithCandidates(blob, keys) {
   decryptCacheSet(blob, keys, null);
   return null;
 }
+function buildUserTextMessageContent(input) {
+  return {
+    role: "user",
+    content: { type: "text", text: input.text },
+    meta: {
+      permissionMode: "bypassPermissions",
+      saycodeSystemPromptEnabled: input.saycodeSystemPromptEnabled ?? true,
+      ...input.saycodePromptBlocks && Object.keys(input.saycodePromptBlocks).length > 0 ? { saycodePromptBlocks: input.saycodePromptBlocks } : {},
+      ...input.model && input.model !== "default" ? { model: input.model } : {},
+      ...input.effort ? { effort: input.effort } : {},
+      ...input.autoRoute ? { autoRoute: input.autoRoute } : {},
+      ...input.appendSystemPrompt !== void 0 ? { appendSystemPrompt: input.appendSystemPrompt } : {}
+    }
+  };
+}
 const CONNECTOR_PROVIDER_IDS = [
   "notion",
   "slack",
@@ -6576,6 +6920,9 @@ function aiCredentialsPath(companyId, bundleId, action) {
 function personalMachinesPath(companyId) {
   return `/api/admin/companies/${encodeURIComponent(companyId)}/personal-machines`;
 }
+function myMachinesPath(companyId) {
+  return `/api/admin/companies/${encodeURIComponent(companyId)}/my-machines`;
+}
 function record$1(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 }
@@ -6692,6 +7039,20 @@ function parseAiCredentialBatchResult(value2) {
     warnings: array(body.warnings).filter((warning) => typeof warning === "string")
   };
 }
+function parseSelfServiceMachines(value2) {
+  return array(record$1(value2).machines).map((entry) => {
+    const row2 = record$1(entry);
+    return {
+      machineId: str(row2.machineId),
+      type: row2.type === "shared" ? "shared" : "personal",
+      displayName: typeof row2.displayName === "string" ? row2.displayName : null,
+      host: typeof row2.host === "string" ? row2.host : null,
+      workspaceRoot: typeof row2.workspaceRoot === "string" ? row2.workspaceRoot : null,
+      registeredAt: num(row2.registeredAt),
+      online: typeof row2.online === "boolean" ? row2.online : null
+    };
+  }).filter((machine) => machine.machineId !== "");
+}
 function parsePersonalMachines(value2) {
   return array(record$1(value2).machines).map((entry) => {
     const row2 = record$1(entry);
@@ -6764,7 +7125,7 @@ function buildOpenConversationsPath(input) {
   if (input.cursor) params.set("cursor", input.cursor);
   return `/api/me/open-conversations?${params.toString()}`;
 }
-function isRecord$3(value2) {
+function isRecord$4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function normalizedOptionalText(value2, maxLength) {
@@ -6772,7 +7133,7 @@ function normalizedOptionalText(value2, maxLength) {
   return value2.trim().slice(0, maxLength) || null;
 }
 function parseCard(value2) {
-  if (!isRecord$3(value2)) return null;
+  if (!isRecord$4(value2)) return null;
   if (typeof value2.sessionId !== "string" || typeof value2.projectId !== "string" || typeof value2.title !== "string" || typeof value2.projectName !== "string" || value2.branch !== null && typeof value2.branch !== "string" || value2.agent !== null && typeof value2.agent !== "string" || typeof value2.updatedAt !== "number" || !Number.isFinite(value2.updatedAt) || typeof value2.serverActive !== "boolean" || typeof value2.workspaceCompleted !== "boolean") return null;
   const sessionId = value2.sessionId.trim();
   const projectId = value2.projectId.trim();
@@ -6801,7 +7162,7 @@ function parseRows(value2, limit) {
   return rows;
 }
 function parseOpenConversationsPayload(value2) {
-  if (!isRecord$3(value2)) throw new Error("Invalid open conversations response");
+  if (!isRecord$4(value2)) throw new Error("Invalid open conversations response");
   if (!Array.isArray(value2.activeCandidates) || !Array.isArray(value2.recent) || typeof value2.truncated !== "boolean" || !(value2.nextCursor === null || typeof value2.nextCursor === "string" && value2.nextCursor.length > 0 && value2.nextCursor.length <= MAX_CURSOR_LENGTH$1)) throw new Error("Invalid open conversations response");
   const rawActive = value2.activeCandidates;
   const rawRecent = value2.recent;
@@ -6876,7 +7237,7 @@ function buildProjectConversationsPath(projectId) {
   if (!trimmed) throw new Error("Invalid project id");
   return `/api/v2/projects/${encodeURIComponent(trimmed)}/conversations`;
 }
-function isRecord$2(value2) {
+function isRecord$3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function nullableString$2(value2) {
@@ -6889,7 +7250,7 @@ function stringArray(value2) {
   return Array.isArray(value2) ? value2.filter((entry) => typeof entry === "string") : [];
 }
 function promptSuggestion(value2) {
-  if (!isRecord$2(value2)) return null;
+  if (!isRecord$3(value2)) return null;
   const text2 = value2.text;
   const provider2 = value2.provider;
   const updatedAt = value2.updatedAt;
@@ -6897,7 +7258,7 @@ function promptSuggestion(value2) {
   return { text: text2, provider: provider2, updatedAt };
 }
 function parseRow(value2) {
-  if (!isRecord$2(value2)) return null;
+  if (!isRecord$3(value2)) return null;
   if (typeof value2.id !== "string" || !value2.id.trim() || typeof value2.title !== "string" || typeof value2.active !== "boolean" || typeof value2.agentStateBusy !== "boolean" || typeof value2.workspaceCompleted !== "boolean" || typeof value2.hydrated !== "boolean") return null;
   return {
     id: value2.id,
@@ -6925,7 +7286,7 @@ function parseRow(value2) {
   };
 }
 function parseProjectConversationsPayload(value2) {
-  if (!isRecord$2(value2)) throw new Error("Invalid project conversations response");
+  if (!isRecord$3(value2)) throw new Error("Invalid project conversations response");
   if (typeof value2.projectId !== "string" || !Array.isArray(value2.conversations) || typeof value2.partial !== "boolean" || typeof value2.truncated !== "boolean") throw new Error("Invalid project conversations response");
   const conversations = [];
   for (const raw of value2.conversations.slice(0, MAX_MAPPING_COUNT)) {
@@ -6944,7 +7305,7 @@ function parseProjectConversationsPayload(value2) {
 const COMPANY_MEMBER_DIRECTORY_PAGE_LIMIT = 100;
 const MAX_PROJECT_MEMBER_COUNT = 1e3;
 const MAX_CURSOR_LENGTH = 2048;
-function isRecord$1(value2) {
+function isRecord$2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function nullableString$1(value2) {
@@ -6952,11 +7313,11 @@ function nullableString$1(value2) {
 }
 function parseAvatar(value2) {
   if (value2 === null) return null;
-  if (!isRecord$1(value2) || typeof value2.path !== "string" || typeof value2.url !== "string") return void 0;
+  if (!isRecord$2(value2) || typeof value2.path !== "string" || typeof value2.url !== "string") return void 0;
   return { path: value2.path, url: value2.url };
 }
 function parseProjectMember(value2) {
-  if (!isRecord$1(value2)) return null;
+  if (!isRecord$2(value2)) return null;
   const username = nullableString$1(value2.username);
   const firstName = nullableString$1(value2.firstName);
   const lastName = nullableString$1(value2.lastName);
@@ -6976,7 +7337,7 @@ function parseProjectMember(value2) {
   };
 }
 function parseProjectMembersPayload(value2) {
-  if (!isRecord$1(value2) || !Array.isArray(value2.members)) {
+  if (!isRecord$2(value2) || !Array.isArray(value2.members)) {
     throw new Error("Invalid project members response");
   }
   if (value2.members.length > MAX_PROJECT_MEMBER_COUNT) {
@@ -6989,7 +7350,7 @@ function parseProjectMembersPayload(value2) {
   });
 }
 function parseDirectoryEntry(value2) {
-  if (!isRecord$1(value2)) return null;
+  if (!isRecord$2(value2)) return null;
   const email = nullableString$1(value2.email);
   const displayName = nullableString$1(value2.displayName);
   if (typeof value2.accountId !== "string" || !value2.accountId.trim() || typeof value2.username !== "string" || !value2.username.trim() || email === void 0 || displayName === void 0) return null;
@@ -7010,8 +7371,8 @@ function buildCompanyMemberDirectoryPath(companyId, cursor) {
   return `/api/companies/${encodeURIComponent(trimmedCompanyId)}/member-directory?${params.toString()}`;
 }
 function parseCompanyMemberDirectoryPage(value2) {
-  const rawItems = Array.isArray(value2) ? value2 : isRecord$1(value2) && Array.isArray(value2.items) ? value2.items : null;
-  const rawCursor = Array.isArray(value2) ? null : isRecord$1(value2) ? value2.nextCursor : void 0;
+  const rawItems = Array.isArray(value2) ? value2 : isRecord$2(value2) && Array.isArray(value2.items) ? value2.items : null;
+  const rawCursor = Array.isArray(value2) ? null : isRecord$2(value2) ? value2.nextCursor : void 0;
   if (!rawItems || rawItems.length > COMPANY_MEMBER_DIRECTORY_PAGE_LIMIT || !(rawCursor === null || typeof rawCursor === "string" && rawCursor.length > 0 && rawCursor.length <= MAX_CURSOR_LENGTH)) {
     if (rawItems && rawItems.length > COMPANY_MEMBER_DIRECTORY_PAGE_LIMIT) {
       throw new Error("Company member directory response is too large");
@@ -15444,7 +15805,7 @@ function branchSlugFromMetadata(metadata) {
 function stringField(value2) {
   return typeof value2 === "string" && value2.trim() ? value2.trim() : void 0;
 }
-function isRecord(value2) {
+function isRecord$1(value2) {
   return !!value2 && typeof value2 === "object" && !Array.isArray(value2);
 }
 function numberField(value2) {
@@ -15471,7 +15832,7 @@ function firstTokenCount(...values) {
   return void 0;
 }
 function coerceTokenUsageRecord(value2, allowGenericKeys = true) {
-  if (!isRecord(value2)) return void 0;
+  if (!isRecord$1(value2)) return void 0;
   const inputTokens = firstTokenCount(
     value2.inputTokens,
     value2.input_tokens,
@@ -15534,7 +15895,7 @@ function coerceSessionTokenUsage(...sources) {
   for (const source of sources) {
     const direct = coerceTokenUsageRecord(source, false);
     if (direct) return direct;
-    if (!isRecord(source)) continue;
+    if (!isRecord$1(source)) continue;
     for (const key of usageKeys) {
       const nested = coerceTokenUsageRecord(source[key]);
       if (nested) return nested;
@@ -15546,7 +15907,7 @@ function pullRequestStateField(value2) {
   return value2 === "open" || value2 === "closed" || value2 === "merged" ? value2 : void 0;
 }
 function coercePendingAskUserQuestionRequest(requestId, value2) {
-  if (!isRecord(value2)) return null;
+  if (!isRecord$1(value2)) return null;
   const envelope = normalizePendingPermissionEnvelope(requestId, value2);
   if (!envelope || !isAskUserQuestionToolName(envelope.toolName)) return null;
   const name = envelope.toolName;
@@ -15563,7 +15924,7 @@ function apiSessionAgentStatePendingAskUserQuestion(agentState, candidateKeys) {
   const state = decryptJsonWithCandidates(agentState, candidateKeys);
   if (!state) return null;
   const requests = state.requests;
-  if (!isRecord(requests)) return null;
+  if (!isRecord$1(requests)) return null;
   for (const [requestId, request] of Object.entries(requests)) {
     const pending = coercePendingAskUserQuestionRequest(requestId, request);
     if (pending) return pending;
@@ -15587,7 +15948,7 @@ function coercePendingExitPlanModeRequest(requestId, value2) {
 function apiSessionAgentStatePendingExitPlanMode(agentState, candidateKeys) {
   if (!agentState) return null;
   const state = decryptJsonWithCandidates(agentState, candidateKeys);
-  if (!state || !isRecord(state.requests)) return null;
+  if (!state || !isRecord$1(state.requests)) return null;
   for (const [requestId, request] of Object.entries(state.requests)) {
     const pending = coercePendingExitPlanModeRequest(requestId, request);
     if (pending) return pending;
@@ -15633,7 +15994,7 @@ function optionalTimestamp(value2) {
   return parsed > 0 ? parsed : void 0;
 }
 function coercePromptSuggestion(value2) {
-  if (!isRecord(value2)) return void 0;
+  if (!isRecord$1(value2)) return void 0;
   const text2 = nonEmptyString(value2.text);
   const provider2 = nonEmptyString(value2.provider);
   const updatedAt = optionalTimestamp(value2.updatedAt);
@@ -15641,7 +16002,7 @@ function coercePromptSuggestion(value2) {
   return { text: text2, provider: provider2, updatedAt };
 }
 function coerceCreatedBy(value2) {
-  if (!isRecord(value2)) return void 0;
+  if (!isRecord$1(value2)) return void 0;
   const accountId = nonEmptyString(value2.accountId);
   if (!accountId) return void 0;
   const displayName = nonEmptyString(value2.displayName);
@@ -15672,6 +16033,7 @@ function apiSessionToSession(api, candidateKeys, existing) {
   const archiveReason = nonEmptyString(metadata?.archiveReason) ?? existing?.archiveReason;
   const createdBy = coerceCreatedBy(metadata?.createdBy) ?? existing?.createdBy;
   const branchSlug = branchSlugFromMetadata(metadata) ?? existing?.branchSlug;
+  const path = nonEmptyString(metadata?.path) ?? existing?.path;
   const promptSuggestion2 = metadata && Object.prototype.hasOwnProperty.call(metadata, "promptSuggestion") ? coercePromptSuggestion(metadata.promptSuggestion) : existing?.promptSuggestion;
   return {
     ...existing,
@@ -15707,6 +16069,7 @@ function apiSessionToSession(api, candidateKeys, existing) {
     ...archiveReason ? { archiveReason } : {},
     ...createdBy ? { createdBy } : {},
     ...branchSlug ? { branchSlug } : {},
+    ...path ? { path } : {},
     ...sessionFilesystemScopePatch(metadata, existing),
     ...remoteThinking === null ? {} : { agentStateBusy: remoteThinking }
   };
@@ -15740,11 +16103,15 @@ function readMcpCallerGrantPublicKey(daemonState) {
   const value2 = daemonState.mcpCallerGrantPublicKey;
   return typeof value2 === "string" && value2 ? value2 : void 0;
 }
-function buildWorktreeMutationBody(input) {
+function buildWorktreeMutationBody(input, options = {}) {
   return JSON.stringify(Object.fromEntries(
-    Object.entries(input).filter(([, value2]) => typeof value2 === "string" && value2.length > 0)
+    Object.entries(input).filter(([key, value2]) => (key !== "machinePlatform" || options.includeMachinePlatform) && (typeof value2 === "string" && (value2.length > 0 || key === "branch") || key === "branch" && value2 === null))
   ));
 }
+const STANDALONE_USER_ID = "standalone-local";
+function isStandaloneAuthSession(session) {
+  return session?.userId === STANDALONE_USER_ID;
+}
 function indexMachineRegistry(entries) {
   const byId = {};
   for (const entry of entries) {
@@ -15809,6 +16176,17 @@ function resolvedProjectPreviewRelayUrl(input) {
   }
   return `${input.syncBaseUrl}/v1/preview/${encodeURIComponent(input.machineId)}/${input.port}/?ptoken=${encodeURIComponent(response.token)}`;
 }
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function versionedAutomationBase64(value2, maxBytes, exactBytes) {
+  if (typeof value2 !== "string" || !value2 || value2.length > Math.ceil(maxBytes / 3) * 4 || !BASE64_PATTERN.test(value2)) {
+    throw new Error("automation-response-invalid");
+  }
+  const decoded = Buffer$1.from(value2, "base64");
+  if (decoded.length < 41 || decoded.length > maxBytes || exactBytes !== void 0 && decoded.length !== exactBytes || decoded[0] !== 1) {
+    throw new Error("automation-response-invalid");
+  }
+  return value2;
+}
 function row(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("automation-response-invalid");
   return value2;
@@ -15830,10 +16208,23 @@ function nullableInteger(value2) {
 function optionalNullableInteger(value2) {
   return value2 === void 0 ? null : nullableInteger(value2);
 }
-function parseServerAutomationPublic(value2) {
+function parseRuntimeState(value2) {
   const item = row(value2);
-  if (item.payloadVersion !== 1 || typeof item.paused !== "boolean") throw new Error("automation-response-invalid");
   return {
+    automationId: stringValue(item.automationId),
+    generation: integer(item.generation, 1),
+    stateVersion: integer(item.stateVersion, 1),
+    stateCiphertext: versionedAutomationBase64(item.stateCiphertext, 96 * 1024),
+    viewerKeyVersion: integer(item.viewerKeyVersion, 1),
+    viewerKeyEnvelope: versionedAutomationBase64(item.viewerKeyEnvelope, 105, 105),
+    machineKeyVersion: integer(item.machineKeyVersion, 1),
+    updatedAt: integer(item.updatedAt)
+  };
+}
+function parseServerAutomationPublic(value2) {
+  const item = row(value2);
+  if (item.payloadVersion !== 1 && item.payloadVersion !== 2 || typeof item.paused !== "boolean") throw new Error("automation-response-invalid");
+  const parsed = {
     id: stringValue(item.id),
     projectId: stringValue(item.projectId),
     ownerAccountId: stringValue(item.ownerAccountId),
@@ -15841,7 +16232,7 @@ function parseServerAutomationPublic(value2) {
     machineId: nullableString(item.machineId),
     revision: integer(item.revision, 1),
     generation: integer(item.generation, 1),
-    payloadVersion: 1,
+    payloadVersion: item.payloadVersion,
     payloadCiphertext: stringValue(item.payloadCiphertext),
     viewerKeyId: stringValue(item.viewerKeyId),
     viewerKeyVersion: integer(item.viewerKeyVersion, 1),
@@ -15853,8 +16244,13 @@ function parseServerAutomationPublic(value2) {
     appliedRevision: integer(item.appliedRevision),
     appliedAt: nullableInteger(item.appliedAt),
     createdAt: integer(item.createdAt),
-    updatedAt: integer(item.updatedAt)
+    updatedAt: integer(item.updatedAt),
+    runtimeState: item.runtimeState === void 0 || item.runtimeState === null ? null : parseRuntimeState(item.runtimeState)
   };
+  if (parsed.payloadVersion === 2 !== (parsed.runtimeState !== null) || parsed.runtimeState && (parsed.runtimeState.automationId !== parsed.id || parsed.runtimeState.generation !== parsed.generation || parsed.runtimeState.viewerKeyVersion !== parsed.viewerKeyVersion || parsed.runtimeState.machineKeyVersion !== parsed.machineKeyVersion)) {
+    throw new Error("automation-response-invalid");
+  }
+  return parsed;
 }
 function parseServerAutomationAdoption(value2) {
   const item = row(value2);
@@ -15875,11 +16271,12 @@ function parseServerAutomationTarget(value2) {
     machinePublicKey: stringValue(item.machinePublicKey),
     machineKeyVersion: integer(item.machineKeyVersion, 1),
     viewerPublicKey: nullableString(item.viewerPublicKey),
-    viewerKeyVersion: integer(item.viewerKeyVersion)
+    viewerKeyVersion: integer(item.viewerKeyVersion),
+    automationProtocolVersion: item.automationProtocolVersion === void 0 ? 1 : integer(item.automationProtocolVersion, 1)
   };
 }
 const RUN_STATUSES = /* @__PURE__ */ new Set(["CLAIMED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED", "ABANDONED"]);
-const RUN_OUTCOMES = /* @__PURE__ */ new Set(["WOKE", "SILENT", "SKIPPED_GATE", "ERROR"]);
+const RUN_OUTCOMES = /* @__PURE__ */ new Set(["WOKE", "SILENT", "SKIPPED_GATE", "NO_CHANGE", "ERROR"]);
 function parseServerAutomationRun(value2) {
   const item = row(value2);
   if (!RUN_STATUSES.has(item.status) || item.outcome !== null && !RUN_OUTCOMES.has(item.outcome) || typeof item.lateReport !== "boolean") throw new Error("automation-response-invalid");
@@ -16135,6 +16532,7 @@ function normalizeAutomationSupport(value2) {
   return {
     rpcAvailable: capability.rpcAvailable,
     serverBacked: capability.serverBacked === true,
+    ...typeof capability.monitorMode === "boolean" ? { monitorMode: capability.monitorMode } : {},
     ...Number.isSafeInteger(capability.keyVersion) && capability.keyVersion > 0 ? { keyVersion: capability.keyVersion } : {}
   };
 }
@@ -16178,7 +16576,8 @@ class ApiClient {
       apiBaseUrl: session.apiBaseUrl,
       syncBaseUrl: session.happyBaseUrl,
       apiToken: session.token,
-      syncToken: session.syncToken || session.token
+      syncToken: session.syncToken || session.token,
+      standalone: isStandaloneAuthSession(session)
     });
   }
   async login(input) {
@@ -16770,9 +17169,25 @@ class ApiClient {
       throw error;
     }
   }
-  async ensureHappyProjectMachineBinding(projectId, machineId) {
-    const path = `/v1/projects/${encodeURIComponent(projectId)}`;
-    const data = await this.request(path, { boundary: "sync" });
+  /**
+   * 자동화·GitHub 트리거가 요구하는 두 전제를 멱등하게 맞춘다: happy 미러
+   * 행이 존재할 것, 그리고 그 행의 `config.machineId` 가 대상 머신일 것.
+   *
+   * A+ 는 프로젝트를 자기 DB 에 만들고 happy 미러는 일부 경로에서만 만든다.
+   * 미러가 없으면 아래 GET 이 404 `project-not-found` 로 죽어 데스크톱의
+   * 자동화 화면이 통째로 막혔다 — 그 404 를 여기서 생성으로 흡수한다.
+   * 정상 경로(미러 존재)는 기존과 같이 GET 한 번으로 끝난다.
+   */
+  async ensureHappyProjectMachineBinding(input) {
+    const { project: source, machineId } = input;
+    const path = `/v1/projects/${encodeURIComponent(source.id)}`;
+    let data;
+    try {
+      data = await this.request(path, { boundary: "sync" });
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 404) throw error;
+      data = await this.createHappyProjectMirror(source, machineId);
+    }
     if (!data.project || typeof data.project !== "object" || Array.isArray(data.project)) {
       throw new Error("happy-project-response-invalid");
     }
@@ -16788,6 +17203,34 @@ class ApiClient {
       body: JSON.stringify({ config: { ...config, machineId } })
     });
   }
+  /**
+   * happy 의 projectCreate 는 `config` 를 그대로 받아 응답에 되돌려주므로,
+   * 신규 생성이면 호출부의 바인딩 조정이 즉시 끝나 왕복이 하나로 마무리된다.
+   * 응답을 그대로 돌려주는 이유는 호출부 주석 참고 — 이 연산은 멱등이라
+   * 남이 만든 미러를 돌려줄 수도 있어서 응답을 믿고 건너뛰면 안 된다.
+   *
+   * 409 는 같은 id 를 다른 happy 계정이 쥐고 있다는 뜻이라 이 클라이언트에서
+   * 고칠 수 없다 — 조용히 넘기면 자동화 화면이 원인 없는 404 를 계속
+   * 보여주므로 그대로 올린다.
+   */
+  async createHappyProjectMirror(source, machineId) {
+    const body = { id: source.id, name: source.name };
+    if (typeof source.description === "string") body.description = source.description;
+    if (typeof source.color === "string") body.color = source.color;
+    body.config = { machineId };
+    try {
+      return await this.request("/v1/projects", {
+        method: "POST",
+        boundary: "sync",
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 409) {
+        throw new Error("happy-project-id-taken");
+      }
+      throw error;
+    }
+  }
   async getProjectMembers(projectId) {
     const data = await this.request(
       `/v1/projects/${encodeURIComponent(projectId)}/members`,
@@ -17213,7 +17656,7 @@ class ApiClient {
       {
         method: "POST",
         boundary: "api",
-        body: buildWorktreeMutationBody(input)
+        body: buildWorktreeMutationBody(input, { includeMachinePlatform: this.config.standalone })
       }
     );
     return data.worktree;
@@ -17304,6 +17747,44 @@ class ApiClient {
       tokenOverride
     });
   }
+  /**
+   * 복호화 없이 원본 행을 전량 — import 파이프가 metadata 블롭을 재암호화할 때 쓴다.
+   * /v1/sessions 는 150건에서 잘리므로 /v2 커서 페이지네이션으로 끝까지 걷는다
+   * (조용한 절단은 "일부만 이관됐는데 성공으로 보이는" 최악의 실패를 만든다).
+   */
+  async fetchApiSessions(tokenOverride) {
+    const all = [];
+    let cursor = null;
+    for (; ; ) {
+      const params = new URLSearchParams({ limit: "200" });
+      if (cursor) params.set("cursor", cursor);
+      const data = await this.request(`/v2/sessions?${params.toString()}`, { boundary: "sync", tokenOverride });
+      all.push(...data.sessions ?? []);
+      if (data.hasNext !== true || !data.nextCursor || data.nextCursor === cursor) break;
+      cursor = data.nextCursor;
+    }
+    return all;
+  }
+  /**
+   * 라이브 CLI 없이 세션 행만 만든다 (specs/desktop-standalone-cloud-import).
+   * 서버는 (accountId, tag) 기준 get-or-create라 같은 tag 재호출은 기존 세션을 돌려준다.
+   * dataEncryptionKey 를 null 로 둬 legacy secretbox(계정 시드) 경로로 통일한다 —
+   * 데스크탑의 encode/decodeMessageContent 가 읽고 쓸 수 있는 유일한 변형이다.
+   */
+  async createRawSession(input, tokenOverride) {
+    const data = await this.request("/v1/sessions", {
+      method: "POST",
+      boundary: "sync",
+      tokenOverride,
+      body: JSON.stringify({
+        tag: input.tag,
+        metadata: input.metadata,
+        agentState: input.agentState ?? null,
+        dataEncryptionKey: null
+      })
+    });
+    return data.session;
+  }
   async getGithubPatStatus(tokenOverride) {
     const raw = await this.request(
       "/v1/connect/github-pat/status",
@@ -17436,17 +17917,7 @@ class ApiClient {
   async sendUserTextMessage(input) {
     const localId = input.localId || `desktop-${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const key = input.secretBase64 ? decodeBase64(input.secretBase64) : null;
-    const content = {
-      role: "user",
-      content: { type: "text", text: input.text },
-      meta: {
-        permissionMode: "bypassPermissions",
-        ...input.model && input.model !== "default" ? { model: input.model } : {},
-        ...input.effort ? { effort: input.effort } : {},
-        ...input.autoRoute ? { autoRoute: input.autoRoute } : {},
-        ...input.appendSystemPrompt ? { appendSystemPrompt: input.appendSystemPrompt } : {}
-      }
-    };
+    const content = buildUserTextMessageContent(input);
     const encoded = encodeMessageContent(content, key);
     const result = await this.sendMessages(input.sessionId, [{ localId, content: encoded }], input.tokenOverride);
     return { localId, sentSeq: result.messages?.[0]?.seq };
@@ -17951,6 +18422,17 @@ class ApiClient {
       { boundary: "api" }
     ));
   }
+  /**
+   * personal-credential-set-apply — owner/admin 이 아닌 일반 멤버도 호출 가능.
+   * 서버가 이미 배포 자격(개인 머신 + 본인이 등록한 이 회사의 공용 머신)
+   * 으로 필터링해 돌려준다.
+   */
+  async getMyMachines(companyId) {
+    return parseSelfServiceMachines(await this.request(
+      myMachinesPath(companyId),
+      { boundary: "api" }
+    ));
+  }
   async getCompanyAiCredentials(companyId) {
     return parseAiCredentialVaultSnapshot(await this.request(
       aiCredentialsPath(companyId),
@@ -18063,11 +18545,20 @@ function credentialSearchPaths(input) {
   }
   return [
     { source: "saycode", path: joinPath(input.homeDir, ".saycode", "credentials.v1.json") },
-    { source: "happy", path: joinPath(input.homeDir, ".happy", "access.key") },
-    { source: "happy_remote", path: joinPath(input.homeDir, ".happy_remote", "access.key") },
-    { source: "happy_local", path: joinPath(input.homeDir, ".happy_local", "access.key") }
+    ...happyHomeOrder(input).map((source) => ({
+      source,
+      path: joinPath(input.homeDir, `.${source}`, "access.key")
+    }))
   ];
 }
+function happyHomeOrder(input) {
+  const homes = CREDENTIAL_SOURCE_ORDER.filter((source) => source !== "saycode");
+  const runtimeHome = input.env.HAPPY_HOME_DIR?.trim();
+  if (!runtimeHome) return [...homes];
+  const runtime = homes.find((source) => joinPath(input.homeDir, `.${source}`) === joinPath(runtimeHome));
+  if (!runtime) return [...homes];
+  return [runtime, ...homes.filter((source) => source !== runtime)];
+}
 function selectFirstValidCredential(candidates, readFile2) {
   for (const candidate of candidates) {
     const raw = readFile2(candidate.path);
@@ -18397,6 +18888,12 @@ class CliRest {
     if (!apiToken) throw new ApiUnavailableError();
     return this.request(path, { method: "GET" }, apiToken);
   }
+  async listProjectWorktrees(projectId) {
+    const data = await this.api(
+      `/api/projects/${encodeURIComponent(projectId)}/worktrees`
+    );
+    return data.worktrees ?? [];
+  }
   async createProjectWorktree(projectId, input) {
     const data = await this.apiMutation(
       `/api/projects/${encodeURIComponent(projectId)}/worktrees`,
@@ -19790,6 +20287,22 @@ class ChatInputController {
     this.readline.off("close", this.handleClose);
   }
 }
+const MACOS_FIRMLINK_ALIASES = [
+  ["/tmp", "/private/tmp"],
+  ["/var", "/private/var"],
+  ["/etc", "/private/etc"]
+];
+function canonicalizeMacOsFirmlinkAlias(path) {
+  for (const [logical, physical] of MACOS_FIRMLINK_ALIASES) {
+    if (path === logical) return physical;
+    if (path.startsWith(`${logical}/`)) return physical + path.slice(logical.length);
+  }
+  return path;
+}
+function canonicalizeRemotePathForComparison(value2, platform2) {
+  const normalized = value2.trim().replace(/\/+$/, "");
+  return platform2 === "darwin" ? canonicalizeMacOsFirmlinkAlias(normalized) : normalized;
+}
 function worktreeTargetMismatch(record2, expected) {
   if (record2.projectId !== expected.projectId) return "project";
   if (record2.machineId !== expected.machineId) return "machine";
@@ -19847,32 +20360,15 @@ function resolveWorktreeName(input) {
 }
 const MANAGED_WORKTREE_SEGMENT = "/.aplus/worktrees/";
 const MAX_MANAGED_WORKTREE_DEPTH = 2;
-function isWorktreePathWithinProjectRoot(projectRoot, worktreePath) {
-  const root = projectRoot.trim().replace(/\/+$/, "");
-  const path = worktreePath.trim().replace(/\/+$/, "");
+function isWorktreePathWithinProjectRoot(projectRoot, worktreePath, platform2) {
+  const root = canonicalizeRemotePathForComparison(projectRoot, platform2);
+  const path = canonicalizeRemotePathForComparison(worktreePath, platform2);
   if (!root || !path) return false;
   if (!path.startsWith(`${root}${MANAGED_WORKTREE_SEGMENT}`)) return false;
   const segments = path.slice(root.length + MANAGED_WORKTREE_SEGMENT.length).split("/");
   if (segments.length < 1 || segments.length > MAX_MANAGED_WORKTREE_DEPTH) return false;
   return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
-async function createWorktreeOnMachine(input) {
-  const record2 = await input.client.createProjectWorktree(input.projectId, {
-    name: input.name,
-    baseRef: input.baseRef,
-    machineId: input.machineId,
-    ...input.confirmRepoRoot ? { confirmRepoRoot: input.confirmRepoRoot } : {}
-  });
-  const targetMismatch = worktreeTargetMismatch(record2, {
-    projectId: input.projectId,
-    machineId: input.machineId
-  });
-  const allowedRoot = input.confirmRepoRoot ?? input.repoCwd;
-  const pathMatches = isWorktreePathWithinProjectRoot(allowedRoot, record2.path);
-  if (!targetMismatch && pathMatches) return record2;
-  await input.client.deleteProjectWorktree(input.projectId, record2.id, true).catch(() => void 0);
-  throw new Error(!pathMatches && input.pathMismatchMessage ? input.pathMismatchMessage(record2.path) : input.targetMismatchMessage);
-}
 const WORKTREE_SUBDIR_CONFIRM_CODE = "worktree-subdir-confirm-required";
 function trimmedString(value2) {
   if (typeof value2 !== "string") return null;
@@ -19912,6 +20408,23 @@ function parseWorktreeSubdirConfirmRequest(status, body, projectRoot) {
   if (!isSafeRelativeDir(repoRelativeDir)) return null;
   return { repoRoot, workspaceDir, repoRelativeDir };
 }
+async function createWorktreeOnMachine(input) {
+  const record2 = await input.client.createProjectWorktree(input.projectId, {
+    name: input.name,
+    baseRef: input.baseRef,
+    machineId: input.machineId,
+    ...input.confirmRepoRoot ? { confirmRepoRoot: input.confirmRepoRoot } : {}
+  });
+  const targetMismatch = worktreeTargetMismatch(record2, {
+    projectId: input.projectId,
+    machineId: input.machineId
+  });
+  const allowedRoot = input.confirmRepoRoot ?? input.repoCwd;
+  const pathMatches = isWorktreePathWithinProjectRoot(allowedRoot, record2.path, input.machinePlatform);
+  if (!targetMismatch && pathMatches) return record2;
+  await input.client.deleteProjectWorktree(input.projectId, record2.id, true).catch(() => void 0);
+  throw new Error(!pathMatches && input.pathMismatchMessage ? input.pathMismatchMessage(record2.path) : input.targetMismatchMessage);
+}
 async function createCliProjectWorktree(input, deps) {
   const createInput = {
     client: {
@@ -20429,6 +20942,7 @@ const USAGE_SETTINGS_NAVIGATION_DESTINATIONS = [
   "settings_memory",
   "settings_conversation_search",
   "settings_connectors",
+  "settings_my_ai_credentials",
   "settings_extensions",
   "settings_about"
 ];
@@ -22742,6 +23256,50 @@ function readMachineId(input, readFile2) {
 function spawnBudgetKey(env) {
   return env.agentId ?? env.root;
 }
+function normalizeAbsolutePath(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("/")) return "";
+  const resolved = [];
+  for (const segment of trimmed.split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      resolved.pop();
+      continue;
+    }
+    resolved.push(segment);
+  }
+  return `/${resolved.join("/")}`;
+}
+function isInsideTree(path, root) {
+  const normalizedRoot = normalizeAbsolutePath(root);
+  if (!normalizedRoot || !path) return false;
+  if (path === normalizedRoot) return true;
+  return path.startsWith(normalizedRoot === "/" ? "/" : `${normalizedRoot}/`);
+}
+function resolveSpawnContextFiles(input) {
+  const resolved = [];
+  for (const original of input.paths) {
+    const path = normalizeAbsolutePath(original);
+    if (!path || !isInsideTree(path, input.root)) {
+      return { ok: false, reason: "out_of_scope", path: original };
+    }
+    if (!input.isReadableFile(path)) {
+      return { ok: false, reason: "file_unreadable", path: original };
+    }
+    resolved.push(path);
+  }
+  return { ok: true, paths: resolved };
+}
+function composeSpawnPrompt(text2, contextPaths) {
+  if (contextPaths.length === 0) return text2;
+  const files = contextPaths.map((path) => `- ${path}`).join("\n");
+  return [
+    "Read these files first — they are the context for this task:",
+    files,
+    "",
+    text2
+  ].join("\n");
+}
 const HANDOFF_INLINE_LIMIT = 12e3;
 const TRUNCATION_NOTICE = "(대화가 길어 앞부분이 잘렸습니다. 아래는 가장 최근 대화입니다.)";
 const HEADER_TITLE_LIMIT = 200;
@@ -22808,6 +23366,13 @@ function buildAgentHandoffPrompt(source, context) {
     ...FIRST_ACTIONS.map((action) => `- ${action}`)
   ].join("\n");
 }
+async function fileSpawnedSessionUnderProject(runtime, sessionId, directory) {
+  if (!runtime.registerSpawnedSession) return;
+  try {
+    await runtime.registerSpawnedSession({ sessionId, directory });
+  } catch {
+  }
+}
 function quote(text2) {
   return text2.split("\n").map((line2) => line2 ? `> ${line2}` : ">").join("\n");
 }
@@ -22881,6 +23446,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent) {
       root: env.root,
       depth: env.depth,
       childSessionId: sessionId,
+      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
       agent,
       promptPreview: `handoff from ${from}`,
       outcome: sessionId ? "spawned" : "failed"
@@ -22892,6 +23458,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent) {
   if (!sessionId) {
     return agentFail("spawn_failed", `the machine daemon did not confirm a session: ${String(spawnError)}`);
   }
+  await fileSpawnedSessionUnderProject(runtime, sessionId, env.root);
   return agentOk({
     sessionId,
     agent,
@@ -22929,6 +23496,107 @@ ${clamped.text}` : clamped.text
     }
   );
 }
+function isRecord(value2, allowCli) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return false;
+  const record2 = value2;
+  return Object.keys(record2).length === 4 && typeof record2.parentSessionId === "string" && record2.parentSessionId.length > 0 && typeof record2.childSessionId === "string" && record2.childSessionId.length > 0 && record2.parentSessionId !== record2.childSessionId && Number.isFinite(record2.spawnedAt) && Number(record2.spawnedAt) >= 0 && (record2.source === "handoff" || record2.source === "autopilot-fanout" || allowCli && record2.source === "cli");
+}
+function validatedRecords(value2, allowCli = true) {
+  if (!Array.isArray(value2) || !value2.every((record2) => isRecord(record2, allowCli))) return null;
+  const parentByChild = /* @__PURE__ */ new Map();
+  for (const record2 of value2) {
+    if (parentByChild.has(record2.childSessionId)) return null;
+    parentByChild.set(record2.childSessionId, record2.parentSessionId);
+  }
+  for (const child of parentByChild.keys()) {
+    const visited = /* @__PURE__ */ new Set([child]);
+    let current = child;
+    while (parentByChild.has(current)) {
+      current = parentByChild.get(current);
+      if (visited.has(current)) return null;
+      visited.add(current);
+    }
+  }
+  return value2.map((record2) => ({ ...record2 }));
+}
+function isDescendant(records, ancestorSessionId, targetSessionId, maxDepth = 2) {
+  if (!ancestorSessionId || !targetSessionId || ancestorSessionId === targetSessionId || maxDepth < 1) return false;
+  const valid = validatedRecords(records);
+  if (!valid) return false;
+  const parentByChild = new Map(valid.map((record2) => [record2.childSessionId, record2.parentSessionId]));
+  let current = targetSessionId;
+  for (let depth = 1; depth <= maxDepth; depth += 1) {
+    const parent = parentByChild.get(current);
+    if (!parent) return false;
+    if (parent === ancestorSessionId) return true;
+    current = parent;
+  }
+  return false;
+}
+function resolveSubagentControlPermission(records, parentSessionId, childSessionId) {
+  const valid = validatedRecords(records);
+  return valid ? isDescendant(valid, parentSessionId, childSessionId, 2) : false;
+}
+function canControlSpawnedDescendant(records, parentSessionId, childSessionId) {
+  const lineage = records.flatMap((record2) => record2.outcome === "spawned" && record2.parentSessionId && record2.childSessionId ? [{
+    parentSessionId: record2.parentSessionId,
+    childSessionId: record2.childSessionId,
+    spawnedAt: record2.ts,
+    source: "handoff"
+  }] : []);
+  return resolveSubagentControlPermission(lineage, parentSessionId, childSessionId);
+}
+function ownershipFailure(runtime, env, target) {
+  if (!env.sessionId) return agentFail("session_unknown", "This session did not receive APLUS_SESSION_ID.");
+  if (!runtime.readLineage) return agentFail("not_owned", "spawn lineage is unavailable");
+  try {
+    return canControlSpawnedDescendant(runtime.readLineage(), env.sessionId, target.session.id) ? null : agentFail("not_owned", `${target.session.id} is not an owned descendant`);
+  } catch (error) {
+    return agentFail("not_owned", `spawn ledger is unreadable: ${String(error)}`);
+  }
+}
+async function steerOwnedTarget(runtime, env, target, text2) {
+  if (!text2.trim()) return agentFail("steer_rejected", "steer text is empty");
+  const refused = ownershipFailure(runtime, env, target);
+  if (refused) return refused;
+  if (!runtime.steerSession) return agentFail("steer_rejected", "steer transport is unavailable");
+  try {
+    const result = await runtime.steerSession(target.session.id, text2);
+    if (result.accepted) {
+      return agentOk({
+        sessionId: target.session.id,
+        accepted: true,
+        // RPC acknowledgement proves acceptance, not transcript delivery.
+        delivered: false
+      });
+    }
+    return result.reason === "in-flight" ? agentFail("steer_in_flight", result.error) : agentFail("steer_rejected", result.error);
+  } catch (error) {
+    return agentFail("steer_rejected", error instanceof Error ? error.message : String(error));
+  }
+}
+async function stopOwnedTarget(runtime, env, target) {
+  const refused = ownershipFailure(runtime, env, target);
+  if (refused) return refused;
+  if (!runtime.stopSession) return agentFail("stop_rejected", "stop transport is unavailable");
+  let stream2 = null;
+  try {
+    stream2 = await runtime.openStream(target.session.id);
+    if (stream2.current().thinking !== true) {
+      return agentFail("stop_not_responding", `${target.session.id} has no active response`);
+    }
+  } catch (error) {
+    return agentFail("stop_rejected", error instanceof Error ? error.message : String(error));
+  } finally {
+    stream2?.close();
+  }
+  try {
+    const result = await runtime.stopSession(target.session.machineId, target.session.id);
+    return result.stopped ? agentOk({ sessionId: target.session.id, stopped: true }) : agentFail("stop_rejected", result.error);
+  } catch (error) {
+    return agentFail("stop_rejected", error instanceof Error ? error.message : String(error));
+  }
+}
 const DEFAULT_READ_LIMIT = 20;
 const STATE_WINDOW_MESSAGES = 50;
 function scopeOf(runtime) {
@@ -22982,10 +23650,18 @@ async function readSession(runtime, target, last) {
   });
 }
 const DEFAULT_SPAWN_AGENT = "claude";
-async function spawnSibling(runtime, env, text2, agent) {
+async function spawnSibling(runtime, env, text2, agent, contextFiles = []) {
   if (env.depth >= AGENT_MAX_DEPTH) {
     return agentFail("spawn_depth_exceeded", `depth ${env.depth} is already at the ceiling of ${AGENT_MAX_DEPTH}`);
   }
+  const context = resolveSpawnContextFiles({
+    paths: contextFiles,
+    root: env.root,
+    isReadableFile: runtime.isReadableFile
+  });
+  if (!context.ok) {
+    return context.reason === "out_of_scope" ? agentFail("out_of_scope", `${context.path} is outside ${env.root}`) : agentFail("file_unreadable", `${context.path} could not be read`);
+  }
   const key = spawnBudgetKey(env);
   let spawned;
   try {
@@ -23002,7 +23678,7 @@ async function spawnSibling(runtime, env, text2, agent) {
     sessionId = (await runtime.spawnSession({
       directory: env.root,
       agent,
-      initialPrompt: text2,
+      initialPrompt: composeSpawnPrompt(text2, context.paths),
       environmentVariables: childAgentEnv(env, childId)
     })).sessionId;
   } catch (error) {
@@ -23015,6 +23691,7 @@ async function spawnSibling(runtime, env, text2, agent) {
       root: env.root,
       depth: env.depth,
       childSessionId: sessionId,
+      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
       agent,
       promptPreview: text2,
       outcome: sessionId ? "spawned" : "failed"
@@ -23026,6 +23703,7 @@ async function spawnSibling(runtime, env, text2, agent) {
   if (!sessionId) {
     return agentFail("spawn_failed", `the machine daemon did not confirm a session: ${String(spawnError)}`);
   }
+  await fileSpawnedSessionUnderProject(runtime, sessionId, env.root);
   return agentOk({ sessionId, agent, directory: env.root, depth: env.depth + 1, spawned: spawned + 1, maxSpawn: env.maxSpawn });
 }
 async function runAgentCommand(runtime, args) {
@@ -23060,7 +23738,7 @@ async function runAgentCommand(runtime, args) {
     if (args.handoff) {
       return handoffToSibling(runtime, scope, env, args.handoff, args.agent ?? DEFAULT_SPAWN_AGENT);
     }
-    return spawnSibling(runtime, env, args.text ?? "", args.agent ?? DEFAULT_SPAWN_AGENT);
+    return spawnSibling(runtime, env, args.text ?? "", args.agent ?? DEFAULT_SPAWN_AGENT, args.files ?? []);
   }
   if (!args.sessionId) return agentFail("session_not_found", "no session id given");
   const target = await resolveTarget(runtime, scope, args.sessionId);
@@ -23077,10 +23755,19 @@ async function runAgentCommand(runtime, args) {
         args.text ?? "",
         args.wait ? { until: args.until ?? "turn-end", timeoutMs: clampWaitTimeout(args.timeoutMs) } : null
       );
+    case "steer":
+      return steerOwnedTarget(runtime, env, target, args.text ?? "");
+    case "stop":
+      return stopOwnedTarget(runtime, env, target);
     default:
       return agentFail("session_not_found", `unsupported verb "${args.verb}"`);
   }
 }
+function parseSpawnRecord(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
+  const record2 = value2;
+  return typeof record2.ts === "number" && Number.isFinite(record2.ts) && typeof record2.agentKey === "string" && record2.agentKey.length > 0 && typeof record2.root === "string" && record2.root.length > 0 && typeof record2.depth === "number" && Number.isInteger(record2.depth) && record2.depth >= 0 && (record2.childSessionId === null || typeof record2.childSessionId === "string" && record2.childSessionId.length > 0) && (record2.parentSessionId === void 0 || typeof record2.parentSessionId === "string" && record2.parentSessionId.length > 0) && typeof record2.agent === "string" && record2.agent.length > 0 && typeof record2.promptPreview === "string" && (record2.outcome === "spawned" || record2.outcome === "failed") ? record2 : null;
+}
 const LEDGER_FILE_MODE = 384;
 const PREVIEW_MAX_LENGTH = 200;
 function agentLineagePath(homeDir) {
@@ -23099,7 +23786,8 @@ function readSpawnRecords(homeDir) {
     if (!line2.trim()) continue;
     try {
       const parsed = JSON.parse(line2);
-      if (parsed && typeof parsed.agentKey === "string") records.push(parsed);
+      const record2 = parseSpawnRecord(parsed);
+      if (record2) records.push(record2);
     } catch {
       continue;
     }
@@ -23116,8 +23804,106 @@ function appendSpawnRecord(homeDir, record2) {
   appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: LEDGER_FILE_MODE });
 }
+function normalize(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  const stripped = trimmed.replace(/\/+$/, "");
+  return stripped || "/";
+}
+function onlyOne(matches) {
+  return matches.length === 1 ? matches[0] : null;
+}
+function matchSpawnProject(input) {
+  const machineId = input.machineId.trim();
+  const directory = normalize(input.directory);
+  if (!machineId || !directory) return null;
+  const local = input.projects.filter((project) => project.machineId && project.machineId === machineId);
+  const byWorkspace = local.filter((project) => normalize(project.workspaceDir) === directory);
+  const workspaceHit = onlyOne(byWorkspace);
+  if (workspaceHit) return { projectId: workspaceHit.id };
+  if (byWorkspace.length > 1) return null;
+  const byWorktree = local.flatMap((project) => (input.worktreesByProjectId[project.id] ?? []).filter((tree) => !tree.removedAt && tree.machineId === machineId && normalize(tree.path) === directory).map((tree) => ({ projectId: project.id, worktreeId: tree.id })));
+  return onlyOne(byWorktree);
+}
+function readFileOrNull$1(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function fileSessionUnderProject(context, env, input) {
+  const machineId = readMachineId(
+    {
+      homeDir: context.homeDir,
+      env,
+      credentialHome: context.credential.source === "saycode" ? null : dirname(context.credential.path)
+    },
+    readFileOrNull$1
+  );
+  if (!machineId) return;
+  const projects = await loadWorkspaceProjects(context);
+  const direct = matchSpawnProject({ machineId, directory: input.directory, projects, worktreesByProjectId: {} });
+  if (direct) {
+    await context.rest.assignSessionToProject(direct.projectId, input.sessionId);
+    return;
+  }
+  const local = projects.filter((project) => project.machineId === machineId);
+  const worktreesByProjectId = {};
+  for (const project of local) {
+    worktreesByProjectId[project.id] = await context.rest.listProjectWorktrees(project.id);
+  }
+  const viaWorktree = matchSpawnProject({ machineId, directory: input.directory, projects, worktreesByProjectId });
+  if (!viaWorktree) return;
+  await context.rest.assignSessionToProject(viaWorktree.projectId, input.sessionId, viaWorktree.worktreeId);
+}
+function rejectedSteer(error) {
+  return {
+    accepted: false,
+    reason: /\bin[- ]flight\b/i.test(error) ? "in-flight" : "rejected",
+    error
+  };
+}
+async function steerAgentSession(transport, sessionId, text2) {
+  try {
+    const result = await transport.rpc(sessionId, "steer", { text: text2 });
+    if (result?.success === true) return { accepted: true };
+    const error = typeof result?.error === "string" ? result.error : "Session returned an invalid steer acknowledgement.";
+    return rejectedSteer(error);
+  } catch (error) {
+    return rejectedSteer(error instanceof Error ? error.message : String(error));
+  }
+}
+async function stopAgentSession(transport, machineId, sessionId) {
+  try {
+    const result = await transport.rpc(machineId, "stop-session", {
+      sessionId,
+      source: "saycode-agent-stop",
+      reason: "user-requested",
+      mode: "force"
+    });
+    if (result?.stopped === true) return { stopped: true };
+    return {
+      stopped: false,
+      error: typeof result?.reason === "string" ? result.reason : "Machine returned an invalid stop acknowledgement."
+    };
+  } catch (error) {
+    return {
+      stopped: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 const STREAM_HISTORY_LIMIT = 50;
 const SPAWN_RPC_TIMEOUT_MS = 6e4;
+function isReadableFileSync(path) {
+  try {
+    accessSync(path, constants$1.R_OK);
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
 function readFileOrNull(path) {
   try {
     return readFileSync(path, "utf8");
@@ -23128,7 +23914,7 @@ function readFileOrNull(path) {
 async function recentContents(context, transport, sessionId, limit) {
   const messages = await context.rest.recentMessages(sessionId, limit);
   const contents = [];
-  for (const message of messages) {
+  for (const message of [...messages].sort((left, right) => left.seq - right.seq)) {
     const ciphertext = unwrapEncryptedField(message.content);
     if (!ciphertext) continue;
     const content = decodeContent(transport, ciphertext);
@@ -23197,6 +23983,7 @@ function createAgentRuntime(context, transport, env = process.env) {
     credentialHome,
     now: () => Date.now(),
     readFile: readFileOrNull,
+    isReadableFile: isReadableFileSync,
     listSessions: async () => normalizeSessionRows(await context.rest.listSessions(), keys),
     readMessages: (sessionId, limit) => recentContents(context, transport, sessionId, limit),
     openStream: (sessionId) => openStream(context, transport, sessionId),
@@ -23228,7 +24015,13 @@ function createAgentRuntime(context, transport, env = process.env) {
     },
     newAgentId: () => randomBytes(8).toString("hex"),
     countSpawns: (agentKey) => countSpawnsFor(homeDir, agentKey),
-    recordSpawn: (record2) => appendSpawnRecord(homeDir, record2)
+    recordSpawn: (record2) => appendSpawnRecord(homeDir, record2),
+    readLineage: () => readSpawnRecords(homeDir),
+    steerSession: (sessionId, text2) => steerAgentSession(transport, sessionId, text2),
+    stopSession: (machineId, sessionId) => stopAgentSession(transport, machineId, sessionId),
+    // Omitted entirely without API access: a Happy `access.key` is sync-only, so
+    // there is no project list to match against and nothing to register with.
+    ...context.hasApiAccess ? { registerSpawnedSession: (input) => fileSessionUnderProject(context, env, input) } : {}
   };
 }
 async function contextFor(workspace) {