@buzzni/saycode-cli 0.3.3 → 0.5.0

package/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline";
-import { homedir, tmpdir, platform } from "node:os";
+import { homedir, tmpdir, platform, totalmem, cpus } from "node:os";
 import require$$0$4, { Buffer as Buffer$1 } from "buffer";
 import require$$0 from "crypto";
 import require$$0$1 from "fs";
@@ -16,7 +16,7 @@ import require$$3$1 from "net";
 import require$$4$1 from "tls";
 import require$$0$5 from "stream";
 import require$$0$3 from "zlib";
-import { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$1, appendFileSync, accessSync, statSync } from "node:fs";
+import { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$1, appendFileSync, openSync, fstatSync, readSync, closeSync, accessSync, statSync } from "node:fs";
 import { dirname, join, basename, extname, delimiter } from "node:path";
 import { readFile, stat, mkdtemp, access, rm, mkdir, appendFile, writeFile, chmod } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
@@ -40,9 +40,9 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.3.3";
+const version$1 = "0.5.0";
 const manifest = {
-  version
+  version: version$1
 };
 const AGENT_CONTROL_VERBS = ["steer", "stop"];
 function parseAgentControlArgs(verb, target, rest, hasPositionalTarget) {
@@ -75,12 +75,23 @@ 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$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 } : {} };
+      return {
+        command: "agent",
+        verb: "read",
+        sessionId: target,
+        ...flags.last !== void 0 ? { last: flags.last } : {},
+        ...flags.since !== void 0 ? { since: flags.since } : {}
+      };
     }
     case "wait": {
+      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 };
@@ -260,6 +271,14 @@ const machineUsageKo = {
   "machineUsage.pollingNote": "{minutes}분 전 · 머신당 5분마다 한 번만 조회",
   "machineUsage.autoSwitched": "{provider} 계정을 자동 전환했습니다: {from} → {to}"
 };
+const hubSessionKo = {
+  "hubSession.enable": "이 대화를 프로젝트 허브로",
+  "hubSession.disable": "프로젝트 허브 해제",
+  "hubSession.hint": "같은 프로젝트의 다른 대화가 턴을 끝내거나 입력을 기다리면 이 대화에 메시지로 알려줍니다",
+  "hubSession.newSessionLabel": "이 대화를 프로젝트 허브로 시작",
+  "hubSession.newSessionHint": "다른 대화의 완료·질문을 여기로 모읍니다",
+  "hubSession.newSessionReplaces": '지금 허브는 "{title}" — 켜면 이 대화로 바뀝니다'
+};
 const taskNotificationKo = {
   "taskNotification.ariaLabel": "백그라운드 작업 알림",
   "taskNotification.status.completed": "작업 완료",
@@ -316,7 +335,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 +389,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 +418,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 +438,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 +453,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 +598,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 +649,8 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.nameLabel": "이름",
   "scheduledAutomations.promptLabel": "프롬프트",
   "scheduledAutomations.agentLabel": "실행 에이전트",
+  "scheduledAutomations.personaLabel": "실행 페르소나",
+  "scheduledAutomations.personaNone": "없음",
   "scheduledAutomations.scheduleLabel": "스케줄",
   "scheduledAutomations.scheduleInterval": "주기 (분마다)",
   "scheduledAutomations.scheduleDaily": "매일 지정 시각",
@@ -670,6 +698,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 +783,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 +815,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": "프로젝트 메모리를 불러오는 중…",
@@ -830,7 +866,19 @@ const extensionInstallKo = {
   "artifactPublication.open": "링크 열기",
   "artifactPublication.revoke": "공개 중지",
   "artifactPublication.revoking": "중지 중…",
-  "artifactPublication.failed": "공개 링크 작업에 실패했습니다."
+  "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": "무엇을 도와드릴까요?",
@@ -864,7 +912,7 @@ const personalChatsKo = {
   "personalChats.creating": "채팅을 시작하는 중…",
   "personalChats.noOnlineMachine": "온라인 머신이 없습니다. 채팅을 시작하려면 머신을 시작해주세요.",
   "personalChats.localMachinePreparing": "이 컴퓨터를 Saycode에 연결하는 중이에요. 잠시 후 바로 시작할 수 있어요.",
-  "personalChats.localMachineAsk": "이 컴퓨터를 바로 사용할 수 있어요. 클릭 한 번으로 연결을 마치세요.",
+  "personalChats.localMachineAsk": "이 컴퓨터에 Saycode CLI를 설치하면 바로 채팅을 시작할 수 있어요.",
   "personalChats.localMachineFailed": "이 컴퓨터 자동 연결에 실패했어요. 다른 방법으로 연결할 수 있어요.",
   "personalChats.pickMachine": "이 채팅을 실행할 머신을 선택하세요",
   "personalChats.back": "뒤로",
@@ -928,16 +976,49 @@ 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": "다음",
+  "settings.memoryEvents.delete": "삭제",
+  "settings.memoryEvents.confirmDelete": "정말 삭제",
+  "settings.memoryEvents.deleteHint": "삭제한 기억은 되돌릴 수 없습니다.",
+  "settings.memoryEvents.deleteFailed": "삭제하지 못했습니다: {reason}"
+};
 const externalWorktreeInboxKo = {
   "externalWorktreeInbox.title": "앱 밖에서 만든 worktree",
   "externalWorktreeInbox.description": "이 저장소에 앱이 만들지 않은 worktree 가 있습니다. 채택하면 목록과 새 대화 시작에서 고를 수 있어요.",
@@ -968,6 +1049,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}"
 };
@@ -1056,7 +1230,46 @@ const accountSettingsKo = {
   "settingsGroup.devices": "기기",
   "settingsGroup.app": "앱",
   "shortcuts.action.settings": "환경설정 열기",
-  "shortcuts.action.settingsDescription": "환경설정 창을 엽니다."
+  "shortcuts.action.settingsDescription": "환경설정 창을 엽니다.",
+  "accountKeyRecovery.title": "암호화된 데이터가 잠겨 있습니다",
+  "accountKeyRecovery.description": "이 데스크톱에서 암호화된 데이터를 잠금 해제하려면 E2EE 복구 키를 입력하세요. 복구 키는 이 기기를 벗어나지 않습니다.",
+  "accountKeyRecovery.label": "E2EE 복구 키",
+  "accountKeyRecovery.unavailable": "이 계정에서는 복구 키 잠금 해제를 사용할 수 없습니다.",
+  "accountKeyRecovery.invalid": "복구 키로 암호화된 데이터를 잠금 해제하지 못했습니다.",
+  "accountKeyRecovery.failed": "복구 키 잠금 해제에 실패했습니다.",
+  "accountKeyRecovery.action": "암호화된 데이터 잠금 해제",
+  "accountKeyRecovery.busy": "잠금 해제 중…",
+  "accountKeyDevice.title": "신뢰 기기",
+  "accountKeyDevice.description": "기존 신뢰 기기에서 이 데스크톱을 승인하거나 대기 중인 기기 요청을 검토하세요.",
+  "accountKeyDevice.loading": "신뢰 기기 상태를 불러오는 중…",
+  "accountKeyDevice.loadFailed": "기기 승인 상태를 불러오지 못했습니다.",
+  "accountKeyDevice.stableIdentityUnavailable": "안정적인 기기 ID를 사용할 수 없어 신뢰 기기 등록을 진행할 수 없습니다.",
+  "accountKeyDevice.secureStorageUnavailable": "보안 기기 저장소를 사용할 수 없어 신뢰 기기 등록을 진행할 수 없습니다.",
+  "accountKeyDevice.qrFailed": "기기 승인 QR을 만들지 못했습니다.",
+  "accountKeyDevice.qrAlt": "기기 승인 QR 코드",
+  "accountKeyDevice.requestFailed": "기기 승인 요청에 실패했습니다.",
+  "accountKeyDevice.pending": "신뢰 기기의 승인을 기다리고 있습니다.",
+  "accountKeyDevice.completeFailed": "기기 승인을 완료하지 못했습니다.",
+  "accountKeyDevice.approved": "이 데스크톱이 신뢰 기기로 승인되었습니다.",
+  "accountKeyDevice.cancelled": "이 기기에서 승인 요청을 취소했습니다.",
+  "accountKeyDevice.cancelFailed": "기기 승인 요청을 취소하지 못했습니다.",
+  "accountKeyDevice.requestsFailed": "대기 중인 기기 요청을 불러오지 못했습니다.",
+  "accountKeyDevice.approveFailed": "기기를 승인하지 못했습니다.",
+  "accountKeyDevice.rejectFailed": "기기 요청을 거절하지 못했습니다.",
+  "accountKeyDevice.revokeFailed": "신뢰 기기를 폐기하지 못했습니다.",
+  "accountKeyDevice.cleanupFailed": "기기는 폐기됐지만 로컬 자격 증명을 삭제하지 못했습니다.",
+  "accountKeyDevice.lockPersistFailed": "기기는 폐기됐지만 로컬 세션 잠금을 저장하지 못했습니다.",
+  "accountKeyDevice.request": "기기 승인 요청",
+  "accountKeyDevice.check": "승인 확인",
+  "accountKeyDevice.cancel": "요청 취소",
+  "accountKeyDevice.scanBefore": "{time} 전에 승인된 기기에서 이 QR을 스캔하세요.",
+  "accountKeyDevice.expires": "{time}에 만료",
+  "accountKeyDevice.approve": "기기 승인",
+  "accountKeyDevice.reject": "기기 거절",
+  "accountKeyDevice.refresh": "요청 새로 고침",
+  "accountKeyDevice.current": "현재 데스크톱",
+  "accountKeyDevice.lastUsed": "마지막 사용: {time}",
+  "accountKeyDevice.revoke": "신뢰 기기 폐기"
 };
 const projectScopeKo = {
   "projectScope.protected": "프로젝트 범위 보호됨",
@@ -1106,7 +1319,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 사용 불가",
@@ -1194,7 +1407,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": "선택됨",
@@ -1252,6 +1475,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": "디렉터리 추가",
@@ -1272,11 +1505,7 @@ const additionalDirectoriesKo = {
   "additionalDirectories.machineMismatch": "현재 머신과 다른 위치에서 선택한 디렉터리입니다.",
   "additionalDirectories.saveFailed": "디렉터리를 등록하지 못했습니다.",
   "additionalDirectories.folderLoadFailed": "디렉터리를 불러오지 못했습니다.",
-  "additionalDirectories.relatedMountMissing": "관련 프로젝트 디렉터리 {count}개를 자동 마운트에서 제외하고 세션을 시작했습니다.",
-  "additionalDirectories.relatedMountLinkLookupFailed": "관련 프로젝트 목록을 불러오지 못해 자동 마운트 없이 세션을 시작했습니다.",
-  "additionalDirectories.relatedMountLookupFailed": "관련 프로젝트 {count}개를 불러오지 못해 제외하고 세션을 시작했습니다.",
-  "additionalDirectories.relatedMountRuntimeUnsupported": "이 머신의 Happy CLI가 관련 프로젝트 자동 마운트를 지원하지 않아 기본 세션으로 시작했습니다.",
-  "additionalDirectories.relatedMountLimit": "관련 프로젝트 디렉터리 상한을 넘어 {count}개를 제외하고 세션을 시작했습니다."
+  ...additionalDirectoryMountWarningKo
 };
 const agentHandoffKo = {
   "agentHandoff.open": "다른 에이전트로 이어가기",
@@ -1357,9 +1586,28 @@ const chatFolderUploadKo = {
   "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": "스테이지된 변경이 없습니다.",
+  "aiCommitPr.stagedUnknown": "스테이지된 변경을 확인하지 못했습니다.",
   "aiCommitPr.stageAll": "모든 변경 스테이지",
   "aiCommitPr.staging": "스테이지하는 중…",
   "aiCommitPr.messagePlaceholder": "커밋 메시지",
@@ -1436,8 +1684,188 @@ const connectorReadinessKo = {
   "connectorReadiness.state.configMissing": "설정 없음",
   "connectorReadiness.state.unknown": "상태 미확인"
 };
-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, ...chatFolderUploadKo, ...connectorReadinessKo };
+const checkpointKo = {
+  "checkpoint.activation.label": "파일 체크포인트 보호",
+  "checkpoint.activation.title": "에이전트가 파일을 변경하기 전에 세션별 체크포인트를 만듭니다.",
+  "checkpoint.activation.hint": "세션별",
+  "checkpoint.activation.unavailable.platform": "macOS에서만 지원",
+  "checkpoint.activation.unavailable.agent": "Claude와 Codex만 지원",
+  "checkpoint.activation.unavailable.sandbox": "프로젝트 샌드박스 필요",
+  "checkpoint.activation.unavailable.worktree": "작업 사본은 준비 중",
+  "checkpoint.activation.error": "파일 체크포인트 보호를 사용할 수 없습니다: {reason}",
+  "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, ...hubSessionKo };
 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": "첫 작업까지 함께 준비해요",
@@ -1460,9 +1888,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": "다른 컴퓨터나 조직 공유 머신은 머신 설정에서 추가할 수 있어요.",
@@ -1485,7 +1913,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": " (선택)",
@@ -1596,7 +2118,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": "언어를 선택하세요",
@@ -1661,8 +2183,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": "새 프로젝트",
@@ -1717,7 +2239,6 @@ const ko = {
   "newProject.gitNeedUrl": "Git 저장소 주소를 입력해 주세요.",
   "newProject.importDone": "'{name}' 프로젝트에 파일 {count}개를 가져왔습니다.",
   "newProject.importFailed": "'{name}' 프로젝트는 생성했지만 파일을 가져오지 못했습니다. {detail}",
-  "composer.attachFile": "파일 첨부",
   "composer.attachNeedMachine": "첨부하려면 머신 연결이 필요합니다",
   "composer.attachNoMachine": "파일을 업로드할 머신을 찾을 수 없습니다.",
   "composer.attachUploadFailed": "파일을 업로드하지 못했습니다.",
@@ -1744,7 +2265,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": "조직 설정",
@@ -1773,7 +2294,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 또는 설명 검색...",
@@ -1888,7 +2409,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 유지)",
@@ -2011,7 +2532,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": "생성",
@@ -2086,7 +2607,7 @@ const ko = {
   "panel.recovery.loginDesc": "로그인 후 터미널을 시작할 수 있습니다.",
   // Chat composer
   "composer.messageAria": "메시지",
-  "composer.placeholder": "데스크톱에서 보낼 메시지를 입력",
+  "composer.placeholder": "메시지를 입력하세요",
   "composer.promptSuggestionPaused": "{window} 사용량 {percent}% — 사용량 경고 중에는 Claude가 추천 질문을 만들지 않습니다",
   "composer.promptSuggestionPausedReset": "{reset} 초기화",
   "composer.starting": "시작 중...",
@@ -2139,18 +2660,20 @@ 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를 찾을 수 없습니다.",
   "gitControls.checkFailed": "Git 확인 실패",
+  "gitControls.retryStatus": "다시 확인",
   "gitControls.checking": "Git 확인 중",
   "gitControls.manageBranchAria": "{branch} branch 관리",
   "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} 결과",
@@ -2595,6 +3118,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 가 설치되어 있지 않아요. 운영자에게 설치 요청을 보내주세요.",
@@ -2857,6 +3386,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 모드를 시작하지 못했습니다.",
@@ -3044,6 +3589,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에 정리되지 않은 변경이 있습니다. 강제로 삭제할까요? 변경 사항이 사라집니다.",
@@ -3163,6 +3714,9 @@ const ko = {
   "preview.tokenUrlInvalid": "Preview 토큰 URL이 올바르지 않습니다.",
   "branchDialog.loading": "Branch 목록을 불러오는 중입니다.",
   "branchDialog.empty": "표시할 branch가 없습니다.",
+  "branchDialog.searchLabel": "브랜치 검색",
+  "branchDialog.searchPlaceholder": "브랜치 이름 검색",
+  "branchDialog.searchEmpty": "'{query}'와 일치하는 브랜치가 없습니다.",
   "branchDialog.actionsAria": "{name} 브랜치 작업",
   "branchDialog.rowAria": "{name} {meta}",
   "branchDialog.switch": "브랜치 이동",
@@ -3177,6 +3731,24 @@ const ko = {
   "branchDialog.deleteConfirm": "'{name}' 브랜치를 삭제할까요? 머지되지 않은 커밋이 있으면 Git이 거부합니다.",
   "branchDialog.deleteConfirmAction": "삭제",
   "branchDialog.cancel": "취소",
+  "branchCleanup.openAria": "병합된 브랜치 정리",
+  "branchCleanup.title": "정리 가능한 브랜치",
+  "branchCleanup.loading": "브랜치를 확인하는 중…",
+  "branchCleanup.empty": "정리 가능한 브랜치가 없습니다.",
+  "branchCleanup.scannedNote": "로컬 브랜치 {total}개 중 {count}개가 정리 가능합니다.",
+  "branchCleanup.selectAll": "모두 선택",
+  "branchCleanup.deselectAll": "모두 해제",
+  "branchCleanup.deleteSelected": "{count}개 삭제",
+  "branchCleanup.deleteFailed": "브랜치를 삭제할 수 없습니다.",
+  "branchCleanup.deletePartial": "{total}개 중 {failed}개를 삭제하지 못했습니다: {detail}",
+  "branchCleanup.loadFailed": "브랜치 확인을 실패했습니다.",
+  "branchCleanup.noBaseBranch": "기본 브랜치를 찾을 수 없습니다. origin/HEAD 를 설정하거나 프로젝트 설정에서 기본 브랜치를 지정하세요.",
+  "branchCleanup.probeIncomplete": "브랜치 정보를 완전히 읽지 못했습니다. 목록이 비어 보일 수 있으니 다시 시도하세요.",
+  "branchCleanup.demoUnsupported": "Demo 모드에서는 지원하지 않습니다.",
+  "branchCleanup.refreshAria": "브랜치 목록 새로고침",
+  "branchCleanup.squashScanning": "squash merge된 브랜치를 찾는 중…",
+  "branchCleanup.squashFailed": "squash merge 검사에 실패했습니다. 아래 목록은 일반 merge 후보만입니다.",
+  "branchCleanup.squashTag": "squash 병합",
   "message.deleteConfirm": "이 메시지를 삭제할까요? 이 작업은 새로고침 후에도 유지됩니다.",
   "message.deleteFailed": "메시지를 삭제할 수 없습니다.",
   "message.sendFailed": "메시지를 보낼 수 없습니다.",
@@ -3665,6 +4237,8 @@ const ko = {
   // ProjectDocumentViewer
   "inlinePreview.openInViewer": "파일 뷰어로 열기",
   "inlinePreview.loading": "미리보기를 불러오는 중",
+  "inlinePreview.loadFailed": "미리보기를 불러오지 못했습니다.",
+  "inlinePreview.retry": "다시 시도",
   "documentViewer.docxConvertFailed": "DOCX 문서를 변환하지 못했습니다.",
   "documentViewer.pdfViewer": "{name} PDF 뷰어",
   "documentViewer.pdfPreparing": "PDF를 준비하는 중...",
@@ -3715,7 +4289,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 저장",
@@ -3728,7 +4302,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 오류",
@@ -3858,7 +4432,7 @@ const ko = {
   "settingsTab.network": "네트워크 데이터 절약",
   "settingsTab.env": "환경 변수",
   "settingsTab.security": "보안",
-  "settingsTab.memory": "Memory",
+  "settingsTab.memory": "메모리",
   "settingsTab.connectors": "커넥터",
   "settingsTab.myAiCredentials": "내 AI 계정",
   "settingsTab.extensions": "확장",
@@ -3891,7 +4465,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": "단축키",
@@ -3984,7 +4560,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": "기록 지우기",
@@ -3995,7 +4571,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": "기록 복구",
@@ -4055,7 +4631,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}의 실행 중인 프로세스 목록",
@@ -4233,6 +4809,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) {
@@ -4433,6 +5010,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;
@@ -4588,12 +5171,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
@@ -6983,6 +7567,89 @@ 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);
+  const possessionPublicKey = bounded(method.possessionPublicKey, 43);
+  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,
+    ...possessionPublicKey && /^[A-Za-z0-9_-]{43}$/.test(possessionPublicKey) ? { possessionPublicKey } : {},
+    ...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");
@@ -6995,15 +7662,58 @@ function parseCloudLoginResult(raw) {
   };
   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 } : {}
+    ...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;
@@ -7048,6 +7758,19 @@ async function decryptDataKeyToString(dataEncryptionKey, bundleBase64) {
     return null;
   }
 }
+async function decryptDataKeyJson(dataEncryptionKey, bundleBase64) {
+  const json = await decryptDataKeyToString(dataEncryptionKey, bundleBase64);
+  if (json === null) return null;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+async function decryptDataKeyRecord(dataEncryptionKey, bundleBase64) {
+  const value2 = await decryptDataKeyJson(dataEncryptionKey, bundleBase64);
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+}
 async function encryptDataKeyContent(dataEncryptionKey, value2) {
   const nonce = nacl.randomBytes(GCM_NONCE_LENGTH);
   const key = await importGcmKey(dataEncryptionKey);
@@ -7059,28 +7782,64 @@ async function encryptDataKeyContent(dataEncryptionKey, value2) {
   bundle.set(ciphertextWithTag, 1 + GCM_NONCE_LENGTH);
   return encodeBase64(bundle);
 }
+let candidates = [];
+let version = 0;
+function dataKeyUnwrapCandidates(accountPrivateKey, companyKeys = getCompanyKeyCandidates()) {
+  return accountPrivateKey ? [accountPrivateKey, ...companyKeys] : [];
+}
+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();
+const companyUnwrappedEnvelopes = /* @__PURE__ */ new Map();
+function firstUnwrap(envelope, candidates2) {
+  for (const candidate of candidates2) {
+    const dek = unwrapDataEncryptionKey(envelope, candidate);
+    if (dek) return dek;
+  }
+  return null;
+}
+let boundaryGeneration$1 = 0;
+function sessionDekRegistryGeneration() {
+  return boundaryGeneration$1;
+}
+function adoptSessionDek(sessionId, envelope, dek, byCompanyKey) {
+  const existing = dekBySessionId.get(sessionId);
+  if (existing && existing.length === dek.length && existing.every((byte, index) => byte === dek[index])) dek.fill(0);
+  else dekBySessionId.set(sessionId, dek);
+  lockedSessionIds.delete(sessionId);
+  if (byCompanyKey) companyUnwrappedEnvelopes.set(sessionId, envelope);
+  else companyUnwrappedEnvelopes.delete(sessionId);
+}
 function registerSessionDek(session, accountPrivateKey) {
   const envelope = session.dataEncryptionKey ?? null;
   if (!envelope) {
     dekBySessionId.delete(session.id);
     lockedSessionIds.delete(session.id);
     fingerprints.delete(session.id);
+    companyUnwrappedEnvelopes.delete(session.id);
     return;
   }
-  const fingerprint = `${envelope}|${accountPrivateKey ? "1" : "0"}`;
+  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 dek = accountPrivateKey ? unwrapDataEncryptionKey(envelope, accountPrivateKey) : null;
+  const accountDek = accountPrivateKey ? unwrapDataEncryptionKey(envelope, accountPrivateKey) : null;
+  const dek = accountDek ?? (accountPrivateKey ? firstUnwrap(envelope, getCompanyKeyCandidates()) : null);
   if (dek) {
-    dekBySessionId.set(session.id, dek);
-    lockedSessionIds.delete(session.id);
-  } else {
-    dekBySessionId.delete(session.id);
-    lockedSessionIds.add(session.id);
+    adoptSessionDek(session.id, envelope, dek, accountDek === null);
+    return;
   }
+  if (dekBySessionId.has(session.id) && previousFingerprint?.startsWith(`${envelope}|`)) return;
+  dekBySessionId.delete(session.id);
+  lockedSessionIds.add(session.id);
+  if (companyUnwrappedEnvelopes.has(session.id)) companyUnwrappedEnvelopes.set(session.id, envelope);
 }
 function getSessionDek(sessionId) {
   return dekBySessionId.get(sessionId) ?? null;
@@ -7105,21 +7864,77 @@ function cacheSet(store, sessionId, ciphertext, plaintext) {
 function getCachedDataKeyMetadataJson(sessionId, ciphertext) {
   return cacheGet(headerCache, sessionId, ciphertext);
 }
-async function preDecryptSessionHeaders(sessions, accountPrivateKey) {
+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) cacheSet(headerCache, session.id, session.metadata, json);
+      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) cacheSet(headerCache, session.id, session.agentState, json);
+      if (json !== null && boundaryIntact()) cacheSet(headerCache, session.id, session.agentState, json);
     }
   }));
 }
+const machineDekById = /* @__PURE__ */ new Map();
+let boundaryGeneration = 0;
+function machineDekRegistryGeneration() {
+  return boundaryGeneration;
+}
+function discardMachineDek(machineId) {
+  machineDekById.get(machineId)?.dek.fill(0);
+  machineDekById.delete(machineId);
+}
+function machineFingerprint(envelope) {
+  return `${envelope}|${companyKeyChainVersion()}`;
+}
+async function resolveMachineDataKeyFields(record2, legacyKeys, privateKeys, scope) {
+  const discard = { machineId: record2.id, fields: null, entry: null };
+  if (!record2.dataEncryptionKey || !record2.metadata) return discard;
+  if (decryptJsonWithCandidates(record2.metadata, legacyKeys)) return discard;
+  const fingerprint = machineFingerprint(record2.dataEncryptionKey);
+  const cached = machineDekById.get(record2.id);
+  const machineKey = cached?.fingerprint === fingerprint ? cached.dek : unwrapMachineKey(record2.dataEncryptionKey, privateKeys);
+  if (!machineKey) return discard;
+  const metadata = await decryptDataKeyRecord(machineKey, record2.metadata);
+  if (!metadata) return discard;
+  const daemonState = record2.daemonState ? await decryptDataKeyRecord(machineKey, record2.daemonState) : null;
+  const entry = cached?.dek === machineKey ? cached : { dek: machineKey, scope, fingerprint };
+  entry.scope = scope;
+  return { machineId: record2.id, fields: { metadata, daemonState }, entry };
+}
+function commitMachineDek(resolved) {
+  if (resolved.entry) machineDekById.set(resolved.machineId, resolved.entry);
+  else discardMachineDek(resolved.machineId);
+}
+function unwrapMachineKey(envelope, privateKeys) {
+  for (const privateKey of privateKeys) {
+    const machineKey = unwrapDataEncryptionKey(envelope, privateKey);
+    if (machineKey) return machineKey;
+  }
+  return null;
+}
+async function decryptMachineDataKeyRows(rows, legacyKeys, options, scope, sinceGeneration = machineDekRegistryGeneration()) {
+  const none = () => rows.map(() => null);
+  if (sinceGeneration !== boundaryGeneration) return none();
+  const listed = new Set(rows.map((row2) => row2.id));
+  for (const [machineId, entry] of [...machineDekById]) {
+    if (entry.scope === scope && !listed.has(machineId)) discardMachineDek(machineId);
+  }
+  if (!options.accountPrivateKey || !rows.some((row2) => row2.dataEncryptionKey)) return none();
+  await options.dataKeyReady;
+  if (sinceGeneration !== boundaryGeneration) return none();
+  const privateKeys = dataKeyUnwrapCandidates(options.accountPrivateKey);
+  const resolved = await Promise.all(rows.map((row2) => resolveMachineDataKeyFields(row2, legacyKeys, privateKeys, scope)));
+  if (sinceGeneration !== boundaryGeneration) return none();
+  for (const entry of resolved) commitMachineDek(entry);
+  return resolved.map((entry) => entry.fields);
+}
 function buildUserTextMessageContent(input) {
   return {
     role: "user",
@@ -7238,69 +8053,69 @@ function personalMachinesPath(companyId) {
 function myMachinesPath(companyId) {
   return `/api/admin/companies/${encodeURIComponent(companyId)}/my-machines`;
 }
-function record$2(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$2(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$2(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$2(value2);
+  const row2 = record$4(value2);
   const statusProvider = provider(row2.provider);
   if (!statusProvider) return void 0;
-  const rotationRow = record$2(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,
@@ -7320,11 +8135,11 @@ function parseStatus(value2) {
   };
 }
 function parseMachineResult(value2) {
-  const row2 = record$2(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 {
@@ -7335,54 +8150,54 @@ function parseMachineResult(value2) {
   };
 }
 function parseAiCredentialVaultSnapshot(value2) {
-  const body = record$2(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$2(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$2(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$2(value2).machines).map((entry) => {
-    const row2 = record$2(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$2(value2).machines).map((entry) => {
-    const row2 = record$2(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,
@@ -7395,6 +8210,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) {
@@ -7764,7 +8717,7 @@ const PUBLICATION_KEYS = /* @__PURE__ */ new Set([
 function fail(detail) {
   throw new Error(`artifact publication response is invalid: ${detail}`);
 }
-function record$1(value2, label) {
+function record$2(value2, label) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) fail(`${label} must be an object`);
   return value2;
 }
@@ -7810,7 +8763,7 @@ function sourceIdentity(source) {
   ]) : JSON.stringify([source.chatId, source.path]);
 }
 function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
-  const publication = record$1(value2, "publication");
+  const publication = record$2(value2, "publication");
   if (Object.keys(publication).some((key) => !PUBLICATION_KEYS.has(key))) {
     fail("publication contains an unexpected field");
   }
@@ -7843,7 +8796,7 @@ function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
   };
 }
 function parseStaticArtifactPublicationResult(value2, options) {
-  const response = record$1(value2, "response");
+  const response = record$2(value2, "response");
   if (options.operation === "publish") {
     exactKeys(response, ["publication", "publicUrl", "reused"]);
     if (typeof response.reused !== "boolean") fail("reused is invalid");
@@ -11400,14 +12353,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;
     }
@@ -16178,10 +17131,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");
@@ -16580,6 +17533,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;
@@ -16663,19 +17626,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);
@@ -16683,40 +17646,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)) {
@@ -16738,13 +17701,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"]);
@@ -16753,16 +17717,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,
@@ -16800,6 +17764,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",
@@ -16919,6 +17975,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");
 }
@@ -16928,7 +17998,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;
   }
@@ -17017,7 +18089,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) {
@@ -17045,14 +18118,15 @@ function normalizeAutomationSupport(value2) {
     ...Number.isSafeInteger(capability.keyVersion) && capability.keyVersion > 0 ? { keyVersion: capability.keyVersion } : {}
   };
 }
-function normalizeMachine(row2, candidateKeys) {
+function normalizeMachine(row2, candidateKeys, dataKeyFields = null) {
   const registry = row2.registry;
-  const decrypted = decryptJsonWithCandidates(row2.metadata, candidateKeys) ?? {};
-  const daemonState = decryptJsonWithCandidates(row2.daemonState, candidateKeys);
+  const decrypted = dataKeyFields?.metadata ?? decryptJsonWithCandidates(row2.metadata, candidateKeys) ?? {};
+  const daemonState = dataKeyFields?.daemonState ?? decryptJsonWithCandidates(row2.daemonState, candidateKeys);
   const resources = row2.resources ?? parseMachineResources(daemonState);
   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,
@@ -17065,8 +18139,10 @@ 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
@@ -17096,8 +18172,57 @@ class ApiClient {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input)
     }, DEFAULT_REQUEST_TIMEOUT_MS);
+    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" });
   }
@@ -17394,6 +18519,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",
@@ -17532,6 +18668,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" });
   }
@@ -17668,6 +18808,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",
@@ -18168,13 +19347,16 @@ class ApiClient {
   async getMachines(companyId, candidateKeys = [], options = {}) {
     const company = companyId ?? "personal";
     const statusParam = options.withStatus ? "&withStatus=1" : "";
+    const dekGeneration = machineDekRegistryGeneration();
     const data = await this.request(
       `/api/machines/list?company=${encodeURIComponent(company)}${statusParam}`,
       { boundary: "api" }
     );
     const rows = Array.isArray(data) ? data : data.machines ?? [];
     const registry = await this.fetchMachineRegistry(rows.map((row2) => row2.id));
-    return rows.map((row2) => normalizeMachine(withMachineRegistry(row2, registry), candidateKeys));
+    const enriched = rows.map((row2) => withMachineRegistry(row2, registry));
+    const dataKeyFields = await decryptMachineDataKeyRows(enriched, candidateKeys, options, company, dekGeneration);
+    return enriched.map((row2, index) => normalizeMachine(row2, candidateKeys, dataKeyFields[index]));
   }
   /**
    * Fail-open: a registry outage degrades machine names back to the daemon
@@ -18336,23 +19518,25 @@ class ApiClient {
     });
   }
   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);
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
     return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
   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);
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
     return {
       sessions: rows.map((row2) => apiSessionToSession(row2, candidateKeys)),
       nextCursor: data.nextCursor ?? null,
@@ -18370,8 +19554,9 @@ class ApiClient {
     return data.sessions ?? [];
   }
   async lookupSessions(candidateKeys, ids, tokenOverride, accountPrivateKey = null) {
+    const boundaryGeneration2 = sessionDekRegistryGeneration();
     const rows = await this.lookupApiSessions(ids, tokenOverride);
-    await preDecryptSessionHeaders(rows, accountPrivateKey);
+    await preDecryptSessionHeaders(rows, accountPrivateKey, boundaryGeneration2);
     return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
   async deleteSession(sessionId, tokenOverride) {
@@ -18495,6 +19680,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));
@@ -18667,15 +19868,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(
@@ -19251,8 +20456,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);
@@ -19408,7 +20613,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") {
@@ -19418,7 +20623,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();
       }
@@ -19927,8 +21132,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.");
@@ -20553,12 +21769,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) {
@@ -20566,7 +21782,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;
 }
@@ -20578,13 +21794,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" },
@@ -20617,10 +21834,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);
@@ -20675,7 +21900,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) {
@@ -20758,6 +21983,141 @@ function resumeHistoryCount(input) {
   if (!input.resuming) return 0;
   return input.since ?? DEFAULT_RESUME_HISTORY;
 }
+const AGENT_SPAWN_BUDGET_MIN = 4;
+const AGENT_SPAWN_BUDGET_MAX = 32;
+const MEMORY_BYTES_PER_AGENT = 2 * 1024 ** 3;
+const AGENTS_PER_CORE = 2;
+function machineSpawnBudget(capacity) {
+  const cores = Number.isFinite(capacity.cpuCount) ? Math.max(0, Math.floor(capacity.cpuCount)) : 0;
+  const memory = Number.isFinite(capacity.totalMemoryBytes) ? Math.max(0, capacity.totalMemoryBytes) : 0;
+  if (cores <= 0 || memory <= 0) return AGENT_SPAWN_BUDGET_MIN;
+  const budget = Math.min(Math.floor(memory / MEMORY_BYTES_PER_AGENT), cores * AGENTS_PER_CORE);
+  return Math.min(Math.max(budget, AGENT_SPAWN_BUDGET_MIN), AGENT_SPAWN_BUDGET_MAX);
+}
+function tierSpawnBudget(depth, machineBudget) {
+  return depth <= 0 ? machineBudget : Math.ceil(machineBudget / 2);
+}
+function resolveMaxSpawn(input) {
+  const tier = tierSpawnBudget(input.depth, input.machineBudget);
+  return input.policy === null ? tier : Math.min(input.policy, tier);
+}
+const SPAWN_BUDGET_WINDOW_MS = 6 * 60 * 60 * 1e3;
+function isCharged(chargedAt, now) {
+  return chargedAt > now - SPAWN_BUDGET_WINDOW_MS;
+}
+function chargeTimes(records) {
+  const byId = /* @__PURE__ */ new Map();
+  const unkeyed = [];
+  for (const record2 of records) {
+    if (record2.spawnId === void 0) {
+      unkeyed.push(record2.ts);
+      continue;
+    }
+    const seen = byId.get(record2.spawnId);
+    if (seen === void 0 || record2.ts < seen) byId.set(record2.spawnId, record2.ts);
+  }
+  return [...byId.values(), ...unkeyed];
+}
+function chargedSpawnCount(records, now) {
+  return chargeTimes(records).filter((chargedAt) => isCharged(chargedAt, now)).length;
+}
+function spawnBudgetResetsAt(records, now, maxSpawn) {
+  if (maxSpawn <= 0) return null;
+  const expiries = chargeTimes(records).filter((chargedAt) => isCharged(chargedAt, now)).map((ts) => ts + SPAWN_BUDGET_WINDOW_MS).sort((a, b) => a - b);
+  if (expiries.length < maxSpawn) return null;
+  return expiries[expiries.length - maxSpawn];
+}
+function spawnLimitDetail(input) {
+  const used = `${input.spawned}/${input.maxSpawn} used`;
+  if (input.resetsAt === null || input.resetsAt <= input.now) return used;
+  const minutes = Math.ceil((input.resetsAt - input.now) / 6e4);
+  return `${used}; the next slot frees in ${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
+const AGENT_ENV_FLAG = "SAYCODE_AGENT_ENV";
+const AGENT_MAX_DEPTH = 2;
+function readOptionalNonNegativeInt(raw) {
+  if (raw === void 0 || !/^\d+$/.test(raw.trim())) return null;
+  const value2 = Number(raw.trim());
+  return Number.isSafeInteger(value2) ? value2 : null;
+}
+function normalizeDirectory(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  const stripped = trimmed.replace(/\/+$/, "");
+  return stripped || "/";
+}
+function hasAgentMarker(env) {
+  return env[AGENT_ENV_FLAG] === "1";
+}
+function isAgentEnv(env) {
+  return hasAgentMarker(env) && normalizeDirectory(env.SAYCODE_AGENT_ROOT ?? "") !== "";
+}
+function readAgentEnv(env, machineBudget) {
+  if (!isAgentEnv(env)) return null;
+  const root = normalizeDirectory(env.SAYCODE_AGENT_ROOT ?? "");
+  const depth = readOptionalNonNegativeInt(env.SAYCODE_AGENT_DEPTH) ?? 0;
+  return {
+    root,
+    scope: normalizeDirectory(env.SAYCODE_AGENT_SCOPE ?? "") || root,
+    depth,
+    maxSpawn: resolveMaxSpawn({
+      policy: readOptionalNonNegativeInt(env.SAYCODE_AGENT_MAX_SPAWN),
+      depth,
+      machineBudget
+    }),
+    agentId: env.SAYCODE_AGENT_ID?.trim() || null,
+    sessionId: env.APLUS_SESSION_ID?.trim() || null
+  };
+}
+function spawnDecision(input) {
+  if (input.depth >= AGENT_MAX_DEPTH) return "spawn_depth_exceeded";
+  if (input.spawned >= input.maxSpawn) return "spawn_limit_exceeded";
+  return "allow";
+}
+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(tierSpawnBudget(parent.depth + 1, parent.maxSpawn)),
+    SAYCODE_AGENT_ID: childAgentId
+  };
+}
+function isInScope(session, scope) {
+  if (!session.machineId || !scope.machineId) return false;
+  if (session.machineId !== scope.machineId) return false;
+  const root = normalizeDirectory(scope.root);
+  const directory = normalizeDirectory(session.directory);
+  if (!root || !directory) return false;
+  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();
+  const homes = CREDENTIAL_SOURCE_ORDER.filter((source) => source !== "saycode").map((source) => `${input.homeDir}/.${source}`);
+  const ordered = [input.credentialHome?.trim(), override, runtimeHome, ...homes];
+  return [...new Set(ordered.filter((home) => Boolean(home)))].map((home) => `${home}/settings.json`.replace(/\/{2,}/g, "/"));
+}
+function readMachineId(input, readFile2) {
+  for (const path of machineSettingsPaths(input)) {
+    const raw = readFile2(path);
+    if (!raw) continue;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.machineId === "string" && parsed.machineId) return parsed.machineId;
+    } catch {
+    }
+  }
+  return null;
+}
+function spawnBudgetKey(env) {
+  return env.agentId ?? env.root;
+}
 const REAL_CLI_SESSION_CONNECTION_DEPS = {
   createLocalId: () => `saycode-cli-${process.pid}-${Math.random().toString(36).slice(2)}`
 };
@@ -21573,14 +22933,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) {
@@ -22527,7 +23885,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);
@@ -22556,9 +23915,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.`);
 }
@@ -22837,6 +24196,9 @@ async function askTemporaryLine(question) {
 }
 async function runChat(context, options, providedTransport) {
   const resuming = !!options.sessionId;
+  if (!resuming && hasAgentMarker(process.env)) {
+    throw new CliError("This session may not start a new conversation with `chat`. Use `saycode agent spawn`, which applies the spawn budget and hands the child its lineage. `chat <session-id>` to attach still works.");
+  }
   let optionPrompter = null;
   let optionInput = null;
   if (!resuming && options.promptForOptions) {
@@ -23741,6 +25103,9 @@ function waitForSessionState(options) {
   });
 }
 const AGENT_FAILURE_EXIT_CODE = 3;
+function isAgentFailure(value2) {
+  return typeof value2 === "object" && value2 !== null && "stdout" in value2;
+}
 function line(value2) {
   return `${JSON.stringify(value2)}
 `;
@@ -23873,82 +25238,6 @@ async function promptTarget(runtime, target, text2, options) {
     stream2.close();
   }
 }
-const AGENT_ENV_FLAG = "SAYCODE_AGENT_ENV";
-const AGENT_MAX_DEPTH = 2;
-const DEFAULT_AGENT_MAX_SPAWN = 4;
-const AGENT_MAX_SPAWN_CEILING = 16;
-function readNonNegativeInt(raw, fallback) {
-  if (raw === void 0) return fallback;
-  if (!/^\d+$/.test(raw.trim())) return fallback;
-  const value2 = Number(raw.trim());
-  return Number.isSafeInteger(value2) ? value2 : fallback;
-}
-function normalizeDirectory(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return "";
-  const stripped = trimmed.replace(/\/+$/, "");
-  return stripped || "/";
-}
-function readAgentEnv(env) {
-  if (env[AGENT_ENV_FLAG] !== "1") return null;
-  const root = normalizeDirectory(env.SAYCODE_AGENT_ROOT ?? "");
-  if (!root) return null;
-  return {
-    root,
-    depth: readNonNegativeInt(env.SAYCODE_AGENT_DEPTH, 0),
-    maxSpawn: Math.min(
-      readNonNegativeInt(env.SAYCODE_AGENT_MAX_SPAWN, DEFAULT_AGENT_MAX_SPAWN),
-      AGENT_MAX_SPAWN_CEILING
-    ),
-    agentId: env.SAYCODE_AGENT_ID?.trim() || null,
-    sessionId: env.APLUS_SESSION_ID?.trim() || null
-  };
-}
-function spawnDecision(input) {
-  if (input.depth >= AGENT_MAX_DEPTH) return "spawn_depth_exceeded";
-  if (input.spawned >= input.maxSpawn) return "spawn_limit_exceeded";
-  return "allow";
-}
-function childAgentEnv(parent, childAgentId) {
-  return {
-    [AGENT_ENV_FLAG]: "1",
-    SAYCODE_AGENT_ROOT: parent.root,
-    SAYCODE_AGENT_DEPTH: String(parent.depth + 1),
-    SAYCODE_AGENT_MAX_SPAWN: String(parent.maxSpawn),
-    SAYCODE_AGENT_ID: childAgentId
-  };
-}
-function isInScope(session, scope) {
-  if (!session.machineId || !scope.machineId) return false;
-  if (session.machineId !== scope.machineId) return false;
-  const root = normalizeDirectory(scope.root);
-  const directory = normalizeDirectory(session.directory);
-  if (!root || !directory) return false;
-  if (directory === root) return true;
-  return directory.startsWith(root === "/" ? "/" : `${root}/`);
-}
-function machineSettingsPaths(input) {
-  const override = input.env.SAYCODE_HAPPY_HOME?.trim();
-  const runtimeHome = input.env.HAPPY_HOME_DIR?.trim();
-  const homes = CREDENTIAL_SOURCE_ORDER.filter((source) => source !== "saycode").map((source) => `${input.homeDir}/.${source}`);
-  const ordered = [input.credentialHome?.trim(), override, runtimeHome, ...homes];
-  return [...new Set(ordered.filter((home) => Boolean(home)))].map((home) => `${home}/settings.json`.replace(/\/{2,}/g, "/"));
-}
-function readMachineId(input, readFile2) {
-  for (const path of machineSettingsPaths(input)) {
-    const raw = readFile2(path);
-    if (!raw) continue;
-    try {
-      const parsed = JSON.parse(raw);
-      if (typeof parsed?.machineId === "string" && parsed.machineId) return parsed.machineId;
-    } catch {
-    }
-  }
-  return null;
-}
-function spawnBudgetKey(env) {
-  return env.agentId ?? env.root;
-}
 function normalizeAbsolutePath(raw) {
   const trimmed = raw.trim();
   if (!trimmed.startsWith("/")) return "";
@@ -24059,6 +25348,71 @@ function buildAgentHandoffPrompt(source, context) {
     ...FIRST_ACTIONS.map((action) => `- ${action}`)
   ].join("\n");
 }
+function checkSpawnBudget(runtime, env) {
+  const key = spawnBudgetKey(env);
+  let usage;
+  try {
+    usage = runtime.countSpawns(key, env.maxSpawn);
+  } catch (error) {
+    return agentFail("spawn_limit_exceeded", `spawn ledger is unreadable, refusing: ${String(error)}`);
+  }
+  const decision = spawnDecision({ depth: env.depth, maxSpawn: env.maxSpawn, spawned: usage.spawned });
+  if (decision === "allow") return { spawned: usage.spawned, key };
+  return agentFail(decision, spawnLimitDetail({
+    spawned: usage.spawned,
+    maxSpawn: env.maxSpawn,
+    resetsAt: usage.resetsAt,
+    now: runtime.now()
+  }));
+}
+function reserveSpawn(runtime, env, key, attempt2, spawnedBefore) {
+  const spawnId = runtime.newAgentId();
+  try {
+    runtime.recordSpawn({
+      ts: runtime.now(),
+      agentKey: key,
+      root: env.scope,
+      depth: env.depth,
+      // Unknown until the daemon answers; `resolveSpawn` appends the id under
+      // the same `spawnId`, and the counter charges the pair once.
+      childSessionId: null,
+      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
+      agent: attempt2.agent,
+      promptPreview: attempt2.promptPreview,
+      outcome: "failed",
+      spawnId
+    });
+  } catch (error) {
+    return agentFail("spawn_limit_exceeded", `spawn ledger is unwritable, refusing before anything is created: ${String(error)}`);
+  }
+  try {
+    if (runtime.countSpawns(key, env.maxSpawn).spawned <= spawnedBefore) {
+      return agentFail("spawn_limit_exceeded", "the spawn reservation did not land in the ledger, refusing before anything is created");
+    }
+  } catch (error) {
+    return agentFail("spawn_limit_exceeded", `spawn ledger became unreadable after reserving, refusing: ${String(error)}`);
+  }
+  return { spawnId };
+}
+function resolveSpawn(runtime, env, key, spawnId, outcome) {
+  try {
+    runtime.recordSpawn({
+      ts: runtime.now(),
+      agentKey: key,
+      root: env.scope,
+      depth: env.depth,
+      childSessionId: outcome.sessionId,
+      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
+      agent: outcome.agent,
+      promptPreview: outcome.promptPreview,
+      outcome: outcome.sessionId ? "spawned" : "failed",
+      spawnId
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function fileSpawnedSessionUnderProject(runtime, sessionId, directory) {
   if (!runtime.registerSpawnedSession) return;
   try {
@@ -24104,15 +25458,9 @@ async function handoffToSibling(runtime, scope, env, handoff, agent, modelOption
   if (env.depth >= AGENT_MAX_DEPTH) {
     return agentFail("spawn_depth_exceeded", `depth ${env.depth} is already at the ceiling of ${AGENT_MAX_DEPTH}`);
   }
-  const key = spawnBudgetKey(env);
-  let spawned;
-  try {
-    spawned = runtime.countSpawns(key);
-  } catch (error) {
-    return agentFail("spawn_limit_exceeded", `spawn ledger is unreadable, refusing: ${String(error)}`);
-  }
-  const decision = spawnDecision({ depth: env.depth, maxSpawn: env.maxSpawn, spawned });
-  if (decision !== "allow") return agentFail(decision, `${spawned}/${env.maxSpawn} used`);
+  const budget = checkSpawnBudget(runtime, env);
+  if (isAgentFailure(budget)) return budget;
+  const { spawned, key } = budget;
   let prompt;
   try {
     prompt = buildHandoffPrompt(await runtime.readMessages(from, HANDOFF_READ_MESSAGES), source, agent);
@@ -24120,6 +25468,9 @@ async function handoffToSibling(runtime, scope, env, handoff, agent, modelOption
     return agentFail("handoff_context_failed", String(error));
   }
   const childId = runtime.newAgentId();
+  const preview = `handoff from ${from}`;
+  const reservation = reserveSpawn(runtime, env, key, { agent, promptPreview: preview }, spawned);
+  if (isAgentFailure(reservation)) return reservation;
   let sessionId = null;
   let spawnError = null;
   try {
@@ -24133,22 +25484,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent, modelOption
   } catch (error) {
     spawnError = error;
   }
-  try {
-    runtime.recordSpawn({
-      ts: runtime.now(),
-      agentKey: key,
-      root: env.root,
-      depth: env.depth,
-      childSessionId: sessionId,
-      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
-      agent,
-      promptPreview: `handoff from ${from}`,
-      outcome: sessionId ? "spawned" : "failed"
-    });
-  } catch (error) {
-    const created = sessionId ? `spawned ${sessionId} but ` : "";
-    return agentFail("spawn_limit_exceeded", `${created}the ledger write failed: ${String(error)}`);
-  }
+  const lineageRecorded = resolveSpawn(runtime, env, key, reservation.spawnId, { agent, promptPreview: preview, sessionId });
   if (!sessionId) {
     return agentFail("spawn_failed", `the machine daemon did not confirm a session: ${String(spawnError)}`);
   }
@@ -24160,6 +25496,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent, modelOption
     depth: env.depth + 1,
     spawned: spawned + 1,
     maxSpawn: env.maxSpawn,
+    lineageRecorded,
     handoff: { mode: "summary", from }
   });
 }
@@ -24241,6 +25578,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 {
@@ -24281,6 +25619,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"
@@ -24295,9 +25770,8 @@ function cliSpawnModelOptions() {
   }));
 }
 const DEFAULT_READ_LIMIT = 20;
-const STATE_WINDOW_MESSAGES = 50;
 function scopeOf(runtime) {
-  const env = readAgentEnv(runtime.env);
+  const env = readAgentEnv(runtime.env, runtime.machineBudget);
   if (!env) return agentFail("not_agent_env", "This command only runs inside a Saycode-spawned session.");
   const machineId = readMachineId(
     { homeDir: runtime.homeDir, env: runtime.env, credentialHome: runtime.credentialHome ?? null },
@@ -24306,10 +25780,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 };
-}
-function isFailure(value2) {
-  return typeof value2 === "object" && value2 !== null && "stdout" in value2;
+  return { scope: { root: env.scope, machineId }, env };
 }
 async function resolveTarget(runtime, scope, sessionId) {
   const sessions = await runtime.listSessions();
@@ -24318,13 +25789,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({
@@ -24340,6 +25811,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.
@@ -24353,22 +25826,18 @@ 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`);
-  }
-  const key = spawnBudgetKey(env);
-  let spawned;
-  try {
-    spawned = runtime.countSpawns(key);
-  } catch (error) {
-    return agentFail("spawn_limit_exceeded", `spawn ledger is unreadable, refusing: ${String(error)}`);
+    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 decision = spawnDecision({ depth: env.depth, maxSpawn: env.maxSpawn, spawned });
-  if (decision !== "allow") return agentFail(decision, `${spawned}/${env.maxSpawn} used`);
+  const budget = checkSpawnBudget(runtime, env);
+  if (isAgentFailure(budget)) return budget;
+  const { spawned, key } = budget;
   const childId = runtime.newAgentId();
+  const reservation = reserveSpawn(runtime, env, key, { agent, promptPreview: text2 }, spawned);
+  if (isAgentFailure(reservation)) return reservation;
   let sessionId = null;
   let spawnError = null;
   try {
@@ -24382,41 +25851,40 @@ async function spawnSibling(runtime, env, text2, agent, contextFiles = [], model
   } catch (error) {
     spawnError = error;
   }
-  try {
-    runtime.recordSpawn({
-      ts: runtime.now(),
-      agentKey: key,
-      root: env.root,
-      depth: env.depth,
-      childSessionId: sessionId,
-      ...env.sessionId ? { parentSessionId: env.sessionId } : {},
-      agent,
-      promptPreview: text2,
-      outcome: sessionId ? "spawned" : "failed"
-    });
-  } catch (error) {
-    const created = sessionId ? `spawned ${sessionId} but ` : "";
-    return agentFail("spawn_limit_exceeded", `${created}the ledger write failed: ${String(error)}`);
-  }
+  const lineageRecorded = resolveSpawn(runtime, env, key, reservation.spawnId, { agent, promptPreview: text2, sessionId });
   if (!sessionId) {
     return agentFail("spawn_failed", `the machine daemon did not confirm a session: ${String(spawnError)}`);
   }
   await fileSpawnedSessionUnderProject(runtime, sessionId, env.root);
-  return agentOk({ sessionId, agent, directory: env.root, depth: env.depth + 1, spawned: spawned + 1, maxSpawn: env.maxSpawn });
+  return agentOk({
+    sessionId,
+    agent,
+    directory: env.root,
+    depth: env.depth + 1,
+    spawned: spawned + 1,
+    maxSpawn: env.maxSpawn,
+    // False means the child runs but this session's ownership link went
+    // unwritten, so a spawned parent cannot steer or stop it.
+    lineageRecorded
+  });
 }
 async function runAgentCommand(runtime, args) {
   const context = scopeOf(runtime);
-  if (isFailure(context)) return context;
+  if (isAgentFailure(context)) return context;
   const { scope, env } = context;
   if (args.verb === "whoami") {
     let spawned = null;
+    let resetsAt = null;
     try {
-      spawned = runtime.countSpawns(spawnBudgetKey(env));
+      const usage = runtime.countSpawns(spawnBudgetKey(env), env.maxSpawn);
+      spawned = usage.spawned;
+      resetsAt = usage.resetsAt;
     } catch {
       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.
@@ -24425,29 +25893,35 @@ async function runAgentCommand(runtime, args) {
       maxSpawn: env.maxSpawn,
       spawned,
       spawnsRemaining: spawned === null ? null : Math.max(0, env.maxSpawn - spawned),
+      // The budget is a rolling window, so "full" is a temporary state with a
+      // known end — an agent that is told only "0 left" would give up for good.
+      budgetResetsAt: resetsAt,
       canSpawn: env.depth < AGENT_MAX_DEPTH && spawned !== null && spawned < env.maxSpawn,
       spawnModelOptions: cliSpawnModelOptions()
     });
   }
   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;
     const modelOptions = args.model !== void 0 || args.effort !== void 0 ? await validateSpawnModelOptions(agent, args.model, args.effort) : {};
-    if (isFailure(modelOptions)) return modelOptions;
+    if (isAgentFailure(modelOptions)) return modelOptions;
     if (args.handoff) {
       return handoffToSibling(runtime, scope, env, args.handoff, agent, modelOptions);
     }
     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;
+  if (isAgentFailure(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":
@@ -24479,7 +25953,7 @@ async function validateSpawnModelOptions(agent, model, effort) {
 function parseSpawnRecord(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
   const record2 = value2;
-  return typeof record2.ts === "number" && Number.isFinite(record2.ts) && typeof record2.agentKey === "string" && record2.agentKey.length > 0 && typeof record2.root === "string" && record2.root.length > 0 && typeof record2.depth === "number" && Number.isInteger(record2.depth) && record2.depth >= 0 && (record2.childSessionId === null || typeof record2.childSessionId === "string" && record2.childSessionId.length > 0) && (record2.parentSessionId === void 0 || typeof record2.parentSessionId === "string" && record2.parentSessionId.length > 0) && typeof record2.agent === "string" && record2.agent.length > 0 && typeof record2.promptPreview === "string" && (record2.outcome === "spawned" || record2.outcome === "failed") ? record2 : null;
+  return typeof record2.ts === "number" && Number.isFinite(record2.ts) && typeof record2.agentKey === "string" && record2.agentKey.length > 0 && typeof record2.root === "string" && record2.root.length > 0 && typeof record2.depth === "number" && Number.isInteger(record2.depth) && record2.depth >= 0 && (record2.childSessionId === null || typeof record2.childSessionId === "string" && record2.childSessionId.length > 0) && (record2.parentSessionId === void 0 || typeof record2.parentSessionId === "string" && record2.parentSessionId.length > 0) && (record2.spawnId === void 0 || typeof record2.spawnId === "string" && record2.spawnId.length > 0) && typeof record2.agent === "string" && record2.agent.length > 0 && typeof record2.promptPreview === "string" && (record2.outcome === "spawned" || record2.outcome === "failed") ? record2 : null;
 }
 const LEDGER_FILE_MODE = 384;
 const PREVIEW_MAX_LENGTH = 200;
@@ -24520,7 +25994,8 @@ function recordIdentity(record2) {
     record2.parentSessionId ?? null,
     record2.agent,
     record2.promptPreview,
-    record2.outcome
+    record2.outcome,
+    record2.spawnId ?? null
   ]);
 }
 function readSpawnRecords(homeDir, rootDir) {
@@ -24536,14 +26011,35 @@ function readSpawnRecords(homeDir, rootDir) {
     return true;
   });
 }
-function countSpawnsFor(homeDir, rootDir, agentKey) {
-  return readSpawnRecords(homeDir, rootDir).filter((record2) => record2.agentKey === agentKey).length;
+function spawnBudgetUsage(homeDir, rootDir, agentKey, now, maxSpawn) {
+  const mine = readSpawnRecords(homeDir, rootDir).filter((record2) => record2.agentKey === agentKey);
+  return {
+    spawned: chargedSpawnCount(mine, now),
+    resetsAt: spawnBudgetResetsAt(mine, now, maxSpawn)
+  };
+}
+function endsWithNewline(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    const size = fstatSync(fd).size;
+    if (size === 0) return true;
+    const tail = Buffer.alloc(1);
+    readSync(fd, tail, 0, 1, size - 1);
+    return tail[0] === 10;
+  } catch (error) {
+    if (error.code === "ENOENT") return true;
+    throw error;
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
 }
 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)}
+  const separator = endsWithNewline(path) ? "" : "\n";
+  appendFileSync(path, `${separator}${JSON.stringify(entry)}
 `, { mode: LEDGER_FILE_MODE });
 }
 function normalize(raw) {
@@ -24688,7 +26184,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;
 }
@@ -24721,7 +26217,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) {
@@ -24745,17 +26241,21 @@ async function openStream(context, transport, sessionId) {
 }
 function createAgentRuntime(context, transport, env = process.env) {
   const keys = [decodeBase64(context.syncCredential.secret)];
-  const homeDir = context.homeDir, lineageRoot = readAgentEnv(env)?.root ?? context.homeDir;
+  const machineBudget = machineSpawnBudget({ cpuCount: cpus().length, totalMemoryBytes: totalmem() });
+  const homeDir = context.homeDir, lineageRoot = readAgentEnv(env, machineBudget)?.scope ?? context.homeDir;
   const credentialHome = context.credential.source === "saycode" ? null : dirname(context.credential.path);
+  const now = () => Date.now();
   return {
     env,
     homeDir,
     credentialHome,
-    now: () => Date.now(),
+    machineBudget,
+    now,
     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,
@@ -24786,7 +26286,7 @@ function createAgentRuntime(context, transport, env = process.env) {
       return { sessionId: result.sessionId };
     },
     newAgentId: () => randomBytes(8).toString("hex"),
-    countSpawns: (agentKey) => countSpawnsFor(homeDir, lineageRoot, agentKey),
+    countSpawns: (agentKey, maxSpawn) => spawnBudgetUsage(homeDir, lineageRoot, agentKey, now(), maxSpawn),
     recordSpawn: (record2) => appendSpawnRecord(lineageRoot, record2),
     readLineage: () => readSpawnRecords(homeDir, lineageRoot),
     steerSession: (sessionId, text2) => steerAgentSession(transport, sessionId, text2),