@buzzni/saycode-cli 0.3.2 → 0.4.0

package/index.mjs

@@ -40,9 +40,9 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.3.2";
+const version$1 = "0.4.0";
 const manifest = {
-  version
+  version: version$1
 };
 const AGENT_CONTROL_VERBS = ["steer", "stop"];
 function parseAgentControlArgs(verb, target, rest, hasPositionalTarget) {
@@ -58,13 +58,13 @@ function parseAgentControlArgs(verb, target, rest, hasPositionalTarget) {
   return null;
 }
 const AGENT_VERBS = ["whoami", "ls", "read", "wait", "prompt", "spawn", ...AGENT_CONTROL_VERBS];
-function fail(message) {
+function fail$1(message) {
   return { command: "error", message };
 }
 function parseAgentArgs(flags, positionals) {
   const [verb, ...rest] = positionals;
   if (!verb || !AGENT_VERBS.includes(verb)) {
-    return fail(`agent needs one of: ${AGENT_VERBS.join(", ")}`);
+    return fail$1(`agent needs one of: ${AGENT_VERBS.join(", ")}`);
   }
   const timeout = flags.timeoutMs !== void 0 ? { timeoutMs: flags.timeoutMs } : {};
   const hasPositionalTarget = flags.sessionId === void 0 && rest[0] !== void 0;
@@ -75,20 +75,31 @@ function parseAgentArgs(flags, positionals) {
     case "whoami":
       return { command: "agent", verb: "whoami" };
     case "ls":
-      return { command: "agent", verb: "ls" };
+      return { command: "agent", verb: "ls", ...flags.status ? { status: true } : {} };
     case "read": {
-      if (!target) return fail("agent read needs a session id (see `saycode agent ls`)");
-      return { command: "agent", verb: "read", sessionId: target, ...flags.last !== void 0 ? { last: flags.last } : {} };
+      if (!target) return fail$1("agent read needs a session id (see `saycode agent ls`)");
+      return {
+        command: "agent",
+        verb: "read",
+        sessionId: target,
+        ...flags.last !== void 0 ? { last: flags.last } : {},
+        ...flags.since !== void 0 ? { since: flags.since } : {}
+      };
     }
     case "wait": {
-      if (!target) return fail("agent wait needs a session id (see `saycode agent ls`)");
-      if (!flags.until) return fail("agent wait needs --until turn-end|waiting-input|completed");
+      if (flags.any) {
+        if (rest.length < 2) return fail$1("agent wait --any needs two or more session ids");
+        if (!flags.until) return fail$1("agent wait needs --until turn-end|waiting-input|completed");
+        return { command: "agent", verb: "wait", sessionIds: [...rest], until: flags.until, ...timeout };
+      }
+      if (!target) return fail$1("agent wait needs a session id (see `saycode agent ls`)");
+      if (!flags.until) return fail$1("agent wait needs --until turn-end|waiting-input|completed");
       return { command: "agent", verb: "wait", sessionId: target, until: flags.until, ...timeout };
     }
     case "prompt": {
-      if (!target) return fail("agent prompt needs a session id (see `saycode agent ls`)");
+      if (!target) return fail$1("agent prompt needs a session id (see `saycode agent ls`)");
       const text2 = rest.slice(hasPositionalTarget ? 1 : 0).join(" ").trim();
-      if (!text2) return fail("agent prompt needs the text to send");
+      if (!text2) return fail$1("agent prompt needs the text to send");
       return {
         command: "agent",
         verb: "prompt",
@@ -104,16 +115,16 @@ function parseAgentArgs(flags, positionals) {
       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");
+          return fail$1("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");
+          return fail$1("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");
+          return fail$1("agent spawn --handoff does not support --mode full yet; only summary is available");
         }
-        if (mode !== "summary") return fail(`agent spawn --handoff got an unknown --mode: ${mode}`);
+        if (mode !== "summary") return fail$1(`agent spawn --handoff got an unknown --mode: ${mode}`);
         const from = flags.from?.trim();
         return {
           command: "agent",
@@ -125,7 +136,7 @@ function parseAgentArgs(flags, positionals) {
         };
       }
       const text2 = flags.prompt?.trim();
-      if (!text2) return fail("agent spawn needs --prompt <text>");
+      if (!text2) return fail$1("agent spawn needs --prompt <text>");
       return {
         command: "agent",
         verb: "spawn",
@@ -137,7 +148,7 @@ function parseAgentArgs(flags, positionals) {
       };
     }
     default:
-      return fail(`unsupported agent verb: ${verb}`);
+      return fail$1(`unsupported agent verb: ${verb}`);
   }
 }
 function fencedMarkdownRanges(content) {
@@ -316,7 +327,7 @@ const agentBoardKo = {
   "agentBoard.columnReviewHint": "카드를 놓으면 리뷰를 요청합니다",
   "agentBoard.columnDone": "완료",
   "agentBoard.columnDoneHint": "카드를 놓으면 대화를 완료로 이동합니다",
-  "agentBoard.columnMerged": "PR Merged",
+  "agentBoard.columnMerged": "PR 병합됨",
   "agentBoard.columnMergedHint": "PR이 머지된 대화",
   "agentBoard.title": "에이전트 보드",
   "agentBoard.description": "실행 중인 모든 에이전트 대화를 한눈에 보고, 카드를 옮겨 다음 작업을 지시하세요.",
@@ -370,7 +381,7 @@ const agentBoardKo = {
   "agentBoard.mergeDialogTitle": "Pull request를 머지할까요?",
   "agentBoard.mergeCopy": "PR #{prNumber}을 squash 방식으로 머지합니다. 이 작업은 GitHub 저장소에 즉시 반영됩니다.",
   "agentBoard.mergeCancel": "취소",
-  "agentBoard.mergeConfirm": "Merge",
+  "agentBoard.mergeConfirm": "병합",
   "agentBoard.cardReopenTitle": "완료를 해제하고 이어서 작업합니다. 완료 시 삭제된 작업 트리는 브랜치 기준으로 복구합니다.",
   "agentBoard.cardReopen": "완료 해제",
   "agentBoard.cardCreatePrTitle": "에이전트에게 commit 및 PR 생성을 요청",
@@ -399,7 +410,7 @@ const agentBoardKo = {
   "agentBoard.findSessionError": "대화를 찾을 수 없습니다. 새로고침 후 다시 시도해주세요.",
   "agentBoard.autopilot.enable": "오토파일럿",
   "agentBoard.autopilot.unavailableWorktree": "오토파일럿 사용 불가 · worktree 필요",
-  "agentBoard.autopilot.enableTitle": "작업이 완료되면 독립 리뷰를 시키고, 발견 0건이면 Commit & PR까지 자동 진행합니다.",
+  "agentBoard.autopilot.enableTitle": "작업이 완료되면 현재 에이전트에 셀프 리뷰를 시키고, medium 이상 지적이 없으면 Commit & PR까지 자동 진행합니다.",
   "agentBoard.autopilot.waiting": "오토파일럿 · 턴 종료 대기",
   "agentBoard.autopilot.reviewRequested": "오토파일럿 · 리뷰 시작 중",
   "agentBoard.autopilot.reviewing": "오토파일럿 · 독립 리뷰 중",
@@ -419,6 +430,8 @@ const agentBoardKo = {
   "agentBoard.autopilot.blocked.commitPrFailed": "오토파일럿 차단 · PR 요청 전송 실패",
   "agentBoard.autopilot.blocked.noCompletionSignal": "오토파일럿 차단 · 완료 신호 없음",
   "agentBoard.autopilot.blocked.loopDetected": "오토파일럿 차단 · 반복 감지로 중지됨",
+  "agentBoard.autopilot.blocked.qualityGateFailed": "품질 게이트 실패 · 같은 세션에서 수정 중",
+  "agentBoard.autopilot.blocked.qualityGateBlocked": "오토파일럿 차단 · 품질 게이트 실패",
   "agentBoard.autopilot.loopStopFailed": "반복을 감지했지만 세션 중지에 실패했습니다: {detail}",
   "agentBoard.autopilot.forceProceed": "그래도 진행",
   "agentBoard.autopilot.forceProceedTitle": "리뷰어가 완료를 명시적으로 선언하지 않았습니다. 그래도 Commit & PR을 진행합니다.",
@@ -432,7 +445,12 @@ const agentBoardKo = {
   "agentBoard.verify.phase.bootstrap": "준비",
   "agentBoard.verify.phase.build": "빌드",
   "agentBoard.verify.phase.test": "테스트",
-  "agentBoard.verify.phase.start": "구동 확인"
+  "agentBoard.verify.phase.start": "구동 확인",
+  "agentBoard.verify.detail.noRecipe": "실행할 레시피가 없습니다. package.json 스크립트, Makefile, 또는 .aplus/verify.json이 필요합니다.",
+  "agentBoard.verify.detail.phaseFailed": "{phase} 실패 · {reason}",
+  "agentBoard.verify.detail.phaseTimeout": "{phase} 시간 초과",
+  "agentBoard.verify.detail.notReady": "구동은 됐지만 포트가 응답하지 않습니다",
+  "agentBoard.verify.phase.deploy": "배포 확인"
 };
 const fanoutLifecycleKo = {
   "fanoutSection.restoreGroupAria": "병렬 그룹 복원: {title} · 실행 {run}",
@@ -572,7 +590,7 @@ const orcaPortKo = {
   "ciFix.promptIntro": "아래 PR의 CI가 실패했습니다. 실패 로그를 확인하고 원인을 수정해주세요:",
   "shortcuts.action.quickOpen": "Quick Open 팔레트",
   "shortcuts.action.quickOpenDescription": "프로젝트·세션·대화를 한 검색창에서 찾아 바로 이동합니다.",
-  "quickOpen.title": "Quick Open",
+  "quickOpen.title": "빠른 열기",
   "quickOpen.inputAria": "Quick Open 검색",
   "quickOpen.placeholder": "프로젝트, 세션, 대화 검색…",
   "quickOpen.resultsAria": "Quick Open 결과",
@@ -623,6 +641,8 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.nameLabel": "이름",
   "scheduledAutomations.promptLabel": "프롬프트",
   "scheduledAutomations.agentLabel": "실행 에이전트",
+  "scheduledAutomations.personaLabel": "실행 페르소나",
+  "scheduledAutomations.personaNone": "없음",
   "scheduledAutomations.scheduleLabel": "스케줄",
   "scheduledAutomations.scheduleInterval": "주기 (분마다)",
   "scheduledAutomations.scheduleDaily": "매일 지정 시각",
@@ -670,6 +690,8 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.outcomeSkippedOverlap": "이전 실행 진행 중(스킵)",
   "scheduledAutomations.outcomeSilent": "이상 없음([SILENT])",
   "scheduledAutomations.outcomeError": "실패",
+  "scheduledAutomations.requestedModel": "요청 모델: {model}",
+  "scheduledAutomations.fallbackModelUsed": "폴백 모델 사용됨: {model}",
   "scheduledAutomations.validationRequired": "이름과 프롬프트를 입력하세요.",
   "scheduledAutomations.migrationTitle": "기존 자동화 이전",
   "scheduledAutomations.migrationHint": "기존 앱·daemon 자동화를 Happy Server로 안전하게 이전합니다.",
@@ -753,6 +775,10 @@ const githubTriggersKo = {
   "githubTriggers.actionLabel": "액션",
   "githubTriggers.actionNotify": "알림만 (LLM 비용 없음)",
   "githubTriggers.actionStartSession": "세션 시작",
+  "githubTriggers.actionVerifyMerge": "머지 검증 (실패 시에만 세션)",
+  "mergeVerify.noticePassed": 'PR #{pr} "{title}" 머지 후 검증을 통과했습니다 ({revision})',
+  "mergeVerify.revisionMergeCommit": "머지 커밋 {sha}",
+  "mergeVerify.revisionBaseFallback": "base 브랜치 tip — 머지 커밋을 확인하지 못해 폴백",
   "githubTriggers.agentLabel": "실행 에이전트",
   "githubTriggers.modelLabel": "모델 (비우면 자동)",
   "githubTriggers.effortLabel": "추론 강도",
@@ -781,13 +807,15 @@ const githubTriggersKo = {
   "githubTriggers.outcomeSessionStarted": "세션 시작",
   "githubTriggers.outcomeSkippedOverlap": "이전 세션 진행 중(스킵)",
   "githubTriggers.outcomeError": "실패",
+  "githubTriggers.outcomeVerifyPassed": "검증 통과",
+  "githubTriggers.outcomeVerifyFailed": "검증 실패 → 수정 세션",
   "githubTriggers.pollError": "GitHub 조회 실패: {detail} — 다음 주기에 재시도합니다.",
   "githubTriggers.validationRequired": "이름과 템플릿을 입력하세요."
 };
 const memoryHubKo = {
   "memoryHub.button": "메모리",
   "memoryHub.ariaLabel": "메모리 허브",
-  "memoryHub.title": "Memory Hub",
+  "memoryHub.title": "메모리 허브",
   "memoryHub.refresh": "새로고침",
   "memoryHub.openDashboard": "전체 대시보드 열기",
   "memoryHub.loading": "프로젝트 메모리를 불러오는 중…",
@@ -816,12 +844,33 @@ const extensionPanelKo = {
 };
 const extensionInstallKo = {
   "extensions.installOfficial": "확장 설치",
+  "extensions.installArtifactPublisher": "공개 링크 확장 설치",
   "extensions.installDescription": "계속하려면 공식 확장을 설치하세요.",
   "extensions.machineExecutePermission": "이 확장은 미리 정의된 동작에만 machine.execute 권한을 요청합니다.",
   "extensions.notInstalled": "요청한 확장이 설치되지 않았습니다.",
   "extensions.disabled": "요청한 확장이 비활성화되어 있습니다.",
   "extensions.quarantined": "요청한 확장이 반복된 오류로 격리되었습니다.",
-  "extensions.unavailable": "요청한 확장이 설치되어 있지만 현재 사용할 수 없습니다."
+  "extensions.unavailable": "요청한 확장이 설치되어 있지만 현재 사용할 수 없습니다.",
+  "extensions.permission.artifactPublishPublic": "선택한 결과물의 공개 링크를 만들 수 있습니다. 파일 내용과 링크 처리는 Saycode Core가 담당합니다.",
+  "artifactPublication.dialogTitle": "공개 링크",
+  "artifactPublication.copy": "링크 복사",
+  "artifactPublication.copied": "복사됨",
+  "artifactPublication.open": "링크 열기",
+  "artifactPublication.revoke": "공개 중지",
+  "artifactPublication.revoking": "중지 중…",
+  "artifactPublication.failed": "공개 링크 작업에 실패했습니다.",
+  "artifactPublication.error.failed": "공개 링크 작업에 실패했습니다.",
+  "artifactPublication.error.cancelled": "공개 링크 작업이 취소되었습니다.",
+  "artifactPublication.error.timeout": "서버 응답 시간이 초과되었습니다. 잠시 후 다시 시도해 주세요.",
+  "artifactPublication.error.network": "서버에 연결할 수 없습니다. 네트워크 상태를 확인해 주세요.",
+  "artifactPublication.error.unauthenticated": "로그인 세션이 만료되었습니다. 다시 로그인한 뒤 시도해 주세요.",
+  "artifactPublication.error.notFound": "파일을 찾을 수 없습니다. 파일이 저장되었는지 확인해 주세요.",
+  "artifactPublication.error.tooLarge": "파일이 너무 큽니다. 공개할 HTML 파일은 10MB 이하여야 합니다.",
+  "artifactPublication.error.rateLimited": "공개 링크 요청이 너무 많습니다. 잠시 후 다시 시도해 주세요.",
+  "artifactPublication.error.rejected": "서버가 이 파일의 공개 요청을 거부했습니다.",
+  "artifactPublication.error.serverError": "서버 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.",
+  "artifactPublication.error.extensionUnavailable": "확장이 비활성화되었거나 공개 권한이 없습니다. 설정에서 Artifact Publisher를 확인해 주세요.",
+  "artifactPublication.error.invalidResponse": "서버 응답을 확인할 수 없어 중단했습니다."
 };
 const personalChatsLandingKo = {
   "personalChats.heroTitle": "무엇을 도와드릴까요?",
@@ -855,7 +904,7 @@ const personalChatsKo = {
   "personalChats.creating": "채팅을 시작하는 중…",
   "personalChats.noOnlineMachine": "온라인 머신이 없습니다. 채팅을 시작하려면 머신을 시작해주세요.",
   "personalChats.localMachinePreparing": "이 컴퓨터를 Saycode에 연결하는 중이에요. 잠시 후 바로 시작할 수 있어요.",
-  "personalChats.localMachineAsk": "이 컴퓨터를 바로 사용할 수 있어요. 클릭 한 번으로 연결을 마치세요.",
+  "personalChats.localMachineAsk": "이 컴퓨터에 Saycode CLI를 설치하면 바로 채팅을 시작할 수 있어요.",
   "personalChats.localMachineFailed": "이 컴퓨터 자동 연결에 실패했어요. 다른 방법으로 연결할 수 있어요.",
   "personalChats.pickMachine": "이 채팅을 실행할 머신을 선택하세요",
   "personalChats.back": "뒤로",
@@ -919,16 +968,45 @@ const agentLoopDetectionKo = {
   "agentBoard.loopDetectedTitle": "같은 툴 호출 또는 텍스트가 짧은 시간 안에 반복되고 있습니다. 멈춰 있을 수 있습니다.",
   "settings.agentLoopAutoStop.enable": "반복 감지 시 세션 자동 중지",
   "settings.agentLoopAutoStop.help": "오토파일럿이 관리하는 세션이 같은 툴 호출이나 텍스트를 반복하며 멈춘 것으로 보이면 자동으로 응답을 중지합니다. 기본은 꺼짐 — 오탐으로 정상 작업을 멈추는 것이 놓치는 것보다 나쁩니다.",
-  "settings.agentLoopAutoStop.saveFailed": "설정을 저장하지 못했습니다."
+  "settings.agentLoopAutoStop.saveFailed": "설정을 저장하지 못했습니다.",
+  "settings.autonomousQualityGate.enable": "오토파일럿 자율 품질 게이트 사용",
+  "settings.autonomousQualityGate.help": "리뷰와 Commit & PR 전에 프로젝트 검증을 실행하고, 실패하면 같은 세션에 제한된 수정 요청을 보냅니다. 기본은 꺼짐입니다.",
+  "settings.autonomousQualityGate.saveFailed": "품질 게이트 설정을 저장하지 못했습니다.",
+  "qualityGate.statusAria": "자율 품질 게이트 상태",
+  "qualityGate.stage": "품질 게이트 · {stage}",
+  "qualityGate.attempt": "시도 {attempt}/{max}",
+  "qualityGate.usage": "수정 {continuations}/{maxContinuations} · 턴 {turns}/{maxTurns} · 토큰 {tokens}/{maxTokens}",
+  "qualityGate.lastPhase": "{phase} · {result}",
+  "qualityGate.limit": "한도 도달: {reason}",
+  "qualityGate.pause": "품질 게이트 일시정지",
+  "qualityGate.resume": "품질 게이트 재개",
+  "qualityGate.stop": "품질 게이트 중지"
 };
 const autopilotSelfReviewRoundsKo = {
   "settings.autopilotSelfReviewRounds.label": "오토파일럿 셀프 리뷰 반복 횟수",
-  "settings.autopilotSelfReviewRounds.help": '오토파일럿이 "현재 에이전트로 점검"을 몇 번까지 이어서 시킬지 정합니다. 점검 결과에 아직 해결하지 못한 문제가 남아 있으면 남은 횟수만큼 다시 점검하게 하고, 문제가 없어지면 남은 횟수와 상관없이 바로 Commit & PR로 넘어갑니다. 지정한 횟수를 다 쓰고도 문제가 남으면 지금처럼 멈추고 사람에게 넘깁니다. 기본은 1회(지금까지와 동일).',
+  "settings.autopilotSelfReviewRounds.help": '오토파일럿이 "현재 에이전트로 점검"을 몇 번까지 이어서 시킬지 정합니다. 한 라운드에서 medium 이상 지적이 나오면 남은 횟수만큼 다시 점검하게 하고, low 이하만 남으면 남은 횟수와 상관없이 바로 Commit & PR로 넘어갑니다. 지정한 횟수를 다 쓰고도 medium 이상이 남으면 멈추고 사람에게 넘깁니다. 기본은 7회.',
   "settings.autopilotSelfReviewRounds.once": "1회 (반복 없음)",
   "settings.autopilotSelfReviewRounds.times": "{count}회",
   "settings.autopilotSelfReviewRounds.saveFailed": "설정을 저장하지 못했습니다.",
   "agentBoard.autopilot.reviewingSelfRound": "오토파일럿 · 셀프 리뷰 중 {round}/{total}"
 };
+const memoryGuardrailsKo = {
+  "settings.memoryGuardrails.help": "기억으로 남기지 말아야 할 항목을 정합니다. 기본 규칙은 끌 수 있고, 프로젝트 전용 규칙을 추가할 수 있습니다.",
+  "settings.memoryGuardrails.saveFailed": "설정을 저장하지 못했습니다.",
+  "settings.memoryGuardrails.tooLong": "규칙 전체 길이가 {max}자를 넘어 저장할 수 없습니다.",
+  "settings.memoryGuardrails.removeAria": "{text} 삭제",
+  "settings.memoryGuardrails.remove": "삭제",
+  "settings.memoryGuardrails.addLabel": "새 금지 항목",
+  "settings.memoryGuardrails.addPlaceholder": "예: 이 프로젝트의 임시 브랜치 이름은 기억하지 않는다",
+  "settings.memoryGuardrails.add": "추가"
+};
+const memoryEventsKo = {
+  "settings.memoryEvents.ariaLabel": "기억 열람",
+  "settings.memoryEvents.unavailable": "기억 대시보드가 실행 중이 아닙니다.",
+  "settings.memoryEvents.searchLabel": "기억 검색",
+  "settings.memoryEvents.prevPage": "이전",
+  "settings.memoryEvents.nextPage": "다음"
+};
 const externalWorktreeInboxKo = {
   "externalWorktreeInbox.title": "앱 밖에서 만든 worktree",
   "externalWorktreeInbox.description": "이 저장소에 앱이 만들지 않은 worktree 가 있습니다. 채택하면 목록과 새 대화 시작에서 고를 수 있어요.",
@@ -959,6 +1037,99 @@ const externalSessionVaultKo = {
   "externalSessionVault.rejectedNotOwned": "이 프로젝트 폴더에서 돌린 대화가 아니라서 이어가지 않았습니다.",
   "externalSessionVault.resumeFailed": "그 대화를 이어가지 못했습니다."
 };
+const orgSearchKo = {
+  "orgAdmin.tab.search": "검색 (Elasticsearch)",
+  "orgSearch.admin.title": "Elasticsearch 기반 조직 검색",
+  "orgSearch.admin.description": "조직의 대화를 조직 소유 Elasticsearch에 색인해 멤버가 키워드로 검색할 수 있게 합니다. 각 멤버는 자기가 참여한 프로젝트만 볼 수 있으며, 이는 멤버별 필터 alias와 API 키로 Elasticsearch가 직접 강제합니다.",
+  "orgSearch.admin.unsupported": "이 서버 또는 데스크탑 버전은 아직 조직 검색을 지원하지 않습니다.",
+  "orgSearch.admin.readOnly": "조직 owner/admin만 이 연동을 변경할 수 있습니다.",
+  "orgSearch.form.url": "Elasticsearch 주소",
+  "orgSearch.form.urlPlaceholder": "http://elasticsearch.internal:9200",
+  "orgSearch.form.username": "관리자 ID",
+  "orgSearch.form.password": "관리자 비밀번호",
+  "orgSearch.form.passwordHint": "전용 운영자 사용자를 만드는 데 한 번만 쓰입니다. 관리자 비밀번호는 저장하지 않습니다.",
+  "orgSearch.form.profile": "analyzer 프로필",
+  "orgSearch.form.profile.nori": "nori + ngram (한국어 형태소, 권장)",
+  "orgSearch.form.profile.standard": "standard + ngram (nori 플러그인 없음)",
+  "orgSearch.form.test": "연결 테스트",
+  "orgSearch.form.testing": "테스트 중…",
+  "orgSearch.form.save": "연결하고 인덱스 만들기",
+  "orgSearch.form.saving": "연결 중…",
+  "orgSearch.probe.version": "Elasticsearch 버전",
+  "orgSearch.probe.security": "보안 활성",
+  "orgSearch.probe.license": "라이선스",
+  "orgSearch.probe.nori": "analysis-nori 플러그인",
+  "orgSearch.probe.privileges": "보안 관리 권한 (운영자 사용자 생성)",
+  "orgSearch.probe.yes": "예",
+  "orgSearch.probe.no": "아니오",
+  "orgSearch.probe.unknown": "알 수 없음",
+  "orgSearch.verdict.ok": "연결에 성공했습니다. 저장하면 운영자 사용자와 인덱스를 만듭니다.",
+  "orgSearch.verdict.unreachable": "Elasticsearch에 닿을 수 없습니다. URL과 이 머신이 같은 네트워크(VPN)에 있는지 확인하세요.",
+  "orgSearch.verdict.unauthorized": "인증에 실패했습니다. 관리자 ID와 비밀번호를 확인하세요.",
+  "orgSearch.verdict.unsupported-version": "Elasticsearch 8 이상이 필요합니다.",
+  "orgSearch.verdict.security-disabled": "이 클러스터는 보안이 꺼져 있어 프로젝트별 접근 권한을 강제할 수 없습니다. xpack.security를 먼저 켜세요.",
+  "orgSearch.verdict.insufficient-privileges": "이 사용자는 보안을 관리할 수 없습니다. manage_security와 manage_api_key 권한이 있는 사용자를 쓰세요.",
+  "orgSearch.saved.title": "조직 검색이 연결되었습니다.",
+  "orgSearch.saved.detail": "운영자 사용자 {operator} · 인덱스 {index}",
+  "orgSearch.saved.existingIndex": "매핑이 일치하는 기존 인덱스를 그대로 사용했습니다.",
+  "orgSearch.summary.url": "Elasticsearch 주소",
+  "orgSearch.summary.index": "인덱스",
+  "orgSearch.summary.profile": "analyzer 프로필",
+  "orgSearch.summary.operator": "운영자 사용자",
+  "orgSearch.summary.updated": "갱신",
+  "orgSearch.disconnect": "연동 해제",
+  "orgSearch.disconnect.title": "조직 검색 연동을 해제할까요?",
+  "orgSearch.disconnect.body": "Elasticsearch에서 멤버 키·alias·조직 인덱스를 삭제하고, 멤버의 조직 검색 탭은 즉시 사라집니다. 대화 자체에는 영향이 없습니다.",
+  "orgSearch.disconnect.operatorSection": "운영자 사용자도 삭제 (관리자 계정이 다시 필요)",
+  "orgSearch.disconnect.confirm": "해제하고 삭제",
+  "orgSearch.disconnect.working": "해제 중…",
+  "orgSearch.disconnect.cancel": "취소",
+  "orgSearch.disconnected": "해제했습니다. 인덱스 {indices}개, alias {aliases}개, 멤버 키 {keys}개를 삭제했습니다.",
+  "orgSearch.disconnected.operatorKept": "관리자 자격증명이 없어 운영자 사용자는 남겨 두었습니다.",
+  "orgSearch.error.title": "마지막 작업이 실패했습니다",
+  "orgSearch.acl.title": "권한 동기화 (멤버별 alias·키)",
+  "orgSearch.acl.upToDate": "권한이 최신입니다",
+  "orgSearch.acl.waiting": "{count}건 대기",
+  "orgSearch.acl.members": "멤버 {count}명",
+  "orgSearch.acl.tick.applied": "마지막 동기화: 변경 {actions}건 적용, 실패 {failures}건.",
+  "orgSearch.acl.tick.inSync": "마지막 동기화에서 변경할 것이 없었습니다.",
+  "orgSearch.acl.tick.elsewhere": "다른 관리자의 데스크탑이 동기화를 맡고 있습니다.",
+  "orgSearch.acl.tick.failed": "마지막 동기화 실패: {message}",
+  "orgSearch.progress.title": "색인 진행률",
+  "orgSearch.progress.phase.idle": "색인할 대화 없음",
+  "orgSearch.progress.phase.waiting": "색인할 멤버 대기 중",
+  "orgSearch.progress.phase.indexing": "색인 중",
+  "orgSearch.progress.phase.done": "색인 완료",
+  "orgSearch.progress.sessions": "세션 {done}/{total} ({percent}%)",
+  "orgSearch.progress.messages": "메시지 {count}개 색인됨",
+  "orgSearch.progress.failed": "실패 {count}건",
+  "orgSearch.progress.leases": "활성 색인기 {count}개",
+  "orgSearch.progress.updated": "{time} 갱신",
+  "orgSearch.progress.project": "프로젝트",
+  "orgSearch.progress.phaseColumn": "상태",
+  "orgSearch.progress.sessionsColumn": "세션",
+  "orgSearch.progress.leader": "색인기",
+  "search.tabOrg": "조직",
+  "orgSearch.tab.keyPending": "조직 관리자의 데스크탑이 검색 키를 발급하는 중입니다. 잠시 후 다시 시도하세요.",
+  "orgSearch.tab.unavailable": "지금은 조직 검색을 사용할 수 없습니다.",
+  "orgSearch.tab.error.unauthorized": "검색 키가 거부되었습니다. 새 키를 요청했으니 잠시 후 다시 시도하세요.",
+  "orgSearch.tab.error.forbidden": "Elasticsearch가 이 검색을 거부했습니다. 권한 동기화가 늦었을 수 있으며 관리자 데스크탑이 곧 맞춥니다.",
+  "orgSearch.tab.error.unreachable": "조직 Elasticsearch에 닿을 수 없습니다. 같은 네트워크(VPN)에 있는지 확인하세요.",
+  "orgSearch.tab.error.timeout": "Elasticsearch가 제때 응답하지 않았습니다.",
+  "orgSearch.tab.error.not-configured": "이 데스크탑에는 아직 조직 검색이 설정되지 않았습니다.",
+  "orgSearch.tab.error.error": "검색에 실패했습니다.",
+  "orgSearch.eval.title": "검색 품질 평가",
+  "orgSearch.eval.description": "색인된 내 프롬프트 {count}건을 표본으로 뽑아 실제 검색어처럼 변형(부분 문자열·키워드·오타·식별자 등)한 뒤, 각 검색어가 자기 대화를 찾는지를 Elasticsearch와 이 데스크탑의 로컬 인덱스에서 나란히 확인합니다. 프롬프트는 앱 밖으로 나가지 않습니다.",
+  "orgSearch.eval.run": "품질 평가 실행",
+  "orgSearch.eval.running": "평가 중…",
+  "orgSearch.eval.emptyIndex": "로컬 인덱스에 표본으로 쓸 프롬프트가 아직 없습니다.",
+  "orgSearch.eval.sampled": "프롬프트 {prompts}건, 검색어 {cases}건",
+  "orgSearch.eval.kind": "변형 종류",
+  "orgSearch.eval.engine.es": "Elasticsearch(조직)",
+  "orgSearch.eval.engine.local": "로컬 인덱스",
+  "orgSearch.eval.overall": "전체",
+  "orgSearch.eval.legend": "칸: Recall@1 / @5 / @10 · MRR · p95 지연. 같은 문구를 여러 대화에서 썼다면 다른 대화가 1위인 것도 정상이라, 100% 미만이 곧 결함은 아닙니다."
+};
 const operationModelRetryKo = {
   "review.job.fallbackModelUsed": "폴백 모델 사용됨: {model}"
 };
@@ -1097,7 +1268,7 @@ const machineSettingsConsoleKo = {
   "machineConsole.daemonUnknown": "daemon 미확인",
   "machineConsole.daemonStatus": "daemon 상태",
   "machineConsole.daemonVersion": "daemon 버전",
-  "machineConsole.daemonVersionValue": "daemon {version}",
+  "machineConsole.daemonVersionValue": "데몬 {version}",
   "machineConsole.rpcStatus": "RPC 상태",
   "machineConsole.rpcAvailableStatus": "RPC 사용 가능",
   "machineConsole.rpcUnavailableStatus": "RPC 사용 불가",
@@ -1132,7 +1303,9 @@ const machineSettingsConsoleKo = {
   "machineConsole.updateTimeout": "업데이트가 시작됐지만 완료를 확인하지 못했습니다. 잠시 후 다시 진단해 주세요.",
   "machineConsole.updateFailed": "CLI 업데이트에 실패했습니다.",
   "machineConsole.aiCliStarted": "Codex와 Claude Code 설치를 시작했습니다.",
-  "machineConsole.aiCliFailed": "AI CLI 설치를 시작하지 못했습니다."
+  "machineConsole.aiCliFailed": "AI CLI 설치를 시작하지 못했습니다.",
+  "machineConsole.machineActionFailed": "머신 작업에 실패했습니다.",
+  "machineConsole.extensionCommandsUnavailable": "Extension 명령을 사용할 수 없습니다."
 };
 const sessionTokenUsageKo = {
   "sessionTokenUsage.total": "누적 {count} 토큰",
@@ -1183,7 +1356,17 @@ const newSessionProfileKo = {
   "newSession.profile.fallbackAgent": "{value} 에이전트를 지금 쓸 수 없어 현재 선택을 유지했습니다.",
   "newSession.profile.fallbackModel": "{value} 모델이 목록에 없어 기본값으로 시작합니다.",
   "newSession.profile.fallbackEffort": "{value} 강도를 이 모델에서 쓸 수 없어 기본값으로 시작합니다.",
-  "newSession.profile.fallbackWorktree": "이 프로젝트는 git 저장소가 아니라 작업 사본을 끕니다."
+  "newSession.profile.fallbackWorktree": "이 프로젝트는 git 저장소가 아니라 작업 사본을 끕니다.",
+  // specs/desktop-session-personas T9
+  "newSession.profile.editPersona": "{name} 페르소나 편집",
+  "newSession.profile.instructionsLabel": "{name} 지시문",
+  "newSession.profile.instructionsPlaceholder": "예: 리뷰 관점에서만 답하라",
+  "newSession.profile.instructionsTooLong": "지시문이 너무 깁니다 ({max}자 이하로 줄여주세요).",
+  "newSession.profile.instructionsSave": "{name} 지시문 저장",
+  "newSession.profile.skillsLabel": "배포할 스킬",
+  "newSession.profile.badgeIconLabel": "{name} 표식 아이콘",
+  "newSession.profile.badgeColorLabel": "{name} 표식 색상",
+  "newSession.profile.badgeSave": "{name} 표식 저장"
 };
 const agentBoardBroadcastKo = {
   "agentBoard.broadcastSelected": "선택됨",
@@ -1241,6 +1424,16 @@ const officeViewerKo = {
   "officeViewer.unsupported": "미리보기를 지원하지 않는 형식입니다.",
   "officeViewer.unsupportedHint": "원본 앱에서 열어 확인하세요."
 };
+const additionalDirectoryMountWarningKo = {
+  "additionalDirectories.mountMissing": "추가 디렉터리 {count}개를 자동 마운트에서 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.mountRuntimeUnsupported": "이 머신의 Happy CLI가 추가 디렉터리 마운트를 지원하지 않아 기본 세션으로 시작했습니다.",
+  "additionalDirectories.mountLimit": "추가 디렉터리 마운트 상한을 넘어 {count}개를 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountMissing": "관련 프로젝트 디렉터리 {count}개를 자동 마운트에서 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountLinkLookupFailed": "관련 프로젝트 목록을 불러오지 못해 자동 마운트 없이 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountLookupFailed": "관련 프로젝트 {count}개를 불러오지 못해 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountRuntimeUnsupported": "이 머신의 Happy CLI가 관련 프로젝트 자동 마운트를 지원하지 않아 기본 세션으로 시작했습니다.",
+  "additionalDirectories.relatedMountLimit": "관련 프로젝트 디렉터리 상한을 넘어 {count}개를 제외하고 세션을 시작했습니다."
+};
 const additionalDirectoriesKo = {
   "additionalDirectories.title": "추가 디렉터리",
   "additionalDirectories.add": "디렉터리 추가",
@@ -1260,7 +1453,8 @@ const additionalDirectoriesKo = {
   "additionalDirectories.limitReached": "추가 디렉터리는 최대 8개까지 등록할 수 있습니다.",
   "additionalDirectories.machineMismatch": "현재 머신과 다른 위치에서 선택한 디렉터리입니다.",
   "additionalDirectories.saveFailed": "디렉터리를 등록하지 못했습니다.",
-  "additionalDirectories.folderLoadFailed": "디렉터리를 불러오지 못했습니다."
+  "additionalDirectories.folderLoadFailed": "디렉터리를 불러오지 못했습니다.",
+  ...additionalDirectoryMountWarningKo
 };
 const agentHandoffKo = {
   "agentHandoff.open": "다른 에이전트로 이어가기",
@@ -1332,6 +1526,33 @@ const subagentKo = {
 const reviewNavigationKo = {
   "review.action.openSourceSession": "원본 대화로 이동: {title}"
 };
+const chatFolderUploadKo = {
+  "upload.kindFolder": "폴더",
+  "upload.folderReference": "{path} ({count}개 파일)",
+  "upload.folderChip": "{name} · {count}개 파일",
+  "upload.folderEmpty": "폴더에 업로드할 파일이 없습니다: {name}",
+  "upload.progress": "파일 업로드 중 {done}/{total}",
+  "upload.partialIssue": "업로드 실패 {failed}개 · 건너뜀 {skipped}개",
+  "upload.invalidPath": "안전하지 않은 첨부 경로입니다."
+};
+const composerAddMenuKo = {
+  "composer.addMenu.trigger": "추가",
+  "composer.addMenu.fileOrPhoto": "파일 또는 사진 추가",
+  "composer.addMenu.folder": "폴더 추가",
+  "composer.addMenu.disabled": "지금은 파일이나 폴더를 추가할 수 없습니다.",
+  "shortcuts.action.composerAttachFile": "파일 또는 사진 추가",
+  "shortcuts.action.composerAttachFileDescription": "포커스된 메시지 작성란의 파일 선택기를 엽니다."
+};
+const composerQuickCommandsKo = {
+  "composer.quickCommands.trigger": "Quick Commands",
+  "composer.quickCommands.saveCurrent": "현재 입력을 이 프로젝트의 Quick Command로 저장",
+  "composer.quickCommands.saveCurrentGlobal": "현재 입력을 모든 프로젝트의 Quick Command로 저장",
+  "composer.quickCommands.storageWriteFailed": "이 기기에 저장하지 못했습니다 — 앱을 다시 시작하면 목록이 사라질 수 있습니다.",
+  "composer.quickCommands.empty": "저장된 Quick Command가 없습니다.",
+  "composer.quickCommands.projectScope": "이 프로젝트",
+  "composer.quickCommands.globalScope": "모든 프로젝트",
+  "composer.quickCommands.remove": '"{label}" 삭제'
+};
 const aiCommitPrKo = {
   "aiCommitPr.stagedCount": "스테이지된 파일 {count}개",
   "aiCommitPr.noStaged": "스테이지된 변경이 없습니다.",
@@ -1404,8 +1625,187 @@ const projectLinksKo = {
   "projectLinks.mcpToggleHint": "켜면 AI가 관련 프로젝트로 작업을 제안했을 때 확인 없이 바로 진행됩니다.",
   "projectLinks.mcpToggleFailed": "설정을 바꾸지 못했습니다."
 };
-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, ...reviewNavigationKo, ...projectLinksKo, ...projectHandoffKo };
+const connectorReadinessKo = {
+  "connectorReadiness.badge": "커넥터 {count}건 확인 필요",
+  "connectorReadiness.state.needsAuth": "다시 연결 필요",
+  "connectorReadiness.state.runtimeFailed": "연결 실패",
+  "connectorReadiness.state.configMissing": "설정 없음",
+  "connectorReadiness.state.unknown": "상태 미확인"
+};
+const checkpointKo = {
+  "checkpoint.title": "파일 체크포인트",
+  "checkpoint.status.protected": "보호됨",
+  "checkpoint.status.legacy": "보호되지 않음",
+  "checkpoint.status.unavailable": "보호 사용 불가",
+  "checkpoint.refresh": "새로고침",
+  "checkpoint.timeline": "기록",
+  "checkpoint.timeline.empty": "아직 체크포인트가 없습니다.",
+  "checkpoint.timeline.snapshot": "스냅샷",
+  "checkpoint.timeline.rewind": "복원",
+  "checkpoint.preview": "미리보기",
+  "checkpoint.preview.title": "복원 미리보기",
+  "checkpoint.preview.empty": "되돌릴 파일 변경이 없습니다.",
+  "checkpoint.preview.confirm": "이 미리보기의 파일 변경을 확인했습니다",
+  "checkpoint.restore": "파일 상태 복원",
+  "checkpoint.restore.running": "파일 상태를 복원하는 중…",
+  "checkpoint.restore.completed": "파일 상태 복원이 완료되었습니다.",
+  "checkpoint.restore.partial": "일부 파일을 복원하지 못했습니다.",
+  "checkpoint.restore.stale": "파일 상태가 바뀌었습니다. 새 미리보기를 확인하세요.",
+  "checkpoint.restore.retry": "실패한 복원 다시 시도",
+  "checkpoint.restore.cancel": "복원 취소",
+  "checkpoint.pending.title": "보호 정책 확인 필요",
+  "checkpoint.pending.partialWarning": "이번 turn이 일부 실행되었을 수 있습니다.",
+  "checkpoint.pending.externalWarning": "외부 부작용은 다시 실행될 수 있습니다.",
+  "checkpoint.pending.cancel": "보호 유지하고 취소",
+  "checkpoint.pending.disable": "보호 해제",
+  "checkpoint.restartRequired": "계속하려면 daemon 세션을 재시작해야 합니다.",
+  "checkpoint.restart": "보호 없이 세션 재시작",
+  "checkpoint.restart.running": "세션을 재시작하는 중…",
+  "checkpoint.error.action": "체크포인트 작업을 완료하지 못했습니다.",
+  "checkpoint.action.restore": "되돌리기",
+  "checkpoint.action.delete": "삭제",
+  "checkpoint.action.skip": "보존",
+  "checkpoint.action.conflict": "충돌",
+  "checkpoint.failure.mutation-failed": "파일 변경 실패",
+  "checkpoint.failure.mutation-outcome-unknown": "결과를 알 수 없어 재확인이 필요함"
+};
+const localLoopKo = {
+  "preview.reasonNoProject": "선택된 프로젝트가 없습니다.",
+  "preview.reasonNoPort": "프로젝트에 미리보기 포트가 설정되어 있지 않습니다.",
+  "preview.reasonNoMachine": "프로젝트가 머신에 연결되어 있지 않습니다.",
+  "preview.reasonMachineMissing": "프로젝트의 머신을 찾을 수 없습니다.",
+  "preview.reasonMachineOffline": "{host} 머신이 오프라인입니다.",
+  "preview.reasonWorktreeNotRunning": "worktree 미리보기가 아직 실행 중이 아닙니다.",
+  "preview.reasonWorktreeMachineOffline": "worktree 미리보기 머신이 오프라인입니다.",
+  "preview.standaloneNoPortHint": "로컬 모드에서는 터미널이나 에이전트로 dev 서버를 실행하면 프로젝트 안에서 열린 포트를 감지해 여기에 표시합니다.",
+  "workCompletion.commitNoRemote": "원격 저장소가 없어 push와 PR 생성 없이 커밋까지만 요청합니다.",
+  "workCompletion.commitOnlyAction": "바로 커밋",
+  "projectSettings.workspaceDefaultPlaceholder": "기본 경로: {path}",
+  "preview.standaloneHostNotEmbeddable": "{host} 은(는) 앱 안에 표시할 수 없는 주소입니다. 이 컴퓨터(127.0.0.1)나 .local 호스트만 직접 표시합니다."
+};
+const localizationGapKo = {
+  "systemPrompt.loading": "프롬프트를 불러오는 중...",
+  "systemPrompt.presetsAria": "시스템 프롬프트 프리셋",
+  "systemPrompt.instructionsLabel": "지시문",
+  "systemPrompt.placeholder": "데스크탑 세션에 적용할 사용자 지시문",
+  "systemPrompt.charCount": "{count}자",
+  "projectInfo.projectId": "프로젝트 ID",
+  "projectInfo.workspace": "작업 폴더",
+  "projectInfo.devCommand": "개발 서버 명령",
+  "projectInfo.machinePlatform": "머신 플랫폼",
+  "projectInfo.electron": "Electron 버전",
+  "projectInfo.unknown": "알 수 없음",
+  "projectInfo.notConfigured": "설정되지 않음",
+  "projectInfo.unbound": "연결된 머신 없음",
+  "projectMeta.source": "소스",
+  "projectMeta.preview": "미리보기",
+  "projectMeta.machineUnbound": "미지정",
+  "projectMeta.previewUnavailable": "사용 불가",
+  "machineDialog.eyebrow": "세션 대상",
+  "machineDialog.title": "머신 선택",
+  "machineDialog.cancelAria": "머신 선택 취소",
+  "machineDialog.unknownPlatform": "플랫폼 미확인",
+  "newProject.repoInitFailed": "프로젝트는 만들었지만 Git 저장소 초기화에 실패했습니다: {detail}",
+  "standalone.defaultProjectName": "로컬 프로젝트"
+};
+const settingsInfoStructureKo = {
+  "about.mode": "모드",
+  "about.mode.demo": "데모 워크스페이스",
+  "about.mode.local": "로컬 워크스페이스",
+  "about.mode.guest": "로컬 워크스페이스 (Guest)",
+  "about.mode.cloud": "Saycode 계정 워크스페이스",
+  "about.appVersion": "앱 버전",
+  "about.userData": "사용자 데이터",
+  "about.unknown": "알 수 없음",
+  "about.updates": "업데이트",
+  "about.versionLine": "현재 {current} · 최신 {latest}",
+  "about.check": "업데이트 확인",
+  "about.download": "업데이트 다운로드",
+  "about.installRestart": "설치 후 재시작",
+  "about.status.checking": "업데이트를 확인하는 중…",
+  "about.status.available": "{version} 버전을 사용할 수 있습니다.",
+  "about.status.downloading": "업데이트 다운로드 중 {percent}%",
+  "about.status.downloaded": "업데이트를 내려받았습니다. 재시작하면 설치됩니다.",
+  "about.status.latest": "최신 버전을 사용 중입니다.",
+  "about.status.unsupported": "업데이트는 패키징된 macOS 빌드에서 제공됩니다.",
+  "about.status.error": "업데이트 확인에 실패했습니다.",
+  "about.status.idle": "업데이트는 자동으로 확인됩니다.",
+  "homeCard.owner": "소유자",
+  "homeCard.branch": "브랜치",
+  "homeCard.updated": "업데이트",
+  "homeCard.preview": "프리뷰",
+  "homeCard.previewAvailable": "사용 가능",
+  "homeCard.previewNotReady": "준비 안 됨",
+  "homeCard.deployed": "배포 시각",
+  "theme.title": "테마",
+  "theme.help": "자동은 macOS 시스템 설정을 따릅니다. 홈 화면 오른쪽 위 토글과 같은 설정입니다.",
+  "theme.auto": "자동",
+  "theme.light": "라이트",
+  "theme.dark": "다크",
+  "theme.autoTitle": "시스템 설정 따르기",
+  "theme.lightTitle": "라이트 모드",
+  "theme.darkTitle": "다크 모드",
+  "standaloneConnectivity.localServer": "로컬 happy-server",
+  "standaloneConnectivity.zrokShare": "zrok 공유 주소",
+  "standaloneConnectivity.zrokFixedName": "zrok 고정 이름",
+  "memoryLayerPanel.remoteNotice": "메모리 레이어 작업은 선택한 프로젝트의 원격 머신에서 실행됩니다.",
+  "memoryLayerPanel.remoteNoticeWithMachine": "메모리 레이어 작업은 선택한 프로젝트의 원격 머신({machine})에서 실행됩니다.",
+  "memoryLayerPanel.targetUnavailable": "원격 머신 대상을 사용할 수 없습니다.",
+  "memoryLayerPanel.checking": "claude-memory-layer를 확인하는 중…",
+  "memoryLayerPanel.installed": "설치됨",
+  "memoryLayerPanel.missing": "미설치",
+  "memoryLayerPanel.updateAvailable": "업데이트 가능",
+  "memoryLayerPanel.version": "버전 {version}",
+  "memoryLayerPanel.versionUnknown": "버전 알 수 없음",
+  "memoryLayerPanel.latest": "최신 {version}",
+  "memoryLayerPanel.notFound": "찾을 수 없음",
+  "memoryLayerPanel.unknown": "알 수 없음",
+  "memoryLayerPanel.notAssigned": "지정되지 않음",
+  "memoryLayerPanel.remoteMachine": "원격 머신",
+  "memoryLayerPanel.installGlobally": "전역 설치",
+  "memoryLayerPanel.updatePackage": "패키지 업데이트",
+  "memoryLayerPanel.reinstallHooks": "훅 다시 설치",
+  "memoryLayerPanel.installing": "설치하는 중…",
+  "memoryLayerPanel.installed.notice": "원격 머신에 claude-memory-layer가 준비됐습니다.",
+  "memoryLayerPanel.agentsTitle": "MCP 에이전트",
+  "memoryLayerPanel.detected": "감지됨",
+  "memoryLayerPanel.registered": "등록됨",
+  "memoryLayerPanel.register": "등록",
+  "memoryLayerPanel.registering": "등록하는 중…",
+  "memoryLayerPanel.registrationUpdated": "{agent} MCP 등록을 원격 머신에 반영했습니다.",
+  "memoryLayerPanel.noAgents": "에이전트 상태를 확인할 수 없습니다.",
+  "memoryLayerPanel.dashboardTitle": "프로젝트 대시보드",
+  "memoryLayerPanel.project": "프로젝트",
+  "memoryLayerPanel.noProject": "선택한 프로젝트 없음",
+  "memoryLayerPanel.path": "경로",
+  "memoryLayerPanel.machine": "머신",
+  "memoryLayerPanel.dashboard": "대시보드",
+  "memoryLayerPanel.remotePort": "원격 포트 {port}",
+  "memoryLayerPanel.notRunning": "실행 중 아님",
+  "memoryLayerPanel.open": "열기",
+  "memoryLayerPanel.stop": "중지",
+  "memoryLayerPanel.starting": "시작하는 중…",
+  "memoryLayerPanel.startDashboard": "대시보드 시작",
+  "memoryLayerPanel.dashboardStarted": "원격 메모리 대시보드를 시작했습니다.",
+  "memoryLayerPanel.dashboardStopped": "원격 메모리 대시보드를 중지했습니다.",
+  "memoryLayerPanel.lastOutput": "마지막 명령 출력",
+  "machineConsole.ownerMe": "나",
+  "overflowMenu.aria": "추가 액션 메뉴",
+  "overflowMenu.title": "추가 액션"
+};
+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, ...orgSearchKo, ...terminalFontKo, ...globalPauseKo, ...subagentKo, ...reviewNavigationKo, ...projectLinksKo, ...projectHandoffKo, ...chatFolderUploadKo, ...composerAddMenuKo, ...composerQuickCommandsKo, ...connectorReadinessKo, ...settingsInfoStructureKo, ...localLoopKo, ...localizationGapKo, ...checkpointKo, ...memoryGuardrailsKo, ...memoryEventsKo };
 const onboardingKo = {
+  "boot.stage.app": "앱 준비 중…",
+  "boot.stage.localRuntime": "로컬 작업공간 준비 중…",
+  "login.dialogTitle": "Saycode 계정으로 로그인",
+  "login.dialogDescription": "로컬 데이터는 이 컴퓨터에 그대로 남고, 현재 창만 클라우드 작업공간으로 전환됩니다.",
+  "login.dialogClose": "로그인 닫기",
+  "guestRecovery.title": "로컬 작업공간을 준비하지 못했어요",
+  "guestRecovery.body": "Saycode가 로컬 런타임을 시작하지 못했습니다. 다시 시도하거나 계정으로 로그인해 클라우드 작업공간을 사용하세요.",
+  "guestRecovery.retry": "다시 시도",
+  "guestRecovery.retrying": "로컬 작업공간 준비 중…",
+  "account.guest": "게스트",
+  "account.localWorkspace": "로컬 작업공간",
   "onboarding.dialogAria": "시작 설정",
   "onboarding.eyebrow": "처음 시작하기",
   "onboarding.title": "첫 작업까지 함께 준비해요",
@@ -1428,9 +1828,9 @@ const onboardingKo = {
   "onboarding.oneCommand.advanced": "고급: 수동 설치",
   "onboarding.localMachine.registering": "이 컴퓨터를 등록하는 중…",
   "onboarding.localMachine.registered": "✓ 이 컴퓨터가 등록되었습니다. 바로 작업할 수 있어요.",
-  "onboarding.localMachine.askTitle": "이 컴퓨터를 바로 사용",
-  "onboarding.localMachine.askBody": "이 컴퓨터에 이미 Happy 설정이 있습니다. 지금 설정으로 바꾸기 전에 원래 파일을 백업해 두고, 실패하면 되돌립니다.",
-  "onboarding.localMachine.askAction": "이 컴퓨터를 바로 사용",
+  "onboarding.localMachine.askTitle": "Saycode CLI 설치",
+  "onboarding.localMachine.askBody": "버튼을 누르면 이 컴퓨터의 기존 설정을 안전하게 백업한 뒤 Saycode CLI를 설치하고 연결합니다.",
+  "onboarding.localMachine.askAction": "Saycode CLI 설치",
   "onboarding.localMachine.failed": "자동 등록에 실패했습니다. 아래 명령으로 직접 설정할 수 있어요.",
   "onboarding.localMachine.retry": "다시 시도",
   "onboarding.localMachine.remoteHint": "다른 컴퓨터나 조직 공유 머신은 머신 설정에서 추가할 수 있어요.",
@@ -1453,7 +1853,101 @@ const onboardingKo = {
   "onboarding.refresh": "상태 다시 확인",
   "onboarding.allDone": "준비가 끝났습니다. 이제 첫 작업을 시작할 수 있어요.",
   "onboarding.resume": "시작 설정 이어하기",
-  "onboarding.preflight": "{provider}를 사용하기 전에 로그인을 완료해 주세요."
+  "onboarding.preflight": "{provider}를 사용하기 전에 로그인을 완료해 주세요.",
+  "onboarding.page.happy": "Saycode CLI",
+  "onboarding.page.agents": "AI 도구",
+  "onboarding.page.notifications": "알림",
+  "onboarding.page.happyTitle": "Saycode CLI 준비",
+  "onboarding.page.happyBody": "설치와 버전을 확인하고, 필요한 작업만 이 화면에서 실행합니다.",
+  "onboarding.page.agentsTitle": "Claude Code와 Codex",
+  "onboarding.page.agentsBody": "사용할 AI 도구를 설치하고 계정 로그인을 완료하세요.",
+  "onboarding.page.notificationsTitle": "알림 설정",
+  "onboarding.page.notificationsBody": "응답 요청과 작업 완료를 놓치지 않도록 알림과 사운드를 설정하세요.",
+  "onboarding.page.back": "이전",
+  "onboarding.page.continue": "계속",
+  "onboarding.page.addProject": "첫 프로젝트 추가",
+  "onboarding.page.configured": "설정됨",
+  "onboarding.page.optional": "선택",
+  "onboarding.page.testNotification": "테스트 알림 보내기",
+  "onboarding.page.testNotificationSending": "테스트 알림 보내는 중…",
+  "onboarding.page.testNotificationSuccess": "테스트 알림을 보냈습니다.",
+  "onboarding.page.testNotificationUnsupported": "이 환경에서는 OS 알림을 사용할 수 없습니다.",
+  "onboarding.page.testNotificationFailed": "테스트 알림을 보내지 못했습니다.",
+  "onboarding.page.testNotificationTitle": "Saycode 알림 테스트",
+  "onboarding.page.testNotificationBody": "알림이 잘 도착하고 있어요.",
+  "onboarding.cli.installed": "설치됨",
+  "onboarding.cli.standaloneBody": "Standalone 앱에 포함된 로컬 런타임을 사용합니다.",
+  "onboarding.cli.currentBody": "이 컴퓨터의 Saycode CLI가 최신 버전입니다.",
+  "onboarding.cli.installTitle": "이 컴퓨터에 CLI가 필요합니다",
+  "onboarding.cli.installBody": "Saycode가 설치, 계정 연결, 최종 확인을 순서대로 진행합니다.",
+  "onboarding.cli.installAction": "Saycode CLI 설치",
+  "onboarding.cli.installing": "설치 중…",
+  "onboarding.cli.verifying": "설치 상태 확인 중…",
+  "onboarding.cli.stage.prepare": "설치 준비",
+  "onboarding.cli.stage.install": "CLI 설치 및 연결",
+  "onboarding.cli.stage.verify": "설치 상태 확인",
+  "onboarding.cli.updateTitle": "업데이트가 필요합니다",
+  "onboarding.cli.updateAction": "업데이트 실행",
+  "onboarding.cli.updating": "업데이트 후 설치 상태를 확인하는 중…",
+  "onboarding.cli.checking": "설치 상태 확인 중…",
+  "onboarding.cli.checkFailedTitle": "설치 상태를 확인하지 못했습니다",
+  "onboarding.cli.checkFailedBody": "연결을 확인한 뒤 다시 시도해 주세요.",
+  "onboarding.cli.retry": "다시 확인",
+  "onboarding.cli.nav.checking": "확인 중",
+  "onboarding.cli.nav.install-required": "설치 필요",
+  "onboarding.cli.nav.installing": "설치 중",
+  "onboarding.cli.nav.installed": "설치됨",
+  "onboarding.cli.nav.update-required": "업데이트 필요",
+  "onboarding.cli.nav.updating": "업데이트 중",
+  "onboarding.cli.nav.failed": "확인 필요",
+  "onboarding.provider.checking": "확인 중",
+  "onboarding.provider.connected": "연결됨",
+  "onboarding.provider.install-required": "설치 필요",
+  "onboarding.provider.login-required": "로그인 필요",
+  "onboarding.provider.failed": "확인 실패",
+  "onboarding.provider.needsConnection": "연결 필요",
+  "firstProject.title": "프로젝트 추가",
+  "firstProject.description": "Saycode를 시작하려면 프로젝트를 추가하세요.",
+  "firstProject.close": "프로젝트 추가 창 닫기",
+  "firstProject.host": "호스트",
+  "firstProject.selectHost": "호스트 선택",
+  "firstProject.noHost": "사용 가능한 머신 없음",
+  "firstProject.thisComputer": "이 컴퓨터",
+  "firstProject.remoteHost": "원격 머신",
+  "firstProject.online": "온라인",
+  "firstProject.offline": "오프라인",
+  "firstProject.addMachine": "다른 머신 추가",
+  "firstProject.addMachineHint": "원격 머신 또는 공유 머신 연결",
+  "firstProject.startMethod": "프로젝트 시작 방법",
+  "firstProject.otherWays": "프로젝트를 추가하는 다른 방법",
+  "firstProject.source.existing-folder.title": "기존 폴더 열기",
+  "firstProject.source.existing-folder.description": "이 컴퓨터나 선택한 머신의 폴더를 사용합니다.",
+  "firstProject.source.zip.title": "ZIP으로 가져오기",
+  "firstProject.source.zip.description": "압축 파일에서 로컬 프로젝트를 만듭니다.",
+  "firstProject.source.git.title": "Git URL에서 복제",
+  "firstProject.source.git.description": "원격 Git 저장소를 선택한 머신에 복제합니다.",
+  "firstProject.source.blank.title": "새 프로젝트 만들기",
+  "firstProject.source.blank.description": "빈 폴더에서 새 프로젝트를 시작합니다.",
+  "firstProject.form.back": "이전",
+  "firstProject.form.machine": "프로젝트를 만들 머신",
+  "firstProject.form.blank.title": "새 프로젝트",
+  "firstProject.form.blank.description": "이름을 정하면 로컬에 새 프로젝트를 만듭니다.",
+  "firstProject.form.git.title": "코드 저장소 가져오기",
+  "firstProject.form.git.description": "Git 주소를 입력하면 이 컴퓨터에 저장소를 복제합니다.",
+  "firstProject.form.existing-folder.title": "기존 폴더 사용",
+  "firstProject.form.existing-folder.description": "로컬 폴더를 Saycode 프로젝트로 연결합니다.",
+  "firstProject.form.zip.title": "ZIP으로 가져오기",
+  "firstProject.form.zip.description": "압축 파일을 선택하면 프로젝트 이름을 자동으로 정합니다.",
+  "firstProject.form.zip.pick": "ZIP 파일 선택",
+  "firstProject.form.zip.drop": "ZIP 파일을 선택하거나 여기로 드래그하세요",
+  "guestRecovery.detailsSummary": "진단 정보 보기",
+  "onboarding.cli.globalInstallTitle": "터미널에서도 Saycode CLI 사용하기",
+  "onboarding.cli.globalInstallBody": "선택 사항입니다. npm으로 전역 happy 명령을 설치합니다: npm i -g @buzzni/happy-cli",
+  "onboarding.cli.globalInstallAction": "전역 CLI 설치",
+  "onboarding.cli.globalInstalling": "설치 중… 몇 분 걸릴 수 있습니다",
+  "onboarding.cli.globalInstalled": "전역 CLI 설치됨 ({version})",
+  "onboarding.cli.globalInstallFailed": "전역 CLI 설치 실패: {detail}",
+  "onboarding.cli.globalInstalledUnversioned": "전역 CLI 설치됨"
 };
 const standaloneRemoteOnboardingKo = {
   "onboarding.optional": " (선택)",
@@ -1500,6 +1994,44 @@ const ko = {
   "common.reset": "초기화",
   "common.cancel": "취소",
   "common.close": "닫기",
+  "networkDataSaver.transferConfirm": "{operation} 작업은 데이터를 많이 사용할 수 있습니다. 예상 크기: {size}. 계속할까요?",
+  "networkDataSaver.sizeUnknown": "알 수 없음",
+  "networkDataSaver.operation.update-download": "업데이트 다운로드",
+  "networkDataSaver.operation.file-upload": "파일 업로드",
+  "networkDataSaver.operation.folder-upload": "폴더 업로드",
+  "networkDataSaver.operation.file-download": "파일 다운로드",
+  "networkDataSaver.operation.project-deploy": "프로젝트 배포",
+  "networkDataSaver.operation.project-import": "프로젝트 가져오기",
+  "networkDataSaver.title": "네트워크 데이터 절약",
+  "networkDataSaver.description": "macOS가 비용이 들거나 저데이터 모드인 경로로 판단하면 백그라운드 데이터 사용을 자동으로 줄입니다.",
+  "networkDataSaver.loading": "네트워크 상태를 확인하는 중…",
+  "networkDataSaver.unsupported": "이 앱 버전에서는 네트워크 비용 상태를 확인할 수 없습니다.",
+  "networkDataSaver.status.active": "데이터 절약 중",
+  "networkDataSaver.status.inactive": "데이터 절약 꺼짐",
+  "networkDataSaver.modeLabel": "절약 방식",
+  "networkDataSaver.mode.automatic": "자동",
+  "networkDataSaver.mode.always-save": "항상 절약",
+  "networkDataSaver.mode.never-save": "절약 안 함",
+  "networkDataSaver.interfaceLabel": "현재 연결",
+  "networkDataSaver.interface.wifi": "Wi-Fi",
+  "networkDataSaver.interface.wired-ethernet": "유선 이더넷",
+  "networkDataSaver.interface.cellular": "셀룰러",
+  "networkDataSaver.interface.loopback": "로컬 연결",
+  "networkDataSaver.interface.other": "기타 연결",
+  "networkDataSaver.interface.unknown": "알 수 없음",
+  "networkDataSaver.reasonLabel": "판단 이유",
+  "networkDataSaver.reason.expensive": "비용이 드는 네트워크로 감지됨",
+  "networkDataSaver.reason.constrained": "저데이터 모드로 감지됨",
+  "networkDataSaver.reason.offline": "오프라인",
+  "networkDataSaver.reason.unrestricted": "일반 네트워크로 감지됨",
+  "networkDataSaver.reason.unknown": "네트워크 비용 상태를 알 수 없음",
+  "networkDataSaver.reason.user-always": "사용자가 항상 절약을 선택함",
+  "networkDataSaver.reason.user-never": "사용자가 절약 안 함을 선택함",
+  "networkDataSaver.deferred.title": "절약 중 지연되는 작업",
+  "networkDataSaver.activeHelp": "수동 새로고침은 계속 사용할 수 있고, 대용량 작업은 확인 후 한 번 허용할 수 있습니다.",
+  "networkDataSaver.deferred.model": "난이도 모델 최초 다운로드",
+  "networkDataSaver.deferred.memory": "Memory Layer 대화 백필",
+  "networkDataSaver.deferred.gitPr": "백그라운드 Git 및 PR 새로고침",
   "happyCliUpdate.title": "Happy CLI 업데이트가 있습니다",
   "happyCliUpdate.checkTitle": "Happy CLI 업데이트 확인",
   "happyCliUpdate.managerTitle": "Happy CLI 업데이트 관리",
@@ -1526,7 +2058,7 @@ const ko = {
   "happyCliUpdate.cancel": "취소",
   // Boot screen
   "boot.preparing": "Saycode 준비 중...",
-  "boot.stage.credentials": "자격 증명 확인 중…",
+  "boot.stage.credentials": "로그인 상태 확인 중…",
   "boot.stage.workspace": "워크스페이스 불러오는 중…",
   // Language selection (first run)
   "language.select.title": "언어를 선택하세요",
@@ -1591,8 +2123,8 @@ const ko = {
   "zipImport.transferFailed": "{count}개 파일을 전송하지 못했습니다. ({path}: {reason})",
   "zipImport.machineInfoMissing": "머신 정보(homeDir/workspaceRoot)가 부족해 가져올 위치를 결정할 수 없습니다.",
   "zipImport.emptyArchive": "압축 파일 안에 가져올 파일이 없습니다.",
-  "sidebarPanel.showAllChats": "전체 대화 보기 ({count}개 더 있음)",
-  "sidebarPanel.showAllChatsAria": "{project}의 전체 대화 보기",
+  "sidebarPanel.showAllChats": "대화 더보기 ({count}개 남음)",
+  "sidebarPanel.showAllChatsAria": "{project}에서 대화 더 보기",
   "sidebarPanel.newChatAria": "{name} 프로젝트에서 새 대화 시작",
   "home.eyebrow": "워크스페이스 홈",
   "home.newProject": "새 프로젝트",
@@ -1647,7 +2179,6 @@ const ko = {
   "newProject.gitNeedUrl": "Git 저장소 주소를 입력해 주세요.",
   "newProject.importDone": "'{name}' 프로젝트에 파일 {count}개를 가져왔습니다.",
   "newProject.importFailed": "'{name}' 프로젝트는 생성했지만 파일을 가져오지 못했습니다. {detail}",
-  "composer.attachFile": "파일 첨부",
   "composer.attachNeedMachine": "첨부하려면 머신 연결이 필요합니다",
   "composer.attachNoMachine": "파일을 업로드할 머신을 찾을 수 없습니다.",
   "composer.attachUploadFailed": "파일을 업로드하지 못했습니다.",
@@ -1674,7 +2205,7 @@ const ko = {
   "workspace.orgAdminMenuEntry": "조직 관리",
   // Org admin console (specs/desktop-org-admin-console)
   "orgAdmin.title": "조직 관리",
-  "orgAdmin.eyebrow": "Organization",
+  "orgAdmin.eyebrow": "조직",
   "orgAdmin.close": "닫기",
   "orgAdmin.tab.members": "멤버 관리",
   "orgAdmin.tab.settings": "조직 설정",
@@ -1703,7 +2234,7 @@ const ko = {
   "orgAdmin.settingsSaved": "조직 설정이 저장되었습니다.",
   "orgAdmin.tab.audit": "감사 로그",
   "orgAdmin.tab.machineMonitor": "머신 모니터링",
-  "orgAdmin.tab.skill": "Skill",
+  "orgAdmin.tab.skill": "스킬",
   "orgAdmin.tab.projects": "프로젝트",
   "orgAdmin.skillSearch": "Skill 검색",
   "orgAdmin.skillSearchPlaceholder": "Skill 또는 설명 검색...",
@@ -1818,7 +2349,7 @@ const ko = {
   "orgAdmin.githubOwnerPlaceholder": "예: myteam",
   "orgAdmin.label": "레이블 (선택)",
   "orgAdmin.labelPlaceholder": "Main Account, Backup Account 등",
-  "orgAdmin.githubPat": "Personal Access Token",
+  "orgAdmin.githubPat": "개인 액세스 토큰",
   "orgAdmin.githubPatRequired": "PAT를 입력하세요.",
   "orgAdmin.githubPatPlaceholder": "github_pat_... 형식의 PAT",
   "orgAdmin.githubPatUnchanged": "변경 없음 (기존 PAT 유지)",
@@ -1941,7 +2472,7 @@ const ko = {
   // Super admin console (specs/desktop-org-admin-console)
   "systemAdmin.menuEntry": "슈퍼 관리자",
   "systemAdmin.title": "슈퍼 관리자",
-  "systemAdmin.eyebrow": "System",
+  "systemAdmin.eyebrow": "시스템",
   "systemAdmin.companiesTitle": "전체 조직",
   "systemAdmin.createCompany": "조직 생성",
   "systemAdmin.create": "생성",
@@ -2016,7 +2547,7 @@ const ko = {
   "panel.recovery.loginDesc": "로그인 후 터미널을 시작할 수 있습니다.",
   // Chat composer
   "composer.messageAria": "메시지",
-  "composer.placeholder": "데스크톱에서 보낼 메시지를 입력",
+  "composer.placeholder": "메시지를 입력하세요",
   "composer.promptSuggestionPaused": "{window} 사용량 {percent}% — 사용량 경고 중에는 Claude가 추천 질문을 만들지 않습니다",
   "composer.promptSuggestionPausedReset": "{reset} 초기화",
   "composer.starting": "시작 중...",
@@ -2069,6 +2600,7 @@ const ko = {
   "sessionWorktree.branch": "브랜치: {branch}",
   "sessionWorktree.path": "경로: {path}",
   "sessionWorktree.merged": "병합됨",
+  "chatPullRequest.open": "{repository} PR #{number} 열기",
   // Project git controls
   "gitControls.branchLoading": "Git branch 확인 중",
   "gitControls.noRemote": "origin remote 또는 branch를 찾을 수 없습니다.",
@@ -2078,9 +2610,9 @@ const ko = {
   "gitControls.manageBranchTitle": "Branch 변경 및 생성",
   "gitControls.manageBranchTitleWithDesc": "Branch 변경 및 생성 · {description}",
   "gitControls.pullAria": "{branch} 브랜치 pull",
-  "gitControls.pullTitle": "{branch} pull",
+  "gitControls.pullTitle": "{branch} 가져오기(pull)",
   "gitControls.pushAria": "{branch} 브랜치 push",
-  "gitControls.pushTitle": "{branch} push",
+  "gitControls.pushTitle": "{branch} 올리기(push)",
   "gitControls.manageWorktreeAria": "{name} worktree 관리",
   "gitControls.manageWorktreeTitle": "Worktree 관리",
   "gitControls.operationResultDialogTitle": "{label} 결과",
@@ -2525,6 +3057,12 @@ const ko = {
   // Owner workspace sync (team share) messages
   "ownerSync.hint.credentialsUnavailable": "원격 머신 / 인증 정보가 없어요. 프로젝트 메뉴에서 머신을 한 번 연결한 뒤 다시 시도해 주세요.",
   "ownerSync.successConnectionUpdated": "저장소 연결을 변경했습니다.",
+  "ownerSync.deferred.workspaceDirNotFound": "저장소 연결은 완료됐지만 워크스페이스 폴더를 찾지 못해 코드는 아직 저장하지 않았어요. 프로젝트를 연 뒤 다시 저장해 주세요.",
+  "ownerSync.deferred.workspaceEmpty": "저장소 연결은 완료됐지만 저장할 파일이 없어 코드는 아직 저장하지 않았어요. 파일을 만든 뒤 다시 저장해 주세요.",
+  "ownerSync.deferred.credentialsUnavailable": "저장소 연결은 완료됐지만 머신 자격 증명을 사용할 수 없어 코드는 아직 저장하지 않았어요. 자격 증명을 확인한 뒤 다시 저장해 주세요.",
+  "ownerSync.deferred.machineHomeUnresolvable": "저장소 연결은 완료됐지만 머신 홈 폴더를 확인할 수 없어 코드는 아직 저장하지 않았어요. 머신 홈 폴더를 확인한 뒤 다시 저장해 주세요.",
+  "ownerSync.deferred.machineUnavailable": "저장소 연결은 완료됐지만 머신이 오프라인이라 코드는 아직 저장하지 않았어요. 머신을 다시 연결한 뒤 저장해 주세요.",
+  "ownerSync.deferred.default": "저장소 연결은 완료됐지만 코드는 아직 저장하지 않았어요. 프로젝트와 머신 상태를 확인한 뒤 다시 저장해 주세요.",
   "ownerSync.hint.machineHomeUnresolvable": "원격 머신을 찾을 수 없어요. happy daemon 이 실행 중인지 확인해 주세요.",
   "ownerSync.hint.machineUnavailable": "원격 머신 daemon 이 오프라인이에요. happy daemon 을 시작한 뒤 다시 시도해 주세요.",
   "ownerSync.hint.missingTools": "원격 머신에 git / tar 가 설치되어 있지 않아요. 운영자에게 설치 요청을 보내주세요.",
@@ -2787,6 +3325,22 @@ const ko = {
   "community.cloneFailed": "커뮤니티 프로젝트를 받아오지 못했습니다.",
   "login.credentialsRequired": "이메일과 비밀번호를 입력해주세요.",
   "login.loginFailed": "로그인에 실패했습니다.",
+  "login.mfaTitle": "추가 인증",
+  "login.mfaLead": "이 계정은 2단계 인증이 필요합니다. 인증 앱의 6자리 코드를 입력해주세요.",
+  "login.mfaMethodsLead": "이 계정은 2단계 인증이 필요합니다. 패스키 또는 등록한 인증 앱으로 인증해주세요.",
+  "login.mfaPasskey": "패스키로 인증",
+  "login.mfaPasskeyRetry": "패스키 인증 다시 열기",
+  "login.mfaPasskeyWaiting": "시스템 브라우저에서 iPhone 또는 이 Mac의 패스키 인증을 완료해주세요.",
+  "login.mfaTotpFallback": "브라우저를 닫아도 인증 앱 코드로 계속할 수 있습니다.",
+  "login.mfaCodeLabel": "인증 코드",
+  "login.mfaCodePlaceholder": "6자리 숫자",
+  "login.mfaSubmit": "인증하고 로그인",
+  "login.mfaCancel": "다른 계정으로 로그인",
+  "login.mfaInvalidCode": "인증 코드가 올바르지 않습니다. 다시 시도해주세요.",
+  "login.mfaExpired": "인증 시간이 만료되었습니다. 다시 로그인해주세요.",
+  "login.mfaRateLimited": "시도가 너무 많습니다. 잠시 후 다시 시도해주세요.",
+  "login.mfaUnsupported": "이 계정에서 사용할 수 있는 2단계 인증 방법이 없습니다. 웹에서 인증 앱 또는 패스키를 등록한 뒤 다시 시도해주세요.",
+  "login.mfaPasskeyFailed": "패스키 인증을 시작하지 못했습니다. 다시 시도하거나 인증 앱 코드를 사용해주세요.",
   "standalone.startFailed": "로컬 standalone 서버를 시작하지 못했습니다.",
   "workspace.loadFailed": "워크스페이스를 불러오지 못했습니다.",
   "standalone.modeStartFailed": "로컬 standalone 모드를 시작하지 못했습니다.",
@@ -2974,6 +3528,12 @@ const ko = {
   "worktreeOp.merging": "머지 중...",
   "worktreeOp.mergeFailed": "머지에 실패했습니다.",
   "worktreeOp.mergeDone": "머지 완료. 이제 worktree를 정리할 수 있습니다.",
+  "worktreeOp.demoAutoMergeBlocked": "데모 모드에서는 auto-merge를 사용할 수 없습니다.",
+  "worktreeOp.autoMergeEnabling": "auto-merge 켜는 중...",
+  "worktreeOp.autoMergeDisabling": "auto-merge 끄는 중...",
+  "worktreeOp.autoMergeEnabled": "auto-merge가 켜졌습니다. 머지 조건(체크·필수 리뷰 등)을 모두 충족하면 자동으로 머지됩니다.",
+  "worktreeOp.autoMergeDisabled": "auto-merge가 꺼졌습니다.",
+  "worktreeOp.autoMergeFailed": "auto-merge 설정을 바꾸지 못했습니다.",
   "worktreeOp.checkingStatus": "worktree 상태 확인 중...",
   "worktreeOp.forceDeleteUnpushed": "worktree에 푸시되지 않은 커밋 {count}개가 있습니다. 강제로 삭제할까요? 커밋이 사라집니다.",
   "worktreeOp.forceDeleteDirty": "worktree에 정리되지 않은 변경이 있습니다. 강제로 삭제할까요? 변경 사항이 사라집니다.",
@@ -3397,6 +3957,7 @@ const ko = {
   "file.readFailed": "파일을 읽지 못했습니다.",
   "session.loadMessagesFailed": "대화 메시지를 불러올 수 없습니다.",
   "session.sendToSessionFailed": "대화에 메시지를 보낼 수 없습니다.",
+  "session.sendBlockedAccountKeyLocked": "이 대화는 계정 키로 잠겨 있습니다. 잠금을 해제한 뒤 다시 시도하세요.",
   "message.noEncryptKey": "메시지 삭제 이벤트를 암호화할 세션 키를 찾을 수 없습니다.",
   "machineSel.boundMissing": "프로젝트에 연결된 머신 정보를 찾을 수 없습니다. 새로고침 후 다시 시도해주세요.",
   "machineSel.connectedMachine": "연결된 머신",
@@ -3594,6 +4155,8 @@ const ko = {
   // ProjectDocumentViewer
   "inlinePreview.openInViewer": "파일 뷰어로 열기",
   "inlinePreview.loading": "미리보기를 불러오는 중",
+  "inlinePreview.loadFailed": "미리보기를 불러오지 못했습니다.",
+  "inlinePreview.retry": "다시 시도",
   "documentViewer.docxConvertFailed": "DOCX 문서를 변환하지 못했습니다.",
   "documentViewer.pdfViewer": "{name} PDF 뷰어",
   "documentViewer.pdfPreparing": "PDF를 준비하는 중...",
@@ -3644,7 +4207,7 @@ const ko = {
   "connectors.browserHint": "브라우저에서 승인을 마친 뒤 앱으로 돌아오세요.",
   "connectors.availableNextTurn": "연결됐습니다. 다음 메시지부터 사용할 수 있습니다.",
   "connectors.readOnlyNote": "읽기 전용으로만 연결합니다.",
-  "connectors.apiKeyLabel": "KNOI API Key",
+  "connectors.apiKeyLabel": "KNOI API 키",
   "connectors.apiKeyEnter": "API Key 입력",
   "connectors.apiKeyReplace": "API Key 교체",
   "connectors.apiKeySave": "API Key 저장",
@@ -3657,7 +4220,7 @@ const ko = {
   "remoteFile.saveFailed": "파일을 저장하지 못했습니다.",
   "fileDownload.invalidData": "다운로드할 파일 데이터가 올바르지 않습니다.",
   "fileDownload.tooLarge": "다운로드 파일은 100 MiB 이하만 지원합니다.",
-  "codex.needsLatestCli": "GPT-5.6을 사용하려면 최신 Codex CLI가 필요합니다. `npm install -g @openai/codex@latest`로 업데이트한 뒤 새 대화를 시작해 주세요.",
+  "codex.needsLatestCli": "선택한 모델을 사용하려면 최신 Codex CLI가 필요합니다. `npm install -g @openai/codex@latest`로 업데이트한 뒤 새 대화를 시작해 주세요.",
   "codex.error": "Codex 오류: {detail}",
   // specs/desktop-error-surface — 실패 알림의 계층 배지와 복구 액션
   "errorSurface.layer.provider": "Provider 오류",
@@ -3784,20 +4347,24 @@ const ko = {
   "settingsTab.language": "언어",
   "settingsTab.machines": "머신",
   "settingsTab.mobile": "모바일 연결",
+  "settingsTab.network": "네트워크 데이터 절약",
   "settingsTab.env": "환경 변수",
   "settingsTab.security": "보안",
-  "settingsTab.memory": "Memory",
+  "settingsTab.memory": "메모리",
   "settingsTab.connectors": "커넥터",
   "settingsTab.myAiCredentials": "내 AI 계정",
   "settingsTab.extensions": "확장",
   "settingsTab.about": "정보",
   "settingsTab.shortcuts": "단축키",
-  "extensions.help": "필요한 기능만 로컬 확장 패키지로 설치하고 관리합니다.",
+  "extensions.help": "필요한 기능만 공식 또는 로컬 확장 패키지로 설치하고 관리합니다.",
   "extensions.installLocal": "로컬 파일 설치",
   "extensions.loading": "설치된 확장을 불러오는 중입니다.",
   "extensions.empty": "설치된 확장이 없습니다.",
   "extensions.permissions": "권한",
   "extensions.noPermissions": "요청 권한 없음",
+  "extensions.permission.browserViewerOpen": "접근 가능한 온라인 머신에서 원격 Chrome 화면을 준비해 기본 브라우저로 엽니다. 소프트웨어 설치는 포함하지 않습니다.",
+  "extensions.permission.browserViewerInstall": "선택한 머신에 원격 화면용 시스템 패키지(Xvfb/noVNC)를 설치합니다. Chrome 설치는 포함하지 않습니다.",
+  "extensions.permission.browserViewerInstallChrome": "선택한 머신에 Google Chrome을 설치합니다. 머신의 시스템 소프트웨어가 변경됩니다.",
   "extensions.approvePermission": "'{permission}' 승인",
   "extensions.revokePermission": "'{permission}' 철회",
   "extensions.enable": "활성화",
@@ -3816,7 +4383,9 @@ const ko = {
   "extensions.developmentSource": "개발 빌드: {directory}",
   "extensions.apiDeprecated": "업데이트 필요",
   "extensions.apiDeprecatedHint": "이전 확장 API({apiVersion})로 동작 중이며, 다음 업데이트에서 지원이 끝납니다.",
-  "extensions.runtime.inactive": "비활성",
+  "extensions.enablement.enabled": "활성화됨",
+  "extensions.enablement.disabled": "비활성화됨",
+  "extensions.runtime.inactive": "대기 중",
   "extensions.runtime.active": "실행 중",
   "extensions.runtime.quarantined": "격리됨",
   "shortcuts.title": "단축키",
@@ -3909,7 +4478,7 @@ const ko = {
   "review.self.disabledWaiting": "먼저 대기 중인 질문이나 권한 요청에 응답해주세요.",
   "review.self.rounds": "반복 횟수",
   "review.self.roundsHint": "medium 이상 지적이 나오면 남은 횟수만큼 리뷰를 자동으로 이어갑니다. low·nit만 남으면 바로 끝냅니다.",
-  "review.self.appOpenHint": "앱이 실행 중일 때만 이어집니다. 앱을 완전히 종료하면 멈추고, 다시 열면 남은 횟수부터 이어갑니다.",
+  "review.self.appOpenHint": "상시 실행 에이전트가 최신 버전이면 앱을 완전히 종료해도 계속됩니다. 지원하지 않는 환경에서는 앱이 켜져 있어야 합니다.",
   "review.self.loopActive": "반복 리뷰 {round}/{total} 진행 중",
   "review.self.loopStop": "반복 중지",
   "review.self.loopDismiss": "기록 지우기",
@@ -3920,7 +4489,7 @@ const ko = {
   "review.self.loopReason.roundsExhausted": "지정한 횟수를 모두 사용",
   "review.self.loopReason.unstructured": "결과를 판정할 수 없어 중단",
   "review.self.loopReason.sendFailed": "다음 라운드를 보내지 못함",
-  "review.self.loopReason.cancelled": "다른 메시지가 들어와 중단",
+  "review.self.loopReason.cancelled": "사용자 요청으로 중단",
   "review.history.title": "독립 리뷰 기록",
   "review.storage.writeFailed": "이 기기에 리뷰 기록을 저장하지 못했습니다. 앱을 다시 켜면 이 목록이 비어 있을 수 있습니다.",
   "review.recovery.title": "기록 복구",
@@ -3980,7 +4549,7 @@ const ko = {
   "review.error.sourceProjectMissing": "리뷰 원본 프로젝트를 찾을 수 없습니다.",
   "review.error.sourceSessionMissing": "리뷰 원본 대화를 찾을 수 없습니다.",
   // Project processes (specs/desktop-process-ownership R4)
-  "projectProcesses.eyebrow": "Running Processes",
+  "projectProcesses.eyebrow": "실행 중인 프로세스",
   "projectProcesses.dialogAria": "{name} 프로세스 보기",
   "projectProcesses.closeAria": "프로세스 보기 닫기",
   "projectProcesses.listAria": "{name}의 실행 중인 프로세스 목록",
@@ -4158,6 +4727,7 @@ function interruptDecision(state) {
   return state.phase === "idle" ? "exit-cli" : "open-menu";
 }
 const AGENT_UNTIL_VALUES = ["turn-end", "waiting-input", "completed"];
+const STATE_WINDOW_MESSAGES = 50;
 const DEFAULT_WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
 const MAX_WAIT_TIMEOUT_MS = 60 * 60 * 1e3;
 function isAgentUntil(value2) {
@@ -4358,6 +4928,12 @@ function collectFlags(argv, startIndex) {
         flags.last = takeNumber(argv, index, token);
         index += 1;
         break;
+      case "--status":
+        flags.status = true;
+        break;
+      case "--any":
+        flags.any = true;
+        break;
       case "--wait":
         flags.wait = true;
         break;
@@ -4513,12 +5089,13 @@ Options
 
 Agent commands (machine-readable JSON on stdout, exit 3 on failure)
   agent whoami                   Show this session's contact point and limits
-  agent ls                       List sibling sessions in the same directory tree
-  agent read <session> [--last n]        Recent messages + completion signal
+  agent ls [--status]            List sessions in scope; --status adds state/pending/cursor
+  agent read <session> [--last n] [--since seq]  Recent messages + completion signal
   agent wait <session> --until <state>   turn-end | waiting-input | completed
+  agent wait --any <s1> <s2>... --until <state>  Block until any of them holds it
   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 steer <session> <text>        Redirect an active response (depth 0: any in scope)
+  agent stop <session>                Stop an active response (depth 0: any in scope)
   agent spawn --prompt <text> [--agent n] [--model n] [--effort n]
                                       Start a sibling with an explicit execution choice
   agent spawn --prompt <text> --file <path>  ...with context files it reads first
@@ -6904,6 +7481,293 @@ function decryptJsonWithCandidates(blob, keys) {
   decryptCacheSet(blob, keys, null);
   return null;
 }
+function bounded(value2, maxLength) {
+  if (typeof value2 !== "string" || value2.length === 0 || value2.length > maxLength) return void 0;
+  return value2;
+}
+function boundedAllowEmpty(value2, maxLength) {
+  if (typeof value2 !== "string" || value2.length > maxLength) return void 0;
+  return value2;
+}
+function parsePasswordLoginResponse(raw) {
+  if (raw && typeof raw === "object" && !Array.isArray(raw) && raw.mfaRequired === true) {
+    const value2 = raw;
+    const loginToken = bounded(value2.loginToken, 512);
+    if (loginToken === void 0) throw new Error("CLOUD_LOGIN_RESPONSE_INVALID");
+    const methods = Array.isArray(value2.methods) ? value2.methods.filter((method) => typeof method === "string") : [];
+    return {
+      kind: "mfa-required",
+      challenge: {
+        loginToken,
+        ...typeof value2.expiresAt === "string" ? { expiresAt: value2.expiresAt } : {},
+        methods,
+        // 형이 어긋나면 보수적으로 "등록 필요" — 코드 입력을 헛되이 시키지 않는다.
+        enrollmentRequired: value2.enrollmentRequired !== false
+      }
+    };
+  }
+  return { kind: "success", result: parseCloudLoginResult(raw) };
+}
+function parseKdfParams(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
+  const entries = Object.entries(value2);
+  if (entries.length > 8) return void 0;
+  const parsed = {};
+  for (const [key, entry] of entries) {
+    if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(key)) return void 0;
+    if (typeof entry === "string") {
+      if (entry.length > 128) return void 0;
+    } else if (typeof entry !== "number" && typeof entry !== "boolean") return void 0;
+    parsed[key] = entry;
+  }
+  return parsed;
+}
+function parseUnlockMethod(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
+  const method = value2;
+  const id = bounded(method.id, 128);
+  const type = method.type;
+  const kdfAlgorithm = bounded(method.kdfAlgorithm, 128);
+  const kdfParams = parseKdfParams(method.kdfParams);
+  const salt = boundedAllowEmpty(method.salt, 256);
+  const wrappedMasterKey = bounded(method.wrappedMasterKey, 16384);
+  if (!id || !/^[A-Za-z0-9_-]+$/.test(id) || type !== "password" && type !== "recovery" && type !== "device" || !kdfAlgorithm || !kdfParams || salt === void 0 || !wrappedMasterKey) return void 0;
+  const revision = method.revision;
+  if (revision !== void 0 && (!Number.isSafeInteger(revision) || revision < 1)) return void 0;
+  return {
+    id,
+    type,
+    kdfAlgorithm,
+    kdfParams,
+    salt,
+    wrappedMasterKey,
+    ...revision === void 0 ? {} : { revision }
+  };
+}
+function parseBundledAccountKey(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
+  const payload = value2;
+  if (payload.mode !== "bundled" || !payload.material || typeof payload.material !== "object") return void 0;
+  const material = payload.material;
+  const keyVersion = material.keyVersion;
+  const publicKey = bounded(material.publicKey, 128);
+  const encryptedPrivateKey = bounded(material.encryptedPrivateKey, 16384);
+  if (!Number.isSafeInteger(keyVersion) || keyVersion < 1 || !publicKey || !encryptedPrivateKey || !Array.isArray(material.unlockMethods) || material.unlockMethods.length > 16) return void 0;
+  return {
+    mode: "bundled",
+    material: {
+      keyVersion,
+      publicKey,
+      encryptedPrivateKey,
+      unlockMethods: material.unlockMethods.flatMap((method) => {
+        const parsed = parseUnlockMethod(method);
+        return parsed ? [parsed] : [];
+      })
+    }
+  };
+}
+function parseCloudLoginResult(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("CLOUD_LOGIN_RESPONSE_INVALID");
+  }
+  const value2 = raw;
+  const required = (field, maxLength) => {
+    const entry = bounded(value2[field], maxLength);
+    if (entry === void 0) throw new Error("CLOUD_LOGIN_RESPONSE_INVALID");
+    return entry;
+  };
+  const accountPublicKey = bounded(value2.accountPublicKey, 128);
+  const accountKeySalt = bounded(value2.accountKeySalt, 128);
+  const mfaSessionToken = bounded(value2.mfaSessionToken, 512);
+  const accountKey = parseBundledAccountKey(value2.accountKey);
+  return {
+    userId: required("userId", 256),
+    username: required("username", 256),
+    token: required("token", 8192),
+    secret: required("secret", 8192),
+    ...mfaSessionToken ? { mfaSessionToken } : {},
+    ...accountPublicKey ? { accountPublicKey } : {},
+    ...accountKeySalt ? { accountKeySalt } : {},
+    ...accountKey ? { accountKey } : {}
+  };
+}
+const HANDOFF_ID_PATTERN = /^mph-[A-Za-z0-9_-]{22}$/;
+const CAPABILITY_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+function record$5(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+}
+function validExpiry(value2) {
+  return typeof value2 === "number" && Number.isSafeInteger(value2) && value2 > 0;
+}
+function parseMfaPasskeyHandoff(raw, apiBaseUrl) {
+  const value2 = record$5(raw);
+  if (!value2 || typeof value2.handoffId !== "string" || !HANDOFF_ID_PATTERN.test(value2.handoffId) || typeof value2.exchangeToken !== "string" || !CAPABILITY_PATTERN.test(value2.exchangeToken) || typeof value2.authorizationUrl !== "string" || !validExpiry(value2.expiresAt)) {
+    throw new Error("MFA_PASSKEY_HANDOFF_RESPONSE_INVALID");
+  }
+  let authorizationUrl;
+  try {
+    authorizationUrl = new URL(value2.authorizationUrl);
+    const expectedOrigin = new URL(apiBaseUrl).origin;
+    const fragmentParams = new URLSearchParams(authorizationUrl.hash.slice(1));
+    const fragmentToken = fragmentParams.get("browserToken");
+    if (authorizationUrl.origin !== expectedOrigin || authorizationUrl.username !== "" || authorizationUrl.password !== "" || authorizationUrl.pathname !== "/mfa/passkey-handoff" || [...authorizationUrl.searchParams].length !== 1 || authorizationUrl.searchParams.get("handoffId") !== value2.handoffId || [...fragmentParams].length !== 1 || !fragmentToken || !CAPABILITY_PATTERN.test(fragmentToken) || authorizationUrl.href.includes(value2.exchangeToken)) {
+      throw new Error("invalid");
+    }
+  } catch {
+    throw new Error("MFA_PASSKEY_HANDOFF_RESPONSE_INVALID");
+  }
+  return {
+    handoffId: value2.handoffId,
+    authorizationUrl: authorizationUrl.toString(),
+    exchangeToken: value2.exchangeToken,
+    expiresAt: value2.expiresAt
+  };
+}
+function parsePendingMfaPasskeyExchange(raw) {
+  const value2 = record$5(raw);
+  if (!value2 || value2.status !== "pending" || !validExpiry(value2.expiresAt)) {
+    throw new Error("MFA_PASSKEY_HANDOFF_RESPONSE_INVALID");
+  }
+  return { kind: "pending", expiresAt: value2.expiresAt };
+}
+const ENVELOPE_VERSION = 0;
+const EPHEMERAL_PUBLIC_KEY_LENGTH = 32;
+const ENVELOPE_NONCE_LENGTH = 24;
+const ENVELOPE_HEADER_LENGTH = 1 + EPHEMERAL_PUBLIC_KEY_LENGTH + ENVELOPE_NONCE_LENGTH;
+const GCM_VERSION = 0;
+const GCM_NONCE_LENGTH = 12;
+const GCM_TAG_LENGTH = 16;
+function unwrapDataEncryptionKey(envelopeBase64, recipientPrivateKey) {
+  let envelope;
+  try {
+    envelope = decodeBase64(envelopeBase64);
+  } catch {
+    return null;
+  }
+  if (envelope.length <= ENVELOPE_HEADER_LENGTH) return null;
+  if (envelope[0] !== ENVELOPE_VERSION) return null;
+  const ephemeralPublicKey = envelope.subarray(1, 1 + EPHEMERAL_PUBLIC_KEY_LENGTH);
+  const nonce = envelope.subarray(1 + EPHEMERAL_PUBLIC_KEY_LENGTH, ENVELOPE_HEADER_LENGTH);
+  const ciphertext = envelope.subarray(ENVELOPE_HEADER_LENGTH);
+  const opened = nacl.box.open(ciphertext, nonce, ephemeralPublicKey, recipientPrivateKey);
+  return opened ? new Uint8Array(opened) : null;
+}
+async function importGcmKey(dataEncryptionKey) {
+  return crypto.subtle.importKey("raw", new Uint8Array(dataEncryptionKey), "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+async function decryptDataKeyToString(dataEncryptionKey, bundleBase64) {
+  let bundle;
+  try {
+    bundle = decodeBase64(bundleBase64);
+  } catch {
+    return null;
+  }
+  if (bundle.length < 1 + GCM_NONCE_LENGTH + GCM_TAG_LENGTH) return null;
+  if (bundle[0] !== GCM_VERSION) return null;
+  const nonce = bundle.subarray(1, 1 + GCM_NONCE_LENGTH);
+  const ciphertextWithTag = bundle.subarray(1 + GCM_NONCE_LENGTH);
+  try {
+    const key = await importGcmKey(dataEncryptionKey);
+    const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: new Uint8Array(nonce) }, key, new Uint8Array(ciphertextWithTag));
+    return new TextDecoder().decode(plaintext);
+  } catch {
+    return null;
+  }
+}
+async function encryptDataKeyContent(dataEncryptionKey, value2) {
+  const nonce = nacl.randomBytes(GCM_NONCE_LENGTH);
+  const key = await importGcmKey(dataEncryptionKey);
+  const plaintext = new TextEncoder().encode(JSON.stringify(value2));
+  const ciphertextWithTag = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(nonce) }, key, plaintext));
+  const bundle = new Uint8Array(1 + GCM_NONCE_LENGTH + ciphertextWithTag.length);
+  bundle[0] = GCM_VERSION;
+  bundle.set(nonce, 1);
+  bundle.set(ciphertextWithTag, 1 + GCM_NONCE_LENGTH);
+  return encodeBase64(bundle);
+}
+let candidates = [];
+let version = 0;
+function getCompanyKeyCandidates() {
+  return candidates.map((candidate) => candidate.privateKey);
+}
+function companyKeyChainVersion() {
+  return version;
+}
+const dekBySessionId = /* @__PURE__ */ new Map();
+const lockedSessionIds = /* @__PURE__ */ new Set();
+const fingerprints = /* @__PURE__ */ new Map();
+let boundaryGeneration = 0;
+function sessionDekRegistryGeneration() {
+  return boundaryGeneration;
+}
+function registerSessionDek(session, accountPrivateKey) {
+  const envelope = session.dataEncryptionKey ?? null;
+  if (!envelope) {
+    dekBySessionId.delete(session.id);
+    lockedSessionIds.delete(session.id);
+    fingerprints.delete(session.id);
+    return;
+  }
+  const fingerprint = `${envelope}|${accountPrivateKey ? "1" : "0"}|${companyKeyChainVersion()}`;
+  if (fingerprints.get(session.id) === fingerprint) return;
+  if (!accountPrivateKey && dekBySessionId.has(session.id) && fingerprints.get(session.id)?.startsWith(`${envelope}|1|`)) return;
+  const previousFingerprint = fingerprints.get(session.id);
+  fingerprints.set(session.id, fingerprint);
+  const candidates2 = accountPrivateKey ? [accountPrivateKey, ...getCompanyKeyCandidates()] : [];
+  let dek = null;
+  for (const candidate of candidates2) {
+    dek = unwrapDataEncryptionKey(envelope, candidate);
+    if (dek) break;
+  }
+  if (dek) {
+    dekBySessionId.set(session.id, dek);
+    lockedSessionIds.delete(session.id);
+    return;
+  }
+  if (dekBySessionId.has(session.id) && previousFingerprint?.startsWith(`${envelope}|`)) return;
+  dekBySessionId.delete(session.id);
+  lockedSessionIds.add(session.id);
+}
+function getSessionDek(sessionId) {
+  return dekBySessionId.get(sessionId) ?? null;
+}
+const MAX_ENTRIES = 3e3;
+const headerCache = /* @__PURE__ */ new Map();
+function cacheGet(store, sessionId, ciphertext) {
+  return store.get(sessionId)?.get(ciphertext) ?? null;
+}
+function cacheSet(store, sessionId, ciphertext, plaintext) {
+  let perSession = store.get(sessionId);
+  if (!perSession) {
+    perSession = /* @__PURE__ */ new Map();
+    store.set(sessionId, perSession);
+  }
+  perSession.set(ciphertext, plaintext);
+  if (perSession.size > MAX_ENTRIES) {
+    const oldest = perSession.keys().next().value;
+    if (oldest !== void 0) perSession.delete(oldest);
+  }
+}
+function getCachedDataKeyMetadataJson(sessionId, ciphertext) {
+  return cacheGet(headerCache, sessionId, ciphertext);
+}
+async function preDecryptSessionHeaders(sessions, accountPrivateKey, sinceGeneration = sessionDekRegistryGeneration()) {
+  const boundaryIntact = () => sessionDekRegistryGeneration() === sinceGeneration;
+  await Promise.all(sessions.map(async (session) => {
+    if (!boundaryIntact()) return;
+    registerSessionDek(session, accountPrivateKey);
+    const dek = getSessionDek(session.id);
+    if (!dek) return;
+    if (session.metadata && getCachedDataKeyMetadataJson(session.id, session.metadata) === null) {
+      const json = await decryptDataKeyToString(dek, session.metadata);
+      if (json !== null && boundaryIntact()) cacheSet(headerCache, session.id, session.metadata, json);
+    }
+    if (session.agentState && getCachedDataKeyMetadataJson(session.id, session.agentState) === null) {
+      const json = await decryptDataKeyToString(dek, session.agentState);
+      if (json !== null && boundaryIntact()) cacheSet(headerCache, session.id, session.agentState, json);
+    }
+  }));
+}
 function buildUserTextMessageContent(input) {
   return {
     role: "user",
@@ -7022,69 +7886,69 @@ function personalMachinesPath(companyId) {
 function myMachinesPath(companyId) {
   return `/api/admin/companies/${encodeURIComponent(companyId)}/my-machines`;
 }
-function record$1(value2) {
+function record$4(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 }
 function array(value2) {
   return Array.isArray(value2) ? value2 : [];
 }
-function str(value2, fallback = "") {
+function str$1(value2, fallback = "") {
   return typeof value2 === "string" ? value2 : fallback;
 }
-function num(value2, fallback = 0) {
+function num$1(value2, fallback = 0) {
   return typeof value2 === "number" && Number.isFinite(value2) ? value2 : fallback;
 }
 function nullableNum(value2) {
   return typeof value2 === "number" && Number.isFinite(value2) ? value2 : null;
 }
 function provider(value2) {
-  return PROVIDERS.includes(str(value2)) ? str(value2) : null;
+  return PROVIDERS.includes(str$1(value2)) ? str$1(value2) : null;
 }
 function parseBundle(value2) {
-  const row2 = record$1(value2);
-  const id = str(row2.id);
+  const row2 = record$4(value2);
+  const id = str$1(row2.id);
   const bundleProvider = provider(row2.provider);
   if (!id || !bundleProvider) return null;
   return {
     id,
-    companyId: str(row2.companyId),
+    companyId: str$1(row2.companyId),
     provider: bundleProvider,
-    label: str(row2.label, id),
-    formatVersion: num(row2.formatVersion, 1),
-    accountCount: num(row2.accountCount),
-    contentHash: str(row2.contentHash),
-    version: num(row2.version, 1),
-    createdById: str(row2.createdById),
-    createdAt: num(row2.createdAt),
-    updatedAt: num(row2.updatedAt)
+    label: str$1(row2.label, id),
+    formatVersion: num$1(row2.formatVersion, 1),
+    accountCount: num$1(row2.accountCount),
+    contentHash: str$1(row2.contentHash),
+    version: num$1(row2.version, 1),
+    createdById: str$1(row2.createdById),
+    createdAt: num$1(row2.createdAt),
+    updatedAt: num$1(row2.updatedAt)
   };
 }
 function parseDeployment(value2) {
-  const row2 = record$1(value2);
-  const machineId = str(row2.machineId);
-  const bundleId = str(row2.bundleId);
+  const row2 = record$4(value2);
+  const machineId = str$1(row2.machineId);
+  const bundleId = str$1(row2.bundleId);
   if (!machineId || !bundleId) return null;
-  const status = str(row2.status);
+  const status = str$1(row2.status);
   return {
-    id: str(row2.id),
-    companyId: str(row2.companyId),
+    id: str$1(row2.id),
+    companyId: str$1(row2.companyId),
     bundleId,
     machineId,
     bundleVersion: nullableNum(row2.bundleVersion),
-    attemptedBundleVersion: num(row2.attemptedBundleVersion, num(row2.bundleVersion)),
+    attemptedBundleVersion: num$1(row2.attemptedBundleVersion, num$1(row2.bundleVersion)),
     status: status === "deployed" || status === "failed" || status === "pending" ? status : "pending",
     errorKind: typeof row2.errorKind === "string" ? row2.errorKind : null,
     deployedAt: nullableNum(row2.deployedAt),
-    createdAt: num(row2.createdAt),
-    updatedAt: num(row2.updatedAt)
+    createdAt: num$1(row2.createdAt),
+    updatedAt: num$1(row2.updatedAt)
   };
 }
 function parseStatus(value2) {
-  const row2 = record$1(value2);
+  const row2 = record$4(value2);
   const statusProvider = provider(row2.provider);
   if (!statusProvider) return void 0;
-  const rotationRow = record$1(row2.rotation);
-  const state = str(rotationRow.state);
+  const rotationRow = record$4(row2.rotation);
+  const state = str$1(rotationRow.state);
   const rotation = ROTATION_STATES.includes(state) ? {
     state,
     lastErrorKind: typeof rotationRow.lastErrorKind === "string" ? rotationRow.lastErrorKind : null,
@@ -7104,11 +7968,11 @@ function parseStatus(value2) {
   };
 }
 function parseMachineResult(value2) {
-  const row2 = record$1(value2);
-  const machineId = str(row2.machineId);
+  const row2 = record$4(value2);
+  const machineId = str$1(row2.machineId);
   if (!machineId) return null;
   if (row2.ok !== true) {
-    return { machineId, ok: false, errorKind: str(row2.errorKind, "UNKNOWN_ERROR") };
+    return { machineId, ok: false, errorKind: str$1(row2.errorKind, "UNKNOWN_ERROR") };
   }
   const status = parseStatus(row2.status);
   return {
@@ -7119,54 +7983,54 @@ function parseMachineResult(value2) {
   };
 }
 function parseAiCredentialVaultSnapshot(value2) {
-  const body = record$1(value2);
+  const body = record$4(value2);
   return {
     bundles: array(body.bundles).map(parseBundle).filter((bundle) => bundle !== null),
     deployments: array(body.deployments).map(parseDeployment).filter((deployment) => deployment !== null)
   };
 }
 function parseAiCredentialCaptureResponse(value2) {
-  const body = record$1(value2);
+  const body = record$4(value2);
   const bundle = parseBundle(body.bundle);
   if (!bundle) throw new Error("AI credential capture response did not contain a bundle");
   return { bundle, warnings: array(body.warnings).filter((warning) => typeof warning === "string") };
 }
 function parseAiCredentialBatchResult(value2) {
-  const body = record$1(value2);
+  const body = record$4(value2);
   return {
     results: array(body.results).map(parseMachineResult).filter((result) => result !== null),
     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 array(record$4(value2).machines).map((entry) => {
+    const row2 = record$4(entry);
     return {
-      machineId: str(row2.machineId),
+      machineId: str$1(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),
+      registeredAt: num$1(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);
+  return array(record$4(value2).machines).map((entry) => {
+    const row2 = record$4(entry);
     const type = row2.type === "shared" ? "shared" : "personal";
     return {
-      machineId: str(row2.machineId),
-      ownerId: str(row2.ownerId),
+      machineId: str$1(row2.machineId),
+      ownerId: str$1(row2.ownerId),
       ownerUsername: typeof row2.ownerUsername === "string" ? row2.ownerUsername : null,
       ownerDisplayName: typeof row2.ownerDisplayName === "string" ? row2.ownerDisplayName : null,
       type,
       accessList: array(row2.accessList).filter((id) => typeof id === "string"),
       displayName: typeof row2.displayName === "string" ? row2.displayName : null,
       workspaceRoot: typeof row2.workspaceRoot === "string" ? row2.workspaceRoot : null,
-      registeredAt: num(row2.registeredAt),
-      updatedAt: num(row2.updatedAt),
+      registeredAt: num$1(row2.registeredAt),
+      updatedAt: num$1(row2.updatedAt),
       online: typeof row2.online === "boolean" ? row2.online : null,
       activeAt: nullableNum(row2.activeAt),
       host: typeof row2.host === "string" ? row2.host : null,
@@ -7179,6 +8043,144 @@ function parsePersonalMachines(value2) {
     };
   }).filter((machine) => machine.machineId !== "");
 }
+const orgSearchPaths = {
+  /** Fetched by main only (secrets) — kept here so the path has one origin. */
+  config: (companyId) => `/api/companies/${encodeURIComponent(companyId)}/search-config`,
+  reissue: (companyId) => `/api/companies/${encodeURIComponent(companyId)}/search-config/reissue`,
+  integration: (companyId) => `/api/admin/companies/${encodeURIComponent(companyId)}/search-integration`,
+  acl: (companyId) => `/api/companies/${encodeURIComponent(companyId)}/search-acl`,
+  leases: (companyId) => `/api/companies/${encodeURIComponent(companyId)}/search-index/leases`,
+  cursors: (companyId, projectId) => `/api/companies/${encodeURIComponent(companyId)}/search-index/cursors${projectId === void 0 ? "" : `?projectId=${encodeURIComponent(projectId)}`}`,
+  progress: (companyId) => `/api/companies/${encodeURIComponent(companyId)}/search-index/progress`
+};
+function record$3(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
+}
+function str(value2, fallback = "") {
+  return typeof value2 === "string" ? value2 : fallback;
+}
+function num(value2, fallback = 0) {
+  return typeof value2 === "number" && Number.isFinite(value2) ? value2 : fallback;
+}
+const PHASES = ["idle", "waiting", "indexing", "done"];
+function parseOrgSearchCursors(raw) {
+  const list = Array.isArray(record$3(raw).cursors) ? record$3(raw).cursors : [];
+  return list.flatMap((item) => {
+    const c = record$3(item);
+    if (typeof c.sessionId !== "string" || typeof c.lastSeq !== "number") return [];
+    return [{
+      sessionId: c.sessionId,
+      lastSeq: c.lastSeq,
+      complete: c.complete === true,
+      failureKind: typeof c.failureKind === "string" ? c.failureKind : null,
+      updatedAt: num(c.updatedAt)
+    }];
+  });
+}
+function parseProjectProgress(raw) {
+  const p = record$3(raw);
+  return {
+    projectId: str(p.projectId),
+    sessionsTotal: num(p.sessionsTotal),
+    sessionsIndexed: num(p.sessionsIndexed),
+    sessionsFailed: num(p.sessionsFailed),
+    messagesIndexed: num(p.messagesIndexed),
+    phase: PHASES.includes(p.phase) ? p.phase : "idle",
+    leaseHolderMasked: typeof p.leaseHolderMasked === "string" ? p.leaseHolderMasked : null,
+    updatedAt: typeof p.updatedAt === "number" ? p.updatedAt : null
+  };
+}
+function parseOrgSearchProgress(raw) {
+  const r = record$3(raw);
+  return {
+    phase: PHASES.includes(r.phase) ? r.phase : "idle",
+    sessionsTotal: num(r.sessionsTotal),
+    sessionsIndexed: num(r.sessionsIndexed),
+    sessionsFailed: num(r.sessionsFailed),
+    messagesIndexed: num(r.messagesIndexed),
+    activeLeases: num(r.activeLeases),
+    updatedAt: typeof r.updatedAt === "number" ? r.updatedAt : null,
+    projects: (Array.isArray(r.projects) ? r.projects : []).map(parseProjectProgress)
+  };
+}
+function isApiError(error) {
+  return error instanceof Error && error.name === "ApiError" && typeof error.status === "number" && typeof error.body === "string";
+}
+function errorCode(error) {
+  try {
+    const parsed = JSON.parse(error.body);
+    return typeof parsed.error === "string" ? parsed.error : null;
+  } catch {
+    return null;
+  }
+}
+function classify404(error) {
+  const code = errorCode(error);
+  if (code === "search-integration-not-configured") return { kind: "not-configured" };
+  if (code === "project-not-found") return { kind: "not-found" };
+  return { kind: "unsupported" };
+}
+async function attempt(run, onError) {
+  try {
+    return await run();
+  } catch (error) {
+    if (isApiError(error)) {
+      const mapped = onError(error);
+      if (mapped !== null) return mapped;
+    }
+    throw error;
+  }
+}
+function createOrgSearchApi(transport) {
+  const json = (body, method) => ({ method, body: JSON.stringify(body) });
+  return {
+    /** Member whose key returned 401 asks the reconciler for a new one (state → reissue). */
+    requestKeyReissue: (companyId) => attempt(
+      async () => {
+        await transport.request(orgSearchPaths.reissue(companyId), { method: "POST" });
+        return { kind: "ok" };
+      },
+      (error) => error.status === 404 ? errorCode(error) === "member-key-not-found" ? { kind: "not-found" } : { kind: "unsupported" } : null
+    ),
+    getIntegration: (companyId) => attempt(
+      async () => ({ kind: "ok", integration: await transport.request(orgSearchPaths.integration(companyId)) }),
+      (error) => error.status === 404 ? classify404(error) : null
+    ),
+    deleteIntegration: async (companyId) => {
+      await transport.request(orgSearchPaths.integration(companyId), { method: "DELETE" });
+    },
+    getAcl: (companyId) => transport.request(orgSearchPaths.acl(companyId)),
+    putAcl: (companyId, input) => attempt(
+      async () => {
+        await transport.request(orgSearchPaths.acl(companyId), json(input, "PUT"));
+        return { kind: "ok" };
+      },
+      (error) => error.status === 409 ? { kind: "lease-not-held" } : error.status === 404 ? { kind: "unsupported" } : null
+    ),
+    lease: (companyId, projectId, action) => attempt(
+      async () => {
+        const lease = await transport.request(orgSearchPaths.leases(companyId), json({ projectId, action }, "POST"));
+        return action === "release" ? { kind: "released" } : { kind: "ok", lease };
+      },
+      (error) => error.status === 404 ? classify404(error) : error.status === 403 ? { kind: "forbidden" } : null
+    ),
+    getCursors: (companyId, projectId) => attempt(
+      async () => ({ kind: "ok", cursors: parseOrgSearchCursors(await transport.request(orgSearchPaths.cursors(companyId, projectId))) }),
+      (error) => error.status === 404 ? classify404(error) : null
+    ),
+    putCursors: (companyId, projectId, cursors) => attempt(
+      async () => {
+        await transport.request(orgSearchPaths.cursors(companyId), json({ projectId, cursors }, "PUT"));
+        return { kind: "ok" };
+      },
+      (error) => error.status === 409 ? { kind: "lease-not-held" } : error.status === 404 ? classify404(error) : null
+    ),
+    getProgress: (companyId) => attempt(
+      async () => ({ kind: "ok", progress: parseOrgSearchProgress(await transport.request(orgSearchPaths.progress(companyId))) }),
+      (error) => error.status === 404 ? { kind: "unsupported" } : null
+    )
+  };
+}
 const SERVER_MACHINE_CONCURRENCY = 4;
 const MAX_FANOUT_TIMEOUT_MS = 9e5;
 function machineFanoutTimeoutMs(perMachineMs, machineCount) {
@@ -7524,6 +8526,123 @@ function parseProjectListV2Page(body) {
     total: page.total
   };
 }
+const PUBLIC_ID_PATTERN = /^[A-Za-z0-9_-]{32}$/;
+const CHECKSUM_PATTERN = /^[a-f\d]{64}$/i;
+const MAX_ID_LENGTH = 256;
+const MAX_TITLE_LENGTH = 255;
+const MAX_WARNINGS = 32;
+const MAX_WARNING_LENGTH = 500;
+const PUBLICATION_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "publicId",
+  "sourceType",
+  "sourceIdentity",
+  "sourceChecksumSha256",
+  "title",
+  "contentType",
+  "sizeBytes",
+  "checksumSha256",
+  "status",
+  "createdAt",
+  "revokedAt",
+  "publicUrl"
+]);
+function fail(detail) {
+  throw new Error(`artifact publication response is invalid: ${detail}`);
+}
+function record$2(value2, label) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) fail(`${label} must be an object`);
+  return value2;
+}
+function exactKeys(value2, keys) {
+  const expected = new Set(keys);
+  if (Object.keys(value2).some((key) => !expected.has(key)) || keys.some((key) => !(key in value2))) fail("response fields do not match the contract");
+}
+function nonEmptyString$1(value2, label, maxLength = MAX_ID_LENGTH) {
+  if (typeof value2 !== "string" || !value2 || value2.trim() !== value2 || value2.length > maxLength) fail(`${label} is invalid`);
+  return value2;
+}
+function checksum(value2, label) {
+  if (typeof value2 !== "string" || !CHECKSUM_PATTERN.test(value2)) fail(`${label} is invalid`);
+}
+function safeInteger(value2, label) {
+  if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 0) fail(`${label} is invalid`);
+}
+function warnings(value2) {
+  if (!Array.isArray(value2) || value2.length > MAX_WARNINGS || value2.some((warning) => typeof warning !== "string" || warning.length > MAX_WARNING_LENGTH)) fail("warnings are invalid");
+  return [...value2];
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function parseTrustedPublicUrl(value2, apiBaseUrl, publicId) {
+  if (typeof value2 !== "string") fail("publicUrl is invalid");
+  let publicUrl;
+  let apiUrl;
+  try {
+    publicUrl = new URL(value2);
+    apiUrl = new URL(apiBaseUrl);
+  } catch {
+    fail("publicUrl is invalid");
+  }
+  if (publicUrl.protocol !== "https:" && !(publicUrl.protocol === "http:" && isLoopbackHostname(publicUrl.hostname)) || publicUrl.origin !== apiUrl.origin || publicUrl.protocol !== apiUrl.protocol || publicUrl.username || publicUrl.password || publicUrl.search || publicUrl.hash || publicUrl.pathname !== `/artifacts/${publicId}`) fail("publicUrl is not trusted");
+  return publicUrl.toString();
+}
+function sourceIdentity(source) {
+  return source.type === "project-file" ? JSON.stringify([
+    source.projectId,
+    ...source.worktreeId ? [source.worktreeId] : [],
+    source.path
+  ]) : JSON.stringify([source.chatId, source.path]);
+}
+function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
+  const publication = record$2(value2, "publication");
+  if (Object.keys(publication).some((key) => !PUBLICATION_KEYS.has(key))) {
+    fail("publication contains an unexpected field");
+  }
+  if ([...PUBLICATION_KEYS].some((key) => !(key in publication))) {
+    fail("publication is missing a field");
+  }
+  const publicationId = nonEmptyString$1(publication.id, "publication id");
+  const publicId = nonEmptyString$1(publication.publicId, "public id");
+  if (!PUBLIC_ID_PATTERN.test(publicId)) fail("public id is invalid");
+  if (!["project-file", "personal-chat-file", "personal-chat-artifact"].includes(String(publication.sourceType))) {
+    fail("source type is invalid");
+  }
+  const parsedSourceIdentity = nonEmptyString$1(publication.sourceIdentity, "source identity", 4096);
+  if (expectedSource && (publication.sourceType !== expectedSource.type || parsedSourceIdentity !== sourceIdentity(expectedSource))) fail("source does not match the request");
+  checksum(publication.sourceChecksumSha256, "source checksum");
+  const title = nonEmptyString$1(publication.title, "title", MAX_TITLE_LENGTH);
+  nonEmptyString$1(publication.contentType, "content type");
+  safeInteger(publication.sizeBytes, "size");
+  checksum(publication.checksumSha256, "checksum");
+  safeInteger(publication.createdAt, "created time");
+  const expectedStatus = operation === "publish" ? "active" : "revoked";
+  if (publication.status !== expectedStatus) fail("status does not match the operation");
+  if (publication.revokedAt !== null && typeof publication.revokedAt !== "number" || typeof publication.revokedAt === "number" && (!Number.isSafeInteger(publication.revokedAt) || publication.revokedAt < 0) || expectedStatus === "active" && publication.revokedAt !== null || expectedStatus === "revoked" && publication.revokedAt === null) fail("revoked time is invalid");
+  return {
+    publicationId,
+    publicId,
+    publicUrl: parseTrustedPublicUrl(publication.publicUrl, apiBaseUrl, publicId),
+    title,
+    status: expectedStatus
+  };
+}
+function parseStaticArtifactPublicationResult(value2, options) {
+  const response = record$2(value2, "response");
+  if (options.operation === "publish") {
+    exactKeys(response, ["publication", "publicUrl", "reused"]);
+    if (typeof response.reused !== "boolean") fail("reused is invalid");
+    const publication2 = validatePublication(response.publication, options.apiBaseUrl, options.operation, options.source);
+    const publicUrl = parseTrustedPublicUrl(response.publicUrl, options.apiBaseUrl, publication2.publicId);
+    if (publication2.publicUrl !== publicUrl) fail("public URLs do not match");
+    return { version: 1, ...publication2, reused: response.reused, warnings: [] };
+  }
+  exactKeys(response, ["publication", "warnings"]);
+  const parsedWarnings = warnings(response.warnings);
+  const publication = validatePublication(response.publication, options.apiBaseUrl, options.operation);
+  return { version: 1, ...publication, reused: false, warnings: parsedWarnings };
+}
 function asRecord(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
@@ -11067,14 +12186,14 @@ function requireReceiver() {
      * @return {(Error|RangeError)} The error
      * @private
      */
-    createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+    createError(ErrorCtor, message, prefix, statusCode, errorCode2) {
       this._loop = false;
       this._errored = true;
       const err = new ErrorCtor(
         prefix ? `Invalid WebSocket frame: ${message}` : message
       );
       Error.captureStackTrace(err, this.createError);
-      err.code = errorCode;
+      err.code = errorCode2;
       err[kStatusCode] = statusCode;
       return err;
     }
@@ -15845,10 +16964,10 @@ class Manager extends Emitter {
    * @private
    */
   onreconnect() {
-    const attempt = this.backoff.attempts;
+    const attempt2 = this.backoff.attempts;
     this._reconnecting = false;
     this.backoff.reset();
-    this.emitReserved("reconnect", attempt);
+    this.emitReserved("reconnect", attempt2);
   }
 }
 const debug = debugModule("socket.io-client");
@@ -16132,6 +17251,18 @@ function coerceCreatedBy(value2) {
   const displayName = nonEmptyString(value2.displayName);
   return displayName ? { accountId, displayName } : { accountId };
 }
+function decryptSessionJsonSync(sessionId, blob, candidateKeys) {
+  if (!blob) return null;
+  const cached = getCachedDataKeyMetadataJson(sessionId, blob);
+  if (cached !== null) {
+    try {
+      return JSON.parse(cached);
+    } catch {
+      return null;
+    }
+  }
+  return decryptJsonWithCandidates(blob, candidateKeys);
+}
 function apiSessionToSession(api, candidateKeys, existing) {
   const updatedAt = mergeUpdatedAt(api.updatedAt);
   const summaryText = decryptSummaryText(api.metadata, candidateKeys) ?? existing?.summaryText;
@@ -16141,8 +17272,8 @@ function apiSessionToSession(api, candidateKeys, existing) {
   const pendingExitPlanMode = apiSessionAgentStatePendingExitPlanMode(api.agentState, candidateKeys);
   const pendingPermissionRequests = apiSessionAgentStatePendingPermissions(api.agentState, candidateKeys);
   const agentControlledByUser = apiSessionAgentStateControlledByUser(api.agentState, candidateKeys);
-  const agentState = api.agentState ? decryptJsonWithCandidates(api.agentState, candidateKeys) : null;
-  const metadata = decryptJsonWithCandidates(api.metadata, candidateKeys);
+  const agentState = api.agentState ? decryptSessionJsonSync(api.id, api.agentState, candidateKeys) : null;
+  const metadata = decryptSessionJsonSync(api.id, api.metadata, candidateKeys);
   const agent = agentFromFlavor(typeof metadata?.flavor === "string" ? metadata.flavor : void 0) ?? existing?.agent;
   const models = coerceSessionModels(metadata?.models) ?? existing?.models;
   const worktree = coerceSessionWorktree(metadata?.worktree) ?? coerceSessionWorktree(metadata) ?? existing?.worktree;
@@ -16235,6 +17366,16 @@ function buildWorktreeMutationBody(input, options = {}) {
     Object.entries(input).filter(([key, value2]) => (key !== "machinePlatform" || options.includeMachinePlatform) && (typeof value2 === "string" && (value2.length > 0 || CLEARABLE_STRING_KEYS.has(key)) || value2 === null && CLEARABLE_STRING_KEYS.has(key)))
   ));
 }
+function readDaemonRunning(decoded) {
+  if (!decoded || typeof decoded !== "object") return null;
+  const { status, state } = decoded;
+  return knownDaemonState(status) ?? knownDaemonState(state);
+}
+function knownDaemonState(value2) {
+  if (value2 === "running") return true;
+  if (value2 === "stopped" || value2 === "shutting-down") return false;
+  return null;
+}
 const STANDALONE_USER_ID = "standalone-local";
 function isStandaloneAuthSession(session) {
   return session?.userId === STANDALONE_USER_ID;
@@ -16318,19 +17459,19 @@ function row(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("automation-response-invalid");
   return value2;
 }
-function stringValue(value2) {
+function stringValue$1(value2) {
   if (typeof value2 !== "string" || !value2) throw new Error("automation-response-invalid");
   return value2;
 }
 function nullableString(value2) {
-  return value2 === null ? null : stringValue(value2);
+  return value2 === null ? null : stringValue$1(value2);
 }
-function integer(value2, min = 0) {
+function integer$1(value2, min = 0) {
   if (!Number.isSafeInteger(value2) || value2 < min) throw new Error("automation-response-invalid");
   return value2;
 }
 function nullableInteger(value2) {
-  return value2 === null ? null : integer(value2);
+  return value2 === null ? null : integer$1(value2);
 }
 function optionalNullableInteger(value2) {
   return value2 === void 0 ? null : nullableInteger(value2);
@@ -16338,40 +17479,40 @@ function optionalNullableInteger(value2) {
 function parseRuntimeState(value2) {
   const item = row(value2);
   return {
-    automationId: stringValue(item.automationId),
-    generation: integer(item.generation, 1),
-    stateVersion: integer(item.stateVersion, 1),
+    automationId: stringValue$1(item.automationId),
+    generation: integer$1(item.generation, 1),
+    stateVersion: integer$1(item.stateVersion, 1),
     stateCiphertext: versionedAutomationBase64(item.stateCiphertext, 96 * 1024),
-    viewerKeyVersion: integer(item.viewerKeyVersion, 1),
+    viewerKeyVersion: integer$1(item.viewerKeyVersion, 1),
     viewerKeyEnvelope: versionedAutomationBase64(item.viewerKeyEnvelope, 105, 105),
-    machineKeyVersion: integer(item.machineKeyVersion, 1),
-    updatedAt: integer(item.updatedAt)
+    machineKeyVersion: integer$1(item.machineKeyVersion, 1),
+    updatedAt: integer$1(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),
+    id: stringValue$1(item.id),
+    projectId: stringValue$1(item.projectId),
+    ownerAccountId: stringValue$1(item.ownerAccountId),
     machineAccountId: nullableString(item.machineAccountId),
     machineId: nullableString(item.machineId),
-    revision: integer(item.revision, 1),
-    generation: integer(item.generation, 1),
+    revision: integer$1(item.revision, 1),
+    generation: integer$1(item.generation, 1),
     payloadVersion: item.payloadVersion,
-    payloadCiphertext: stringValue(item.payloadCiphertext),
-    viewerKeyId: stringValue(item.viewerKeyId),
-    viewerKeyVersion: integer(item.viewerKeyVersion, 1),
-    viewerKeyEnvelope: stringValue(item.viewerKeyEnvelope),
-    machineKeyVersion: integer(item.machineKeyVersion, 1),
+    payloadCiphertext: stringValue$1(item.payloadCiphertext),
+    viewerKeyId: stringValue$1(item.viewerKeyId),
+    viewerKeyVersion: integer$1(item.viewerKeyVersion, 1),
+    viewerKeyEnvelope: stringValue$1(item.viewerKeyEnvelope),
+    machineKeyVersion: integer$1(item.machineKeyVersion, 1),
     paused: item.paused,
-    enabledAt: integer(item.enabledAt),
+    enabledAt: integer$1(item.enabledAt),
     runRequestedAt: optionalNullableInteger(item.runRequestedAt),
-    appliedRevision: integer(item.appliedRevision),
+    appliedRevision: integer$1(item.appliedRevision),
     appliedAt: nullableInteger(item.appliedAt),
-    createdAt: integer(item.createdAt),
-    updatedAt: integer(item.updatedAt),
+    createdAt: integer$1(item.createdAt),
+    updatedAt: integer$1(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)) {
@@ -16393,13 +17534,14 @@ function parseServerAutomationAdoption(value2) {
 function parseServerAutomationTarget(value2) {
   const item = row(value2);
   return {
-    machineAccountId: stringValue(item.machineAccountId),
-    machineId: stringValue(item.machineId),
-    machinePublicKey: stringValue(item.machinePublicKey),
-    machineKeyVersion: integer(item.machineKeyVersion, 1),
+    machineAccountId: stringValue$1(item.machineAccountId),
+    machineId: stringValue$1(item.machineId),
+    machinePublicKey: stringValue$1(item.machinePublicKey),
+    machineKeyVersion: integer$1(item.machineKeyVersion, 1),
     viewerPublicKey: nullableString(item.viewerPublicKey),
-    viewerKeyVersion: integer(item.viewerKeyVersion),
-    automationProtocolVersion: item.automationProtocolVersion === void 0 ? 1 : integer(item.automationProtocolVersion, 1)
+    viewerKeyVersion: integer$1(item.viewerKeyVersion),
+    automationProtocolVersion: item.automationProtocolVersion === void 0 ? 1 : integer$1(item.automationProtocolVersion, 1),
+    sessionFollowupSupported: item.sessionFollowupSupported === true
   };
 }
 const RUN_STATUSES = /* @__PURE__ */ new Set(["CLAIMED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED", "ABANDONED"]);
@@ -16408,16 +17550,16 @@ 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");
   return {
-    id: stringValue(item.id),
-    automationId: stringValue(item.automationId),
-    generation: integer(item.generation, 1),
-    scheduledFor: integer(item.scheduledFor),
-    machineId: stringValue(item.machineId),
+    id: stringValue$1(item.id),
+    automationId: stringValue$1(item.automationId),
+    generation: integer$1(item.generation, 1),
+    scheduledFor: integer$1(item.scheduledFor),
+    machineId: stringValue$1(item.machineId),
     status: item.status,
     sessionId: nullableString(item.sessionId),
     outcome: item.outcome,
     detailCiphertext: nullableString(item.detailCiphertext),
-    claimedAt: integer(item.claimedAt),
+    claimedAt: integer$1(item.claimedAt),
     startedAt: nullableInteger(item.startedAt),
     completedAt: nullableInteger(item.completedAt),
     lateReport: item.lateReport,
@@ -16455,6 +17597,98 @@ function parseServerGithubWebhookStatus(value2) {
     lastDeliveryAt: nullableTimestamp(item.lastDeliveryAt)
   };
 }
+const SESSION_FOLLOWUP_WIRE_VERSION = 1;
+const STATUSES$1 = /* @__PURE__ */ new Set(["WAITING", "DELIVERY_PENDING", "PAUSED", "COMPLETED", "CANCELLED", "FAILED"]);
+const TERMINAL_CODES = /* @__PURE__ */ new Set([
+  "CLEAN",
+  "LOW_OR_NIT_ONLY",
+  "UNSTRUCTURED",
+  "ROUNDS_EXHAUSTED",
+  "USER_INTERVENTION",
+  "STOPPED",
+  "SESSION_UNAVAILABLE",
+  "TARGET_MISMATCH",
+  "DECRYPT_FAILED",
+  "PERMISSION_REVOKED"
+]);
+function invalid() {
+  throw new Error("session-followup-response-invalid");
+}
+function record$1(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) invalid();
+  return value2;
+}
+function stringValue(value2) {
+  return typeof value2 === "string" && value2 ? value2 : invalid();
+}
+function boundedString(value2, max) {
+  const parsed = stringValue(value2);
+  return parsed.length <= max ? parsed : invalid();
+}
+function integer(value2, min = 0) {
+  return Number.isSafeInteger(value2) && value2 >= min ? value2 : invalid();
+}
+function validateSessionFollowupCreateInput(input) {
+  try {
+    if (input.wireVersion !== SESSION_FOLLOWUP_WIRE_VERSION || input.payloadVersion !== 1) invalid();
+    if (!input.sessionId || input.sessionId.length > 200 || !input.viewerKeyId || input.viewerKeyId.length > 128) invalid();
+    const totalRounds = integer(input.totalRounds, 2);
+    const currentRound = integer(input.currentRound, 1);
+    if (totalRounds > 7 || currentRound > totalRounds) invalid();
+    integer(input.responseBoundarySeq);
+    integer(input.viewerKeyVersion, 1);
+    integer(input.machineKeyVersion, 1);
+    versionedAutomationBase64(input.payloadCiphertext, 128 * 1024);
+    versionedAutomationBase64(input.viewerKeyEnvelope, 105, 105);
+    versionedAutomationBase64(input.machineKeyEnvelope, 105, 105);
+    return input;
+  } catch {
+    throw new Error("session-followup-request-invalid");
+  }
+}
+function parseSessionFollowupPublic(value2) {
+  try {
+    const item = record$1(value2);
+    if (!STATUSES$1.has(item.status)) invalid();
+    if (item.terminalCode !== null && !TERMINAL_CODES.has(item.terminalCode)) invalid();
+    if (item.payloadVersion !== 1) invalid();
+    const totalRounds = integer(item.totalRounds, 2);
+    const currentRound = integer(item.currentRound, 1);
+    if (totalRounds > 7 || currentRound > totalRounds) invalid();
+    return {
+      id: stringValue(item.id),
+      projectId: stringValue(item.projectId),
+      ownerAccountId: stringValue(item.ownerAccountId),
+      machineAccountId: stringValue(item.machineAccountId),
+      machineId: stringValue(item.machineId),
+      sessionId: stringValue(item.sessionId),
+      revision: integer(item.revision, 1),
+      generation: integer(item.generation, 1),
+      step: integer(item.step, 1),
+      status: item.status,
+      terminalCode: item.terminalCode,
+      totalRounds,
+      currentRound,
+      responseBoundarySeq: integer(item.responseBoundarySeq),
+      lastObservedSeq: integer(item.lastObservedSeq),
+      payloadVersion: 1,
+      payloadCiphertext: versionedAutomationBase64(item.payloadCiphertext, 128 * 1024),
+      viewerKeyId: boundedString(item.viewerKeyId, 128),
+      viewerKeyVersion: integer(item.viewerKeyVersion, 1),
+      viewerKeyEnvelope: versionedAutomationBase64(item.viewerKeyEnvelope, 105, 105),
+      machineKeyVersion: integer(item.machineKeyVersion, 1),
+      completedAt: item.completedAt === null ? null : integer(item.completedAt),
+      createdAt: integer(item.createdAt),
+      updatedAt: integer(item.updatedAt)
+    };
+  } catch {
+    throw new Error("session-followup-response-invalid");
+  }
+}
+function parseSessionFollowupList(value2) {
+  if (!Array.isArray(value2)) throw new Error("session-followup-response-invalid");
+  return value2.map(parseSessionFollowupPublic);
+}
 const ERROR_CODES = /* @__PURE__ */ new Set([
   "PAIRING_INVALID",
   "PAIRING_EXPIRED",
@@ -16486,18 +17720,18 @@ function readCloudMobileLoginPairingErrorCode(body) {
 const PAIRING_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const CODE_PATTERN = /^[A-Za-z0-9_-]{43}$/;
 const STATUSES = /* @__PURE__ */ new Set(["pending", "consumed", "revoked", "expired"]);
-function invalidResponse() {
+function invalidResponse$1() {
   throw new Error("PAIRING_RESPONSE_INVALID");
 }
 function parseCloudMobileLoginPairing(raw, options = {}) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) invalidResponse();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) invalidResponse$1();
   const value2 = raw;
-  if (typeof value2.pairingId !== "string" || !PAIRING_ID_PATTERN.test(value2.pairingId)) invalidResponse();
-  if (!Number.isSafeInteger(value2.expiresAt) || value2.expiresAt <= 0) invalidResponse();
-  if (!Number.isSafeInteger(value2.serverTime) || value2.serverTime <= 0) invalidResponse();
-  if (typeof value2.status !== "string" || !STATUSES.has(value2.status)) invalidResponse();
-  if (options.requireCode && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse();
-  if (value2.code !== void 0 && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse();
+  if (typeof value2.pairingId !== "string" || !PAIRING_ID_PATTERN.test(value2.pairingId)) invalidResponse$1();
+  if (!Number.isSafeInteger(value2.expiresAt) || value2.expiresAt <= 0) invalidResponse$1();
+  if (!Number.isSafeInteger(value2.serverTime) || value2.serverTime <= 0) invalidResponse$1();
+  if (typeof value2.status !== "string" || !STATUSES.has(value2.status)) invalidResponse$1();
+  if (options.requireCode && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse$1();
+  if (value2.code !== void 0 && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse$1();
   return {
     pairingId: value2.pairingId,
     expiresAt: value2.expiresAt,
@@ -16506,6 +17740,43 @@ function parseCloudMobileLoginPairing(raw, options = {}) {
     ...typeof value2.code === "string" ? { code: value2.code } : {}
   };
 }
+const BROWSER_VIEWER_OPEN_TIMEOUT_MS = 13e4;
+const BROWSER_VIEWER_INSTALL_TIMEOUT_MS = 31e4;
+function invalidResponse() {
+  throw new Error("BROWSER_VIEWER_RESPONSE_INVALID");
+}
+function responseRecord(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) invalidResponse();
+  return value2;
+}
+function parseBrowserViewerOpenResponse(value2) {
+  const response = responseRecord(value2);
+  if (typeof response.token !== "string" || response.token.length === 0 || typeof response.relayUrl !== "string" && response.relayUrl !== null || response.routingVersion !== 1 || typeof response.previewDomain !== "string" && response.previewDomain !== null || !Number.isInteger(response.webPort) || response.webPort < 1 || response.webPort > 65535 || typeof response.bridgeReady !== "boolean") invalidResponse();
+  return {
+    token: response.token,
+    relayUrl: response.relayUrl,
+    routingVersion: 1,
+    previewDomain: response.previewDomain,
+    webPort: response.webPort,
+    bridgeReady: response.bridgeReady
+  };
+}
+function parseBrowserViewerInstallResponse(value2) {
+  const response = responseRecord(value2);
+  if (response.action === "already-installed") return { kind: "already-installed" };
+  if (response.action === "run") {
+    if (response.ok !== true) invalidResponse();
+    return { kind: "installed" };
+  }
+  if (response.action === "manual") {
+    if (typeof response.command !== "string" || typeof response.reason !== "string") invalidResponse();
+    return {
+      kind: "manual-required",
+      reason: response.command.length === 0 ? "unsupported-platform" : "admin-required"
+    };
+  }
+  return invalidResponse();
+}
 const FIXED_API_BASE_URL = "https://saycode.ai";
 const FIXED_SYNC_BASE_URL = "https://saycode.ai";
 const machineRegistryCache = /* @__PURE__ */ new Map();
@@ -16537,6 +17808,20 @@ class MachineDeleteConflictError extends Error {
 const DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
 const LONG_REQUEST_TIMEOUT_MS = 18e4;
 const UPLOAD_REQUEST_TIMEOUT_MS = 12e4;
+const OWNER_SYNC_WARNING_MAX_COUNT = 16;
+const OWNER_SYNC_WARNING_MAX_LENGTH = 100;
+function parseOwnerSyncWarnings(value2) {
+  if (!Array.isArray(value2)) return [];
+  const warnings2 = [];
+  for (const item of value2) {
+    if (typeof item !== "string") continue;
+    const warning = item.trim();
+    if (!warning || warning.length > OWNER_SYNC_WARNING_MAX_LENGTH) continue;
+    warnings2.push(warning);
+    if (warnings2.length === OWNER_SYNC_WARNING_MAX_COUNT) break;
+  }
+  return warnings2;
+}
 function isRequestTimeoutError(error) {
   return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
 }
@@ -16546,7 +17831,9 @@ async function fetchWithTimeout(url2, init, timeoutMs) {
     return await fetch(url2, requestAbort.signal ? { ...init, signal: requestAbort.signal } : init);
   } catch (error) {
     if (requestAbort.didTimeout() && isRequestTimeoutError(error)) {
-      throw new Error(translateCurrent("api.serverTimeout", { seconds: Math.round(timeoutMs / 1e3) }));
+      const timeout = new Error(translateCurrent("api.serverTimeout", { seconds: Math.round(timeoutMs / 1e3) }));
+      timeout.name = "ServerTimeoutError";
+      throw timeout;
     }
     throw error;
   }
@@ -16635,7 +17922,8 @@ function normalizeGithubPullRequest(raw) {
     head: typeof head === "string" ? head : null,
     base: typeof base === "string" ? base : null,
     draft: raw.draft === true,
-    merged
+    merged,
+    ...raw.autoMerge === true ? { autoMerge: true } : {}
   };
 }
 function extractPullRequestList(raw) {
@@ -16671,6 +17959,7 @@ function normalizeMachine(row2, candidateKeys) {
   const host = row2.host || registry?.host || (typeof decrypted.host === "string" ? decrypted.host : row2.id.slice(0, 8));
   const platform2 = row2.platform || registry?.platform || (typeof decrypted.platform === "string" ? decrypted.platform : "unknown");
   const automationSupport = normalizeAutomationSupport(decrypted.automationSupport) ?? normalizeAutomationSupport(registry?.automationSupport);
+  const autonomousQualityGate = decrypted.autonomousQualityGateSupport ?? registry?.autonomousQualityGateSupport;
   return {
     id: row2.id,
     accountId: row2.accountId,
@@ -16683,9 +17972,12 @@ function normalizeMachine(row2, candidateKeys) {
     happyCliVersion: row2.happyCliVersion || registry?.happyCliVersion || (typeof decrypted.happyCliVersion === "string" ? decrypted.happyCliVersion : void 0),
     homeDir: row2.homeDir || registry?.homeDir || (typeof decrypted.homeDir === "string" ? decrypted.homeDir : void 0),
     resources,
+    daemonRunning: readDaemonRunning(daemonState),
     mcpCallerGrantPublicKey: readMcpCallerGrantPublicKey(daemonState),
     automationSupport,
+    autonomousQualityGate,
     filesystemScope: decrypted.filesystemScope,
+    additionalDirectories: decrypted.additionalDirectories,
     registry
   };
 }
@@ -16713,7 +18005,56 @@ class ApiClient {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input)
     }, DEFAULT_REQUEST_TIMEOUT_MS);
-    return this.handleResponse(response);
+    return parsePasswordLoginResponse(await this.handleResponse(response));
+  }
+  /**
+   * MFA(TOTP) 로그인 2단계 — 서버 mfaLoginRoutes `/api/auth/mfa/login/totp`.
+   * 성공 응답은 일반 로그인 결과의 상위집합이라 같은 strict parser 를 쓴다.
+   * 실패는 handleResponse 의 ApiError(status + body 의 MFA_* code)로 온다.
+   */
+  async verifyMfaTotpLogin(input) {
+    const response = await fetchWithTimeout(absoluteUrl(this.config.apiBaseUrl, "/api/auth/mfa/login/totp"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    }, DEFAULT_REQUEST_TIMEOUT_MS);
+    return parseCloudLoginResult(await this.handleResponse(response));
+  }
+  async startMfaPasskeyHandoff(input) {
+    const response = await fetchWithTimeout(
+      absoluteUrl(this.config.apiBaseUrl, "/api/auth/mfa/login/passkey-handoffs"),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          version: 1,
+          loginToken: input.loginToken,
+          clientKind: input.clientKind,
+          ...input.deviceId ? { deviceId: input.deviceId } : {},
+          e2eeDeviceApprovalVersion: 1
+        }),
+        signal: input.signal
+      },
+      DEFAULT_REQUEST_TIMEOUT_MS
+    );
+    return parseMfaPasskeyHandoff(await this.handleResponse(response), this.config.apiBaseUrl);
+  }
+  async exchangeMfaPasskeyHandoff(input) {
+    const response = await fetchWithTimeout(
+      absoluteUrl(
+        this.config.apiBaseUrl,
+        `/api/auth/mfa/login/passkey-handoffs/${encodeURIComponent(input.handoffId)}/exchange`
+      ),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ version: 1, exchangeToken: input.exchangeToken }),
+        signal: input.signal
+      },
+      DEFAULT_REQUEST_TIMEOUT_MS
+    );
+    const data = await this.handleResponse(response);
+    return response.status === 202 ? parsePendingMfaPasskeyExchange(data) : { kind: "complete", result: parseCloudLoginResult(data) };
   }
   async getMe() {
     return this.request("/api/auth/me", { boundary: "api" });
@@ -17011,6 +18352,17 @@ class ApiClient {
     );
     return Array.isArray(data) ? data : data.members ?? [];
   }
+  /**
+   * 회사 공유 키 공개키 + 자기 grant 조회 (specs/e2ee-company-key-activation
+   * P1). 응답 해석(myGrants null=미수립 vs []=권한없음)은 companyKeyChain 이
+   * 담당하므로 여기서는 원본을 그대로 넘긴다.
+   */
+  async fetchCompanyDataKey(companyId) {
+    return this.request(
+      `/api/admin/companies/${encodeURIComponent(companyId)}/data-key`,
+      { boundary: "api" }
+    );
+  }
   async updateCompanyMemberRole(companyId, accountId, role) {
     await this.request(`/api/admin/companies/${encodeURIComponent(companyId)}/members/${encodeURIComponent(accountId)}`, {
       method: "PATCH",
@@ -17149,6 +18501,10 @@ class ApiClient {
       }
     );
   }
+  /** specs/org-elasticsearch-search — 경계 어댑터는 src/api/orgSearch.ts 가 소유한다. */
+  orgSearch() {
+    return createOrgSearchApi({ request: (path, init) => this.request(path, { boundary: "api", ...init ?? {} }) });
+  }
   async getCompanyHappyCredentials(companyId) {
     return this.request(`/api/companies/${encodeURIComponent(companyId)}/happy-credentials`, { boundary: "api" });
   }
@@ -17285,6 +18641,45 @@ class ApiClient {
     const data = await this.request(`/v1/projects/${encodeURIComponent(projectId)}/automation-target`, { boundary: "sync" });
     return parseServerAutomationTarget(data.target);
   }
+  sessionFollowupPath(projectId, followupId) {
+    const root = `/v1/projects/${encodeURIComponent(projectId)}/session-followups`;
+    return followupId ? `${root}/${encodeURIComponent(followupId)}` : root;
+  }
+  async listSessionFollowups(projectId, sessionId) {
+    const query = sessionId ? `?session_id=${encodeURIComponent(sessionId)}&limit=100` : "?limit=100";
+    return parseSessionFollowupList(await this.request(`${this.sessionFollowupPath(projectId)}${query}`, { boundary: "sync" }));
+  }
+  async createSessionFollowup(projectId, input) {
+    return parseSessionFollowupPublic(await this.request(this.sessionFollowupPath(projectId), {
+      method: "POST",
+      boundary: "sync",
+      body: JSON.stringify(validateSessionFollowupCreateInput(input))
+    }));
+  }
+  async mutateSessionFollowupRevision(input) {
+    const item = this.sessionFollowupPath(input.projectId, input.followupId);
+    try {
+      return parseSessionFollowupPublic(await this.request(input.action ? `${item}/${input.action}` : item, {
+        method: input.method,
+        boundary: "sync",
+        body: JSON.stringify({ wireVersion: SESSION_FOLLOWUP_WIRE_VERSION, expectedRevision: input.expectedRevision })
+      }));
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 409) throw error;
+      try {
+        const body = JSON.parse(error.body);
+        return parseSessionFollowupPublic(body.latest);
+      } catch {
+        throw error;
+      }
+    }
+  }
+  async stopSessionFollowup(projectId, followupId, expectedRevision) {
+    return this.mutateSessionFollowupRevision({ projectId, followupId, expectedRevision, method: "POST", action: "stop" });
+  }
+  async deleteSessionFollowup(projectId, followupId, expectedRevision) {
+    return this.mutateSessionFollowupRevision({ projectId, followupId, expectedRevision, method: "DELETE" });
+  }
   async setServerAutomationViewerKey(projectId, input) {
     return this.request(`/v1/projects/${encodeURIComponent(projectId)}/automation-viewer-key`, {
       method: "PUT",
@@ -17952,23 +19347,28 @@ class ApiClient {
       boundary: "api"
     });
   }
-  async fetchSessions(candidateKeys = [], tokenOverride) {
+  async fetchSessions(candidateKeys = [], tokenOverride, accountPrivateKey = null) {
+    const boundaryGeneration2 = sessionDekRegistryGeneration();
     const data = await this.request("/v1/sessions", {
       boundary: "sync",
       tokenOverride
     });
     const rows = Array.isArray(data) ? data : data.sessions ?? [];
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
     return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
-  async fetchSessionsPage(candidateKeys = [], cursor, limit = 200, tokenOverride) {
+  async fetchSessionsPage(candidateKeys = [], cursor, limit = 200, tokenOverride, accountPrivateKey = null) {
     const params = new URLSearchParams({ limit: String(limit) });
     if (cursor) params.set("cursor", cursor);
+    const boundaryGeneration2 = sessionDekRegistryGeneration();
     const data = await this.request(
       `/v2/sessions?${params.toString()}`,
       { boundary: "sync", tokenOverride }
     );
+    const rows = data.sessions ?? [];
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
     return {
-      sessions: (data.sessions ?? []).map((row2) => apiSessionToSession(row2, candidateKeys)),
+      sessions: rows.map((row2) => apiSessionToSession(row2, candidateKeys)),
       nextCursor: data.nextCursor ?? null,
       hasNext: data.hasNext === true
     };
@@ -17983,8 +19383,11 @@ class ApiClient {
     });
     return data.sessions ?? [];
   }
-  async lookupSessions(candidateKeys, ids, tokenOverride) {
-    return (await this.lookupApiSessions(ids, tokenOverride)).map((row2) => apiSessionToSession(row2, candidateKeys));
+  async lookupSessions(candidateKeys, ids, tokenOverride, accountPrivateKey = null) {
+    const boundaryGeneration2 = sessionDekRegistryGeneration();
+    const rows = await this.lookupApiSessions(ids, tokenOverride);
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
+    return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
   async deleteSession(sessionId, tokenOverride) {
     await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
@@ -18107,6 +19510,22 @@ class ApiClient {
       message: typeof raw.message === "string" ? raw.message : null
     };
   }
+  /** specs/desktop-pr-auto-merge-toggle — aplus-dev-studio#3315 server endpoint. */
+  async setGithubPullRequestAutoMerge(input, tokenOverride) {
+    const raw = await this.request(
+      `/api/projects/${encodeURIComponent(input.projectId)}/pull-requests/${encodeURIComponent(String(input.number))}/auto-merge`,
+      {
+        method: "POST",
+        boundary: "api",
+        tokenOverride,
+        body: JSON.stringify({ enabled: input.enabled, ...input.method ? { method: input.method } : {} })
+      }
+    );
+    return {
+      autoMerge: raw.autoMerge === true,
+      prNumber: typeof raw.prNumber === "number" ? raw.prNumber : input.number
+    };
+  }
   async fetchMessages(sessionId, afterSeq, tokenOverride, signal) {
     const params = new URLSearchParams({ limit: "100" });
     if (afterSeq !== void 0) params.set("after_seq", String(afterSeq));
@@ -18169,9 +19588,8 @@ 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 = buildUserTextMessageContent(input);
-    const encoded = encodeMessageContent(content, key);
+    const encoded = input.dataEncryptionKey ? await encryptDataKeyContent(input.dataEncryptionKey, content) : encodeMessageContent(content, input.secretBase64 ? decodeBase64(input.secretBase64) : null);
     const result = await this.sendMessages(input.sessionId, [{ localId, content: encoded }], input.tokenOverride);
     return { localId, sentSeq: result.messages?.[0]?.seq };
   }
@@ -18243,6 +19661,34 @@ class ApiClient {
     }
     return resolvedProjectPreviewRelayUrl({ ...input, response: { ...response, token: response.token }, syncBaseUrl: this.config.syncBaseUrl });
   }
+  async openBrowserViewer(machineId, signal) {
+    return parseBrowserViewerOpenResponse(await this.request(
+      `/api/machines/${encodeURIComponent(machineId)}/browser-viewer/open`,
+      {
+        method: "POST",
+        boundary: "api",
+        signal,
+        timeoutMs: BROWSER_VIEWER_OPEN_TIMEOUT_MS
+      }
+    ));
+  }
+  async installBrowserViewer(machineId, signal) {
+    return this.installBrowserViewerComponent(machineId, "install", signal);
+  }
+  async installBrowserViewerChrome(machineId, signal) {
+    return this.installBrowserViewerComponent(machineId, "install-chrome", signal);
+  }
+  async installBrowserViewerComponent(machineId, action, signal) {
+    return parseBrowserViewerInstallResponse(await this.request(
+      `/api/machines/${encodeURIComponent(machineId)}/browser-viewer/${action}`,
+      {
+        method: "POST",
+        boundary: "api",
+        signal,
+        timeoutMs: BROWSER_VIEWER_INSTALL_TIMEOUT_MS
+      }
+    ));
+  }
   // --- Project deploy & share (specs/desktop-project-deploy-share) ---
   async moveProject(projectId, input) {
     return this.request(`/api/projects/${encodeURIComponent(projectId)}/move`, {
@@ -18252,15 +19698,19 @@ class ApiClient {
     });
   }
   async syncOwnerWorkspace(projectId, input = {}) {
-    return this.request(`/api/projects/${encodeURIComponent(projectId)}/sync-owner-workspace`, {
-      method: "POST",
-      boundary: "api",
-      timeoutMs: LONG_REQUEST_TIMEOUT_MS,
-      body: JSON.stringify({
-        trigger: input.trigger ?? "owner-manual",
-        ...input.vcsTarget ? { vcsTarget: input.vcsTarget } : {}
-      })
-    });
+    const data = await this.request(
+      `/api/projects/${encodeURIComponent(projectId)}/sync-owner-workspace`,
+      {
+        method: "POST",
+        boundary: "api",
+        timeoutMs: LONG_REQUEST_TIMEOUT_MS,
+        body: JSON.stringify({
+          trigger: input.trigger ?? "owner-manual",
+          ...input.vcsTarget ? { vcsTarget: input.vcsTarget } : {}
+        })
+      }
+    );
+    return { result: data.result, warnings: parseOwnerSyncWarnings(data.warnings) };
   }
   async getProjectVcsRemote(projectId) {
     const data = await this.request(
@@ -18364,6 +19814,30 @@ class ApiClient {
       timeoutMs: LONG_REQUEST_TIMEOUT_MS
     });
   }
+  async publishStaticArtifact(source, signal) {
+    const { version: _version, ...serverSource } = source;
+    const response = await this.request("/api/artifact-publications", {
+      method: "POST",
+      boundary: "api",
+      body: JSON.stringify({ source: serverSource }),
+      signal
+    });
+    return parseStaticArtifactPublicationResult(response, {
+      apiBaseUrl: this.config.apiBaseUrl,
+      operation: "publish",
+      source
+    });
+  }
+  async revokeStaticArtifactPublication(publicationId, signal) {
+    const response = await this.request(
+      `/api/artifact-publications/${encodeURIComponent(publicationId)}`,
+      { method: "DELETE", boundary: "api", signal }
+    );
+    return parseStaticArtifactPublicationResult(response, {
+      apiBaseUrl: this.config.apiBaseUrl,
+      operation: "revoke"
+    });
+  }
   async getDeployGitHubFiles(projectId, branch = "main") {
     const data = await this.request("/deploy/github-files", {
       method: "POST",
@@ -18812,8 +20286,8 @@ function happyHomeOrder(input) {
   if (!runtime) return [...homes];
   return [runtime, ...homes.filter((source) => source !== runtime)];
 }
-function selectFirstValidCredential(candidates, readFile2) {
-  for (const candidate of candidates) {
+function selectFirstValidCredential(candidates2, readFile2) {
+  for (const candidate of candidates2) {
     const raw = readFile2(candidate.path);
     if (raw === null) continue;
     const credential = parseAccessKeyFile(raw);
@@ -18969,7 +20443,7 @@ class RealtimeSocket {
     }
     const schedule = connectSchedule(totalTimeoutMs);
     let lastError = null;
-    for (let attempt = 0; attempt < CONNECT_ATTEMPTS; attempt += 1) {
+    for (let attempt2 = 0; attempt2 < CONNECT_ATTEMPTS; attempt2 += 1) {
       const result = await this.connectOnce(schedule.attemptTimeoutMs);
       if (result.type === "cancelled") throw this.cancelledError();
       if (result.type === "connected") {
@@ -18979,7 +20453,7 @@ class RealtimeSocket {
       }
       if (result.type === "error") lastError = result.error;
       this.socket.disconnect();
-      const retryDelay = schedule.retryDelaysMs[attempt];
+      const retryDelay = schedule.retryDelaysMs[attempt2];
       if (retryDelay !== void 0 && retryDelay > 0 && !await this.waitForRetry(retryDelay)) {
         throw this.cancelledError();
       }
@@ -19488,8 +20962,19 @@ async function runLogin(out, env = process.env) {
   const client = new ApiClient({ apiBaseUrl: serverUrl, syncBaseUrl: serverUrl });
   let result;
   try {
-    result = await client.login({ email, password });
-  } catch {
+    const outcome = await client.login({ email, password });
+    if (outcome.kind === "mfa-required") {
+      if (outcome.challenge.enrollmentRequired || !outcome.challenge.methods.includes("totp")) {
+        throw new CliError("This account requires MFA enrollment or a security key. Sign in on the web first, then retry.");
+      }
+      const code = (await askVisible("MFA code (6 digits): ")).trim();
+      if (!/^\d{6}$/.test(code)) throw new CliError("The MFA code must be 6 digits.");
+      result = await client.verifyMfaTotpLogin({ loginToken: outcome.challenge.loginToken, code });
+    } else {
+      result = outcome.result;
+    }
+  } catch (error) {
+    if (error instanceof CliError) throw error;
     throw new CliError("Login failed. Check the email and password, then try again.");
   }
   if (!result?.token || !result?.secret) throw new CliError("The server did not return usable credentials.");
@@ -19784,11 +21269,11 @@ function reduceSessionReadState(state, change, merge, fingerprintLimit = DEFAULT
   const { item } = change;
   if (state.fingerprints.includes(item.fingerprint)) return state;
   if (change.kind === "event" && item.cursor !== null && state.cursor !== null && item.cursor < state.cursor) return state;
-  const fingerprints = [...state.fingerprints, item.fingerprint].slice(-Math.max(1, fingerprintLimit));
+  const fingerprints2 = [...state.fingerprints, item.fingerprint].slice(-Math.max(1, fingerprintLimit));
   return {
     value: merge(state.value, item.value),
     cursor: item.cursor === null ? state.cursor : Math.max(state.cursor ?? item.cursor, item.cursor),
-    fingerprints
+    fingerprints: fingerprints2
   };
 }
 function record(value2) {
@@ -20114,12 +21599,12 @@ const codexUltraEffortOptions = [
 function getEffortOptionsForAgent(agent, model) {
   if (model === "default") return [];
   if (agent === "codex") {
-    if (model === "gpt-5.6-sol" || model === "gpt-5.6-terra") return codexUltraEffortOptions;
+    if (model === "gpt-6-astra" || model === "gpt-5.6-sol" || model === "gpt-5.6-terra") return codexUltraEffortOptions;
     if (model === "gpt-5.6-luna") return codexMaxEffortOptions;
     return codexEffortOptions;
   }
   if (agent === "gemini" || agent === "opencode" || agent === "grok") return [];
-  if (model === "claude-fable-5") return claudeFableEffortOptions;
+  if (model === "claude-fable-5-1") return claudeFableEffortOptions;
   return claudeEffortOptions;
 }
 function defaultEffortForAgent(agent, model) {
@@ -20127,7 +21612,7 @@ function defaultEffortForAgent(agent, model) {
   if (options.length === 0) return null;
   if (agent === "codex") {
     if (model === "gpt-5.6-sol") return "low";
-    if (model === "gpt-5.6-terra" || model === "gpt-5.6-luna") return "medium";
+    if (model === "gpt-6-astra" || model === "gpt-5.6-terra" || model === "gpt-5.6-luna") return "medium";
   }
   return options.some((option) => option.key === "high") ? "high" : options[options.length - 1].key;
 }
@@ -20139,13 +21624,14 @@ const newSessionAgents = [
 ];
 const claudeModelOptions = [
   { key: "default", label: "Default" },
-  { key: "claude-fable-5", label: "Fable 5" },
+  { key: "claude-fable-5-1", label: "Fable 5.1" },
   { key: "claude-opus-5", label: "Opus 5" },
   { key: "claude-sonnet-5", label: "Sonnet 5" },
   { key: "claude-haiku-4-5", label: "Haiku 4.5" }
 ];
 const codexModelOptions = [
   { key: "default", label: "Default" },
+  { key: "gpt-6-astra", label: "GPT-6 Astra" },
   { key: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
   { key: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
   { key: "gpt-5.6-luna", label: "GPT-5.6 Luna" },
@@ -20178,10 +21664,18 @@ function getModelsForAgent(agent) {
   if (agent === "grok") return grokModelOptions;
   return claudeModelOptions;
 }
+const RETIRED_MODEL_KEYS = {
+  "claude-fable-5": "claude-fable-5-1"
+};
+function isKnownModelForAgent(agent, model) {
+  const current = RETIRED_MODEL_KEYS[model] ?? model;
+  return getModelsForAgent(agent).some((option) => option.key === current);
+}
 function normalizeModelForAgent(agent, model) {
   if (agent === "opencode") return model || "default";
+  const current = RETIRED_MODEL_KEYS[model] ?? model;
   const models = getModelsForAgent(agent);
-  return models.some((option) => option.key === model) ? model : models[0]?.key ?? "default";
+  return models.some((option) => option.key === current) ? current : models[0]?.key ?? "default";
 }
 function normalizeModelSelectionOptions(agent, current, patch) {
   const model = normalizeModelForAgent(agent, patch.model ?? current.model);
@@ -20236,7 +21730,7 @@ function updateLiveChatSettings(current, patch) {
   }
   let selection = { model: current.model, effort: current.effort };
   if (patch.model !== void 0) {
-    if (!liveChatModelChoices(current).some((option) => option.key === patch.model)) return current;
+    if (!isKnownModelForAgent(current.agent, patch.model)) return current;
     selection = normalizeModelSelectionOptions(current.agent, selection, { model: patch.model });
   }
   if (patch.effort !== void 0) {
@@ -20741,7 +22235,7 @@ function chatUploadRelPath(file, id) {
   if (file.type.startsWith("image/")) return `.aplus/uploads/${id}.${extensionFor(file)}`;
   return `.aplus/uploads/${id}-${safeFileName(file)}`;
 }
-async function uploadChatFileToMachineCore(file, workspaceRoot, deps) {
+async function uploadChatFileToMachineCore(file, workspaceRoot, deps, relativePath) {
   const root = workspaceRoot.trim().replace(/\/+$/, "");
   if (!root) throw new Error(translateCurrent("upload.noWorkspaceRoot"));
   const id = (deps.now?.() ?? Date.now()).toString(36) + (deps.random?.() ?? Math.random()).toString(36).slice(2, 8);
@@ -21134,14 +22628,12 @@ function hasNewConversationSettings(request) {
   return request.model !== void 0 || request.effort !== void 0 || request.useWorktree === true || request.worktreeName !== void 0 || request.worktreeBaseRef !== void 0 || request.files !== void 0 || request.voice === true || request.voiceFile !== void 0;
 }
 function validateExplicitSelection(request, agent) {
-  if (request.model !== void 0 && !modelChoices(agent).some((option) => option.key === request.model)) {
+  if (request.model !== void 0 && !isKnownModelForAgent(agent, request.model)) {
     throw new CliError(`Unknown ${agent} model "${request.model}".`);
   }
-  if (request.effort !== void 0) {
-    const model = request.model ?? DEFAULT_CLI_NEW_CONVERSATION_OPTIONS.model;
-    if (!effortChoices(agent, model).some((option) => option.key === request.effort)) {
-      throw new CliError(`Effort "${request.effort}" is not available for ${agent} model "${model}".`);
-    }
+  const model = request.model === void 0 ? DEFAULT_CLI_NEW_CONVERSATION_OPTIONS.model : normalizeModelForAgent(agent, request.model);
+  if (request.effort !== void 0 && !effortChoices(agent, model).some((option) => option.key === request.effort)) {
+    throw new CliError(`Effort "${request.effort}" is not available for ${agent} model "${model}".`);
   }
 }
 async function resolveCliNewConversationOptions(request, ask) {
@@ -21190,6 +22682,7 @@ const USAGE_SETTINGS_NAVIGATION_DESTINATIONS = [
   "settings_shortcuts",
   "settings_machines",
   "settings_mobile",
+  "settings_network",
   "settings_env",
   "settings_security",
   "settings_memory",
@@ -22087,7 +23580,8 @@ function normalizeSessionRows(rows, candidateKeys) {
       directory: readString(metadata, "path") ?? "",
       summary: readSummary(metadata),
       active: row2.active === true,
-      updatedAt: row2.updatedAt ?? 0
+      updatedAt: row2.updatedAt ?? 0,
+      agentState: decryptJsonWithCandidates(row2.agentState, candidateKeys)
     });
   }
   return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
@@ -22116,9 +23610,9 @@ async function resolveMachineId(context, query) {
   const match = matchMachine(machines, query);
   if (match.type === "match") return match.machine.id;
   if (match.type === "not-found") throw new CliError(`No machine matches "${query}". Run \`saycode machines\` to list them.`);
-  const candidates = match.candidates.map((machine) => `  ${machine.host}  (${machine.id.slice(0, 8)})`).join("\n");
+  const candidates2 = match.candidates.map((machine) => `  ${machine.host}  (${machine.id.slice(0, 8)})`).join("\n");
   throw new CliError(`"${query}" matches more than one machine:
-${candidates}
+${candidates2}
 
 Use a longer prefix or the machine id.`);
 }
@@ -23455,6 +24949,7 @@ function readAgentEnv(env) {
   if (!root) return null;
   return {
     root,
+    scope: normalizeDirectory(env.SAYCODE_AGENT_SCOPE ?? "") || root,
     depth: readNonNegativeInt(env.SAYCODE_AGENT_DEPTH, 0),
     maxSpawn: Math.min(
       readNonNegativeInt(env.SAYCODE_AGENT_MAX_SPAWN, DEFAULT_AGENT_MAX_SPAWN),
@@ -23473,8 +24968,9 @@ function childAgentEnv(parent, childAgentId) {
   return {
     [AGENT_ENV_FLAG]: "1",
     SAYCODE_AGENT_ROOT: parent.root,
+    SAYCODE_AGENT_SCOPE: parent.scope,
     SAYCODE_AGENT_DEPTH: String(parent.depth + 1),
-    SAYCODE_AGENT_MAX_SPAWN: String(parent.maxSpawn),
+    SAYCODE_AGENT_MAX_SPAWN: String(Math.min(parent.maxSpawn, DEFAULT_AGENT_MAX_SPAWN)),
     SAYCODE_AGENT_ID: childAgentId
   };
 }
@@ -23487,6 +24983,9 @@ function isInScope(session, scope) {
   if (directory === root) return true;
   return directory.startsWith(root === "/" ? "/" : `${root}/`);
 }
+function sessionsInScope(sessions, scope) {
+  return sessions.filter((session) => isInScope(session, scope));
+}
 function machineSettingsPaths(input) {
   const override = input.env.SAYCODE_HAPPY_HOME?.trim();
   const runtimeHome = input.env.HAPPY_HOME_DIR?.trim();
@@ -23697,7 +25196,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent, modelOption
     runtime.recordSpawn({
       ts: runtime.now(),
       agentKey: key,
-      root: env.root,
+      root: env.scope,
       depth: env.depth,
       childSessionId: sessionId,
       ...env.sessionId ? { parentSessionId: env.sessionId } : {},
@@ -23801,6 +25300,7 @@ function canControlSpawnedDescendant(records, parentSessionId, childSessionId) {
   return resolveSubagentControlPermission(lineage, parentSessionId, childSessionId);
 }
 function ownershipFailure(runtime, env, target) {
+  if (env.depth === 0) return null;
   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 {
@@ -23841,6 +25341,143 @@ async function stopOwnedTarget(runtime, env, target) {
     return agentFail("stop_rejected", error instanceof Error ? error.message : String(error));
   }
 }
+const LAST_AGENT_TEXT_PREVIEW_LENGTH = 240;
+function deriveAgentSessionState(snapshot, active) {
+  if (!active) return "ended";
+  if (awaitingUserInput(snapshot)) return "waiting-input";
+  if (snapshot.thinking) return "responding";
+  return "idle";
+}
+function turnOpenInWindow(contents) {
+  let lastEnd = -1;
+  let lastActivity = -1;
+  contents.forEach((content, index) => {
+    if (turnBoundary(content) === "end") lastEnd = index;
+    else if (isTurnActivity(content)) lastActivity = index;
+  });
+  return lastActivity > lastEnd;
+}
+const TURN_ACTIVITY_EVENTS = /* @__PURE__ */ new Set(["turn-start", "text", "tool-call-start", "tool-call-progress", "tool-call-end"]);
+function isTurnActivity(content) {
+  if (content.role === "user") return true;
+  if (content.role !== "session") return false;
+  return TURN_ACTIVITY_EVENTS.has(content.content.ev.t);
+}
+function lastAgentTextPreview(message, max = LAST_AGENT_TEXT_PREVIEW_LENGTH) {
+  if (!message) return null;
+  const text2 = message.content;
+  return text2.length <= max ? text2 : `${text2.slice(0, max)}…`;
+}
+function pendingOf(snapshot) {
+  return {
+    askUserQuestion: Boolean(snapshot.pendingAskUserQuestion),
+    exitPlanMode: Boolean(snapshot.pendingExitPlanMode),
+    permissionRequests: snapshot.pendingPermissionRequestCount ?? 0
+  };
+}
+const STATUS_CONCURRENCY = 4;
+async function sessionStatus(runtime, session) {
+  let sequenced = [];
+  let error = null;
+  try {
+    sequenced = await runtime.readSequencedMessages(session.id, STATE_WINDOW_MESSAGES);
+  } catch (cause) {
+    error = cause instanceof Error ? cause.message : String(cause);
+  }
+  let snapshot = createWaitSnapshot();
+  for (const { content } of sequenced) snapshot = foldMessageIntoSnapshot(snapshot, content);
+  snapshot = foldAgentStateIntoSnapshot(snapshot, session.agentState ?? null);
+  if (turnOpenInWindow(sequenced.map((entry) => entry.content))) snapshot = { ...snapshot, thinking: true };
+  return {
+    ...sessionSummary(session),
+    state: deriveAgentSessionState(snapshot, session.active),
+    turnEndedAt: snapshot.lastResponseCompletedAt ?? 0,
+    completion: completionSignalOf(snapshot),
+    pending: pendingOf(snapshot),
+    lastAgentText: lastAgentTextPreview(snapshot.finalAgentMessage),
+    lastSeq: sequenced.reduce((max, entry) => Math.max(max, entry.seq), 0),
+    ...error !== null ? { error } : {}
+  };
+}
+async function listSessionStatus(runtime, scope) {
+  const sessions = sessionsInScope(await runtime.listSessions(), scope);
+  const rows = [];
+  for (let index = 0; index < sessions.length; index += STATUS_CONCURRENCY) {
+    const batch = sessions.slice(index, index + STATUS_CONCURRENCY);
+    rows.push(...await Promise.all(batch.map((session) => sessionStatus(runtime, session))));
+  }
+  return agentOk({ sessions: rows });
+}
+async function resolveAll(runtime, scope, sessionIds) {
+  const sessions = await runtime.listSessions();
+  const targets = [];
+  for (const sessionId of sessionIds) {
+    const session = sessions.find((candidate) => candidate.id === sessionId);
+    if (!session) return agentFail("session_not_found", sessionId);
+    if (!isInScope(session, scope)) return agentFail("out_of_scope", sessionId);
+    targets.push({ session, scope });
+  }
+  return targets;
+}
+async function waitForAnyTarget(runtime, scope, sessionIds, until, timeoutMs) {
+  const resolved = await resolveAll(runtime, scope, sessionIds);
+  if (!Array.isArray(resolved)) return resolved;
+  const since = runtime.now();
+  const predicate = untilPredicate(until, since);
+  const streams = [];
+  for (const target of resolved) {
+    try {
+      streams.push(await runtime.openStream(target.session.id));
+    } catch (error) {
+      for (const stream2 of streams) stream2.close();
+      throw error;
+    }
+  }
+  const controllers = resolved.map(() => new AbortController());
+  const pins = resolved.map((target, index) => startIdentityPin(runtime, target, controllers[index]));
+  const outcomes = new Map(resolved.map((target) => [target.session.id, "pending"]));
+  try {
+    await new Promise((resolve) => {
+      let settled = 0;
+      resolved.forEach((target, index) => {
+        void waitForSessionState({
+          current: streams[index].current,
+          subscribe: streams[index].subscribe,
+          predicate,
+          timeoutMs,
+          signal: controllers[index].signal
+        }).then((result) => {
+          const id = target.session.id;
+          if (result.outcome === "satisfied") outcomes.set(id, "satisfied");
+          else if (result.outcome === "aborted") {
+            if (pins[index].lost()) outcomes.set(id, "lost");
+          } else outcomes.set(id, "timeout");
+          settled += 1;
+          if (result.outcome === "satisfied" || settled === resolved.length) resolve();
+        });
+      });
+    });
+  } finally {
+    for (const controller of controllers) controller.abort();
+    for (const pin of pins) pin.stop();
+    for (const stream2 of streams) stream2.close();
+  }
+  const satisfied = resolved.filter((target, index) => outcomes.get(target.session.id) !== "lost" && predicate(streams[index].current())).map((target) => target.session.id);
+  const lost = resolved.map((target) => target.session.id).filter((id) => outcomes.get(id) === "lost");
+  const pending = resolved.map((target) => target.session.id).filter((id) => !satisfied.includes(id) && !lost.includes(id));
+  if (satisfied.length > 0) {
+    return agentOk({
+      outcome: "satisfied",
+      until,
+      satisfied,
+      pending,
+      lost,
+      sessions: resolved.filter((target) => satisfied.includes(target.session.id)).map((target) => sessionSummary(target.session))
+    });
+  }
+  if (lost.length === resolved.length) return agentFail("session_not_running", lost.join(","));
+  return agentFail("wait_timeout", `${until} not reached within ${timeoutMs}ms${lost.length ? ` (lost: ${lost.join(",")})` : ""}`);
+}
 const CLI_CONFIGURABLE_AGENTS = [.../* @__PURE__ */ new Set([
   ...newSessionAgents.map(({ id }) => id),
   "gemini"
@@ -23855,7 +25492,6 @@ function cliSpawnModelOptions() {
   }));
 }
 const DEFAULT_READ_LIMIT = 20;
-const STATE_WINDOW_MESSAGES = 50;
 function scopeOf(runtime) {
   const env = readAgentEnv(runtime.env);
   if (!env) return agentFail("not_agent_env", "This command only runs inside a Saycode-spawned session.");
@@ -23866,7 +25502,7 @@ function scopeOf(runtime) {
   if (!machineId) {
     return agentFail("out_of_scope", "Could not determine this machine from any happy home settings.");
   }
-  return { scope: { root: env.root, machineId }, env };
+  return { scope: { root: env.scope, machineId }, env };
 }
 function isFailure(value2) {
   return typeof value2 === "object" && value2 !== null && "stdout" in value2;
@@ -23878,13 +25514,13 @@ async function resolveTarget(runtime, scope, sessionId) {
   if (!isInScope(session, scope)) return agentFail("out_of_scope", sessionId);
   return { session, scope };
 }
-async function readSession(runtime, target, last) {
-  const messages = await runtime.readMessages(target.session.id, Math.max(last, STATE_WINDOW_MESSAGES));
+async function readSession(runtime, target, last, since = 0) {
+  const sequenced = await runtime.readSequencedMessages(target.session.id, Math.max(last, STATE_WINDOW_MESSAGES));
   let snapshot = createWaitSnapshot();
   const text2 = [];
-  for (const message of messages) {
+  for (const { seq, content: message } of sequenced) {
     snapshot = foldMessageIntoSnapshot(snapshot, message);
-    if (message.role !== "session") continue;
+    if (seq <= since || message.role !== "session") continue;
     const envelope = message.content;
     if (envelope.ev.t !== "text") continue;
     text2.push({
@@ -23900,6 +25536,8 @@ async function readSession(runtime, target, last) {
     session: sessionSummary(target.session),
     turnEndedAt: snapshot.lastResponseCompletedAt ?? 0,
     completion: completionSignalOf(snapshot),
+    // 0 when the window is empty: "start from the beginning", never a stale cursor.
+    lastSeq: sequenced.reduce((max, entry) => Math.max(max, entry.seq), 0),
     // `slice(-0)` is `slice(0)` — the whole array. `--last 0` is a reasonable
     // way to ask for state without the transcript, and it must not answer with
     // every message in the window.
@@ -23913,11 +25551,11 @@ async function spawnSibling(runtime, env, text2, agent, contextFiles = [], model
   }
   const context = resolveSpawnContextFiles({
     paths: contextFiles,
-    root: env.root,
+    root: env.scope,
     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`);
+    return context.reason === "out_of_scope" ? agentFail("out_of_scope", `${context.path} is outside ${env.scope}`) : agentFail("file_unreadable", `${context.path} could not be read`);
   }
   const key = spawnBudgetKey(env);
   let spawned;
@@ -23946,7 +25584,7 @@ async function spawnSibling(runtime, env, text2, agent, contextFiles = [], model
     runtime.recordSpawn({
       ts: runtime.now(),
       agentKey: key,
-      root: env.root,
+      root: env.scope,
       depth: env.depth,
       childSessionId: sessionId,
       ...env.sessionId ? { parentSessionId: env.sessionId } : {},
@@ -23976,7 +25614,8 @@ async function runAgentCommand(runtime, args) {
       spawned = null;
     }
     return agentOk({
-      root: scope.root,
+      root: env.root,
+      scope: env.scope,
       machineId: scope.machineId,
       // Which session this IS. Null when happy-cli did not supply it, and a
       // handoff must then be told its source explicitly rather than guess.
@@ -23990,8 +25629,8 @@ async function runAgentCommand(runtime, args) {
     });
   }
   if (args.verb === "ls") {
-    const sessions = await runtime.listSessions();
-    return agentOk({ sessions: sessions.filter((session) => isInScope(session, scope)).map(sessionSummary) });
+    if (args.status) return listSessionStatus(runtime, scope);
+    return agentOk({ sessions: sessionsInScope(await runtime.listSessions(), scope).map(sessionSummary) });
   }
   if (args.verb === "spawn") {
     const agent = args.agent ?? DEFAULT_SPAWN_AGENT;
@@ -24002,12 +25641,15 @@ async function runAgentCommand(runtime, args) {
     }
     return spawnSibling(runtime, env, args.text ?? "", agent, args.files ?? [], modelOptions);
   }
+  if (args.verb === "wait" && args.sessionIds) {
+    return waitForAnyTarget(runtime, scope, args.sessionIds, args.until ?? "turn-end", clampWaitTimeout(args.timeoutMs));
+  }
   if (!args.sessionId) return agentFail("session_not_found", "no session id given");
   const target = await resolveTarget(runtime, scope, args.sessionId);
   if (isFailure(target)) return target;
   switch (args.verb) {
     case "read":
-      return readSession(runtime, target, args.last ?? DEFAULT_READ_LIMIT);
+      return readSession(runtime, target, args.last ?? DEFAULT_READ_LIMIT, args.since);
     case "wait":
       return waitForTarget(runtime, target, args.until ?? "turn-end", clampWaitTimeout(args.timeoutMs));
     case "prompt":
@@ -24043,13 +25685,16 @@ function parseSpawnRecord(value2) {
 }
 const LEDGER_FILE_MODE = 384;
 const PREVIEW_MAX_LENGTH = 200;
-function agentLineagePath(homeDir) {
+function agentLineagePath(rootDir) {
+  return join(rootDir, ".aplus", "agent-lineage.jsonl");
+}
+function legacyAgentLineagePath(homeDir) {
   return join(homeDir, ".saycode", "agent-lineage.jsonl");
 }
-function readSpawnRecords(homeDir) {
+function readLedger(path) {
   let raw;
   try {
-    raw = readFileSync(agentLineagePath(homeDir), "utf8");
+    raw = readFileSync(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -24067,12 +25712,38 @@ function readSpawnRecords(homeDir) {
   }
   return records;
 }
-function countSpawnsFor(homeDir, agentKey) {
-  return readSpawnRecords(homeDir).filter((record2) => record2.agentKey === agentKey).length;
+function recordIdentity(record2) {
+  return JSON.stringify([
+    record2.ts,
+    record2.agentKey,
+    record2.root,
+    record2.depth,
+    record2.childSessionId,
+    record2.parentSessionId ?? null,
+    record2.agent,
+    record2.promptPreview,
+    record2.outcome
+  ]);
+}
+function readSpawnRecords(homeDir, rootDir) {
+  const records = [
+    ...readLedger(legacyAgentLineagePath(homeDir)),
+    ...readLedger(agentLineagePath(rootDir))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return records.filter((record2) => {
+    const identity = recordIdentity(record2);
+    if (seen.has(identity)) return false;
+    seen.add(identity);
+    return true;
+  });
+}
+function countSpawnsFor(homeDir, rootDir, agentKey) {
+  return readSpawnRecords(homeDir, rootDir).filter((record2) => record2.agentKey === agentKey).length;
 }
-function appendSpawnRecord(homeDir, record2) {
-  const path = agentLineagePath(homeDir);
-  mkdirSync(join(homeDir, ".saycode"), { recursive: true, mode: 448 });
+function appendSpawnRecord(rootDir, record2) {
+  const path = agentLineagePath(rootDir);
+  mkdirSync(join(rootDir, ".aplus"), { recursive: true, mode: 448 });
   const entry = { ...record2, promptPreview: record2.promptPreview.slice(0, PREVIEW_MAX_LENGTH) };
   appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: LEDGER_FILE_MODE });
@@ -24219,7 +25890,7 @@ async function recentContents(context, transport, sessionId, limit) {
     const ciphertext = unwrapEncryptedField(message.content);
     if (!ciphertext) continue;
     const content = decodeContent(transport, ciphertext);
-    if (content) contents.push(content);
+    if (content) contents.push({ seq: message.seq, content });
   }
   return contents;
 }
@@ -24252,7 +25923,7 @@ async function openStream(context, transport, sessionId) {
     else apply(update);
   });
   try {
-    for (const content of await recentContents(context, transport, sessionId, STREAM_HISTORY_LIMIT)) {
+    for (const { content } of await recentContents(context, transport, sessionId, STREAM_HISTORY_LIMIT)) {
       snapshot = foldMessageIntoSnapshot(snapshot, content);
     }
   } catch (error) {
@@ -24276,7 +25947,7 @@ async function openStream(context, transport, sessionId) {
 }
 function createAgentRuntime(context, transport, env = process.env) {
   const keys = [decodeBase64(context.syncCredential.secret)];
-  const homeDir = context.homeDir;
+  const homeDir = context.homeDir, lineageRoot = readAgentEnv(env)?.scope ?? context.homeDir;
   const credentialHome = context.credential.source === "saycode" ? null : dirname(context.credential.path);
   return {
     env,
@@ -24286,7 +25957,8 @@ function createAgentRuntime(context, transport, env = process.env) {
     readFile: readFileOrNull,
     isReadableFile: isReadableFileSync,
     listSessions: async () => normalizeSessionRows(await context.rest.listSessions(), keys),
-    readMessages: (sessionId, limit) => recentContents(context, transport, sessionId, limit),
+    readMessages: async (sessionId, limit) => (await recentContents(context, transport, sessionId, limit)).map((entry) => entry.content),
+    readSequencedMessages: (sessionId, limit) => recentContents(context, transport, sessionId, limit),
     openStream: (sessionId) => openStream(context, transport, sessionId),
     sendPrompt: async (sessionId, text2) => createCliSessionConnection({
       rest: context.rest,
@@ -24317,9 +25989,9 @@ function createAgentRuntime(context, transport, env = process.env) {
       return { sessionId: result.sessionId };
     },
     newAgentId: () => randomBytes(8).toString("hex"),
-    countSpawns: (agentKey) => countSpawnsFor(homeDir, agentKey),
-    recordSpawn: (record2) => appendSpawnRecord(homeDir, record2),
-    readLineage: () => readSpawnRecords(homeDir),
+    countSpawns: (agentKey) => countSpawnsFor(homeDir, lineageRoot, agentKey),
+    recordSpawn: (record2) => appendSpawnRecord(lineageRoot, record2),
+    readLineage: () => readSpawnRecords(homeDir, lineageRoot),
     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