@buzzni/saycode-cli 0.9.2 → 0.9.3

package/index.mjs

@@ -2,13 +2,13 @@
 import { createInterface } from "node:readline";
 import { homedir, tmpdir, platform, totalmem, freemem, cpus, userInfo, hostname as hostname$1 } from "node:os";
 import fs, { readFileSync, mkdirSync, writeFileSync, rmSync, chmodSync, constants as constants$3, appendFileSync, existsSync, realpathSync, createWriteStream, openSync, fstatSync, readSync, closeSync, accessSync, statSync } from "node:fs";
-import path$1, { dirname, join, basename, extname, delimiter, win32, resolve, sep, relative, isAbsolute } from "node:path";
+import path$1, { dirname, join, basename, extname, delimiter, win32, resolve, sep, relative, isAbsolute, posix } from "node:path";
 import { createHash, randomUUID, randomBytes, generateKeyPairSync, sign, createHmac, timingSafeEqual, createPublicKey, verify } from "node:crypto";
 import require$$0$5, { Buffer as Buffer$1 } from "buffer";
 import { readFile, stat, mkdtemp, access, rm, mkdir, appendFile, writeFile, chmod, lstat, open, readdir, rename, statfs, realpath } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
 import net, { isIP, connect as connect$1, createServer as createServer$1 } from "node:net";
-import { createServer, request } from "node:http";
+import { createServer, request as request$1 } from "node:http";
 import { promisify } from "node:util";
 import { StringDecoder } from "node:string_decoder";
 import require$$0$6 from "stream";
@@ -49,7 +49,7 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version$3 = "0.9.2";
+const version$3 = "0.9.3";
 const manifest = {
   version: version$3
 };
@@ -442,6 +442,52 @@ const conversationTabsKo = {
   "workspaceHost.closeConversationHint": "탭만 닫고 대화 기록은 남아요.",
   "workspaceHost.newConversation": "새 대화 열기"
 };
+const personalAiKo = {
+  "aiConnection.sectionTitle": "연결된 AI 확인하기",
+  "aiConnection.ai": "AI",
+  "aiConnection.pc": "PC",
+  "aiConnection.selectPc": "PC 선택",
+  "aiConnection.pcUnknown": "확인할 수 없음",
+  "aiConnection.selectAi": "AI 선택",
+  "aiConnection.chooseAiHint": "AI를 선택하면 이 PC의 연결 상태를 확인할 수 있어요.",
+  "personalAi.settingsTitle": "내 AI 계정",
+  "personalAi.settingsDescription": "사용 중인 ChatGPT 또는 Claude 계정을 연결하세요.",
+  "personalAi.title": "개인 AI 계정 연결",
+  "personalAi.imageAlt": "웹 계정과 데스크탑 대화 화면이 연결되는 모습",
+  "personalAi.intro": "ChatGPT 또는 Claude 계정을 연결하면\nSayCode에서 AI와 대화할 수 있어요.",
+  "personalAi.note": "사용 중인 AI 계정으로 로그인해 주세요.",
+  "personalAi.later": "나중에 하기",
+  "personalAi.connect": "내 AI 계정 연결",
+  "personalAi.choose": "연결할 AI를 선택해 주세요",
+  "personalAi.chooseDescription": "선택한 서비스의 웹사이트에서 로그인합니다.",
+  "personalAi.withProvider": "{provider} 계정으로 연결",
+  "personalAi.back": "뒤로",
+  "personalAi.providerTitle": "{provider} 계정 연결",
+  "personalAi.waiting": "브라우저에서 로그인을 완료해 주세요.",
+  "personalAi.approval": "로그인과 연결 승인을 마치면\n자동으로 연결 상태를 확인합니다.",
+  "personalAi.cancel": "취소",
+  "personalAi.reopen": "브라우저 다시 열기",
+  "personalAi.expired": "아직 연결을 확인하지 못했어요.",
+  "personalAi.retryDescription": "다시 연결해 브라우저에서\n로그인을 완료해 주세요.",
+  "personalAi.retry": "다시 연결",
+  "personalAi.connected": "{provider} 계정이 연결됐어요.",
+  "personalAi.ready": "이 컴퓨터에서 사용할 준비가 됐습니다.",
+  "personalAi.done": "완료",
+  "personalAi.localOnly": "개인 AI 계정은 이 컴퓨터에서 연결할 수 있어요. 작업PC를 이 컴퓨터로 선택한 뒤 다시 연결해 주세요.",
+  "personalAi.unavailable": "이 컴퓨터의 연결과 AI 도구 설치를 확인한 뒤 다시 열어 주세요.",
+  "aiConnection.loginLinkFailed": "로그인 링크를 열지 못했어요. 터미널 보기에서 링크를 직접 눌러 주세요.",
+  "aiConnection.openLoginLink": "로그인 링크 열기",
+  "aiConnection.loginPreparing": "로그인 준비 중이에요…",
+  "aiConnection.codeLabel": "브라우저에서 로그인한 뒤 표시되는 인증 코드를 붙여 넣어 주세요.",
+  "aiConnection.codeSend": "인증 코드 보내기",
+  "aiConnection.loginFailed": "로그인하지 못했어요. 인증 코드를 다시 확인한 뒤 다시 시도해 주세요.",
+  "aiConnection.loginRetry": "다시 시도",
+  "aiConnection.loginTerminalFailed": "로그인 터미널을 열지 못했어요. 아래 터미널에서 다시 열어 주세요.",
+  "aiConnection.loginTerminalClosed": "로그인 터미널이 닫혔어요. 아래 터미널에서 다시 열어 주세요.",
+  "aiConnection.loginLinkSlow": "로그인 링크가 아직 나오지 않았어요. 아래 터미널에서 진행 상황을 확인해 주세요.",
+  "aiConnection.codeSent": "인증 코드를 보냈어요. 로그인이 끝나면 로그인 완료를 눌러 주세요.",
+  "aiConnection.showTerminal": "터미널 보기"
+};
 const questionComposerKo = {
   "askUser.skip": "건너뛰기",
   "askUser.skipAnswer": "사용자가 이 질문의 답변을 건너뛰었습니다.",
@@ -481,8 +527,8 @@ const projectSettingsWebKo = {
   "projectSettings.webOnly": "웹 전용",
   "projectSettings.advancedWeb": "고급 실행 설정",
   "projectSettings.advancedHint": "멀티 AI도구(오케스트레이터)와 Sandbox 실행 격리는 웹 실행 환경의 설정입니다. 앱의 로컬 실행 권한·격리 설정과 별도로 관리합니다.",
-  "projectSettings.cleanup": "빌드 산출물/캐시 정리",
-  "projectSettings.cleanupHint": "클라우드 백업의 빌드 산출물과 캐시만 정리합니다. 작업PC의 파일은 삭제하지 않습니다.",
+  "projectSettings.cleanup": "빌드 작업물/캐시 정리",
+  "projectSettings.cleanupHint": "클라우드 백업의 빌드 작업물과 캐시만 정리합니다. 작업PC의 파일은 삭제하지 않습니다.",
   "projectSettings.cleanupPreview": "정리 대상 확인",
   "projectSettings.cleanupConfirm": "백업 파일 {count}개를 정리할까요?",
   "projectSettings.cleanupRun": "정리 실행",
@@ -663,6 +709,12 @@ const projectSettingsKo = {
   "projectSettings.diagnostics": "개발 정보"
 };
 const aiRecoveryKo = {
+  "aiRecovery.capacityTitle": "모델 혼잡 재시도",
+  "aiRecovery.capacitySummary": "지금은 요청이 많아요. 잠시 후 다시 시도해 주세요.",
+  "aiRecovery.capacityCountdown": "{seconds}초 후 다시 시도 ({attempt}/3)",
+  "aiRecovery.capacityCancel": "취소",
+  "aiRecovery.capacityExhausted": "자동 재시도를 마쳤어요. 잠시 후 다시 시도하거나 입력창에서 모델을 변경해주세요.",
+  "aiRecovery.capacityModelHint": "입력창에서 다른 모델로 변경할 수 있어요.",
   "aiRecovery.modelUnsupported": "현재 AI에서 사용할 수 없는 모델이에요. 입력창에서 모델을 변경한 뒤 다시 시도해주세요.",
   "aiRecovery.accessSummary": "이 계정으로 Claude를 사용할 수 없어요.",
   "aiRecovery.connectAccount": "다시 연결",
@@ -780,6 +832,8 @@ const managedClaudeKo = {
   "managedClaude.loading": "AI 연결 중…"
 };
 const workKo = {
+  "work.mediaChanged": "원본 파일이 변경됐습니다. 다시 열어주세요.",
+  "work.mediaUnsupported": "이 컴퓨터에서는 미디어 스트리밍을 지원하지 않습니다. 원본을 저장해 열어주세요.",
   "work.homeTitle": "어떤 작업을 도와드릴까요?",
   "work.new": "새 chat",
   "work.archived": "보관된 chat",
@@ -835,7 +889,8 @@ const workKo = {
   "work.sourceNotice.denied": "파일에 접근할 권한이 없어요. 접근 권한을 확인해 주세요.",
   "work.sourceNotice.unavailable": "파일을 확인하지 못했어요. 다시 시도해 주세요.",
   "work.saveCheck": "재저장 확인",
-  "work.checkingFile": "확인 중…"
+  "work.checkingFile": "확인 중…",
+  "work.mediaViewerNeeded": "미디어 미리보기 확장을 설치하고 파일 읽기 권한을 허용해주세요."
 };
 const FILE_ACCESS_TRANSLATIONS_KO = {
   "fileAccess.retry": "다시 시도",
@@ -911,6 +966,8 @@ const organizationInstallRecoveryKo = {
   "organizationStart.toolDiagnostic.reason.TOOL_EXECUTION_FAILED": "파일을 실행하거나 버전을 확인하지 못했어요.",
   "organizationStart.toolDiagnostic.reason.TOOL_INSTALL_FAILED": "도구 준비를 마치지 못했어요. 정확한 원인은 아직 확인되지 않았어요.",
   "organizationStart.toolDiagnostic.reason.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "설치된 cswap이 필요한 인증 기능을 지원하지 않아요.",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_AUTH_REQUIRED": "회사 프록시가 로그인 인증을 요구해 연결하지 못했어요.",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_BLOCKED": "회사 프록시가 다운로드나 패키지 서버 연결을 허용하지 않았어요.",
   "organizationStart.toolDiagnostic.action.TOOL_NOT_FOUND": "다시 시도하거나 설치 안내에 따라 준비한 뒤 다시 확인해 주세요.",
   "organizationStart.toolDiagnostic.action.TOOL_PREREQUISITE_REQUIRED": "표시된 선행 도구를 먼저 준비한 뒤 다시 시도해 주세요.",
   "organizationStart.toolDiagnostic.action.TOOL_NETWORK_FAILED": "인터넷·회사 네트워크·프록시를 확인하고 다시 시도해 주세요.",
@@ -923,12 +980,55 @@ const organizationInstallRecoveryKo = {
   "organizationStart.toolDiagnostic.action.TOOL_TIMEOUT": "네트워크를 확인한 뒤 다시 시도해 주세요. 반복되면 진단을 전달해 주세요.",
   "organizationStart.toolDiagnostic.action.TOOL_EXECUTION_FAILED": "설치가 온전한지와 회사 정책이 실행을 허용하는지 확인해 주세요.",
   "organizationStart.toolDiagnostic.action.TOOL_INSTALL_FAILED": "다시 시도해 주세요. 반복되면 이 진단을 전달해 주세요.",
-  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "다시 시도로 Saycode가 사용하는 인증 도구를 설치해 주세요."
+  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "다시 시도로 Saycode가 사용하는 인증 도구를 설치해 주세요.",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_AUTH_REQUIRED": "이 진단을 회사 IT 담당자에게 전달해 다운로드 서버를 프록시 인증 예외로 허용해 달라고 요청해 주세요.",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_BLOCKED": "이 진단을 회사 IT 담당자에게 전달해 다운로드 서버 접속 허용을 요청해 주세요."
+};
+const organizationAccountKeyKo = {
+  "organizationStart.accountKey.title": "대화 암호화 켜기",
+  "organizationStart.accountKey.body": "조직 AI를 이 컴퓨터에서 쓰려면 대화 암호화를 먼저 켜야 해요. 현재 비밀번호로 이 계정의 암호화 키를 만들어요.",
+  "organizationStart.accountKey.row": "대화 암호화",
+  "organizationStart.accountKey.passwordLabel": "현재 비밀번호",
+  "organizationStart.accountKey.checking": "비밀번호 확인 중…",
+  "organizationStart.accountKey.recoveryTitle": "복구 키를 보관해주세요",
+  "organizationStart.accountKey.recoveryNotice": "비밀번호를 잊었을 때 대화를 여는 방법이에요. 비밀번호와 복구 키를 모두 잃으면 암호화된 대화를 열 수 없어요. 이 화면을 닫으면 복구 키를 다시 볼 수 없어요.",
+  "organizationStart.accountKey.copy": "복사",
+  "organizationStart.accountKey.copied": "복구 키를 복사했어요.",
+  "organizationStart.accountKey.save": "파일로 저장",
+  "organizationStart.accountKey.saved": "복구 키를 저장했어요.",
+  "organizationStart.accountKey.confirmLabel": "복구 키 다시 입력",
+  "organizationStart.accountKey.confirmMismatch": "입력한 복구 키가 위의 복구 키와 달라요.",
+  "organizationStart.accountKey.enable": "대화 암호화 켜기",
+  "organizationStart.accountKey.saving": "켜는 중…",
+  "organizationStart.accountKey.renewBody": "확인 시간이 지나 비밀번호를 한 번 더 확인해야 해요. 보관한 복구 키는 그대로예요.",
+  "organizationStart.accountKey.renew": "다시 확인",
+  "organizationStart.accountKey.error.wrong-password": "현재 비밀번호가 일치하지 않아요.",
+  "organizationStart.accountKey.error.rate-limited": "시도가 너무 많아요. 잠시 뒤 다시 시도해주세요.",
+  "organizationStart.accountKey.error.already-enabled": "이 계정은 이미 대화 암호화가 켜져 있어요. 로그아웃한 뒤 다시 로그인해주세요.",
+  "organizationStart.accountKey.error.signed-out": "로그인이 만료됐어요. 로그아웃한 뒤 다시 로그인해주세요.",
+  "organizationStart.accountKey.error.expired": "확인 시간이 지났어요. 비밀번호를 다시 입력해주세요.",
+  "organizationStart.accountKey.error.failed": "대화 암호화를 켜지 못했어요. 잠시 뒤 다시 시도해주세요.",
+  "organizationStart.accountKey.error.recovery-mismatch": "입력한 복구 키가 위의 복구 키와 달라요.",
+  "organizationStart.accountKey.lockedTitle": "다시 로그인해주세요",
+  "organizationStart.accountKey.lockedBody": "이 계정은 대화 암호화가 켜져 있지만 이 컴퓨터에서는 아직 열리지 않았어요. 로그아웃한 뒤 다시 로그인하면 이어서 진행해요.",
+  "organizationStart.accountKey.signInAgain": "다시 로그인",
+  "organizationStart.diagnostic.reason.accountKey": "이 계정의 대화 암호화가 아직 켜져 있지 않아요.",
+  "organizationStart.diagnostic.action.accountKey": "시작준비에서 대화 암호화를 켜주세요.",
+  "organizationStart.diagnostic.reason.accountKeyLocked": "이 컴퓨터에서 계정 암호화 키가 아직 열리지 않았어요.",
+  "organizationStart.diagnostic.action.accountKeyLocked": "로그아웃한 뒤 다시 로그인해주세요."
+};
+const organizationPcRegistrationKo = {
+  "organizationStart.diagnostic.reason.pcNotAssigned": "이 PC가 지금 고른 조직에서 이 계정의 전용 PC로 배정돼 있지 않아요.",
+  "organizationStart.diagnostic.action.pcNotAssigned": "고른 조직이 맞는지 확인하고, 맞으면 조직 관리자에게 이 PC를 이 계정의 전용 PC로 배정해 달라고 요청해주세요.",
+  "organizationStart.diagnostic.reason.pcReregister": "이 PC의 예전 등록 정보를 이어서 쓸 수 없어요.",
+  "organizationStart.diagnostic.action.pcReregister": "조직 관리자에게 이 PC를 새로 등록해 달라고 요청해주세요."
 };
 const organizationStartKo = {
   "organizationStart.toolsDetails": "도구 준비 상세",
   "organizationStart.toolsProgress": "도구 준비 상태",
   ...organizationInstallRecoveryKo,
+  ...organizationAccountKeyKo,
+  ...organizationPcRegistrationKo,
   "organizationStart.connectingTitle": "조직으로 연결 중",
   "organizationStart.connectingBody": "{name}에서 작업할 준비를 하고 있어요.",
   "organizationStart.welcome": "조직에서 바로 시작해요",
@@ -956,6 +1056,9 @@ const organizationStartKo = {
   "organizationStart.aiGroupConflict": "조직의 AI 계정 설정을 확인해야 해요. 조직 관리자에게 알려주세요.",
   "organizationStart.aiChecking": "AI 연결 중…",
   "organizationStart.connectLater": "나중에 하기",
+  "organizationStart.skip": "건너뛰기",
+  "organizationStart.noAi.body": "{name}에 등록된 조직 AI 계정이 없어요. 건너뛰고 내 AI 계정으로 시작할 수 있어요.",
+  "organizationStart.noAi.status": "조직 AI 계정 없음",
   "organizationStart.existingConnection": "이 PC를 {name}에 연결하려면 다음을 눌러주세요.",
   "organizationStart.failed": "시작준비",
   "organizationStart.recovery.title": "앱 복구가 필요해요",
@@ -1062,7 +1165,32 @@ const organizationStartKo = {
   "organizationStart.diagnostic.reason.registrationChanged": "이 PC의 조직 등록이 바뀌었거나 삭제되어 이 계정으로 연결할 수 없어요.",
   "organizationStart.diagnostic.action.registrationChanged": "조직 관리자에게 조직 관리 → PC에서 이 PC의 등록을 확인해 달라고 요청한 뒤 다시 시도해주세요.",
   "organizationStart.diagnostic.reason.publicVerify": "공용 인증을 적용했지만 AI 인증 사용을 확인하지 못했어요.",
-  "organizationStart.diagnostic.action.publicVerify": "조직 관리자에게 최신 공용 인증 복구를 요청한 뒤 다시 연결해주세요."
+  "organizationStart.diagnostic.action.publicVerify": "조직 관리자에게 최신 공용 인증 복구를 요청한 뒤 다시 연결해주세요.",
+  "companyInvite.title": "받은 조직 초대",
+  "companyInvite.checkFailed": "조직 초대 확인 필요",
+  "companyInvite.body": "새 조직 초대가 있어요. 참여할 조직을 선택해주세요.",
+  "companyInvite.onboardingBody": "받은 조직 초대를 먼저 확인해주세요.",
+  "companyInvite.member": "멤버",
+  "companyInvite.admin": "관리자",
+  "companyInvite.accept": "수락",
+  "companyInvite.decline": "거절",
+  "companyInvite.later": "나중에",
+  "companyInvite.dismiss": "조직 초대 닫기",
+  "companyInvite.accepted": "조직에 참여했어요.",
+  "companyInvite.declined": "조직 초대를 거절했어요.",
+  "companyInvite.failed": "초대를 처리하지 못했어요. 잠시 후 다시 시도해주세요.",
+  "companyInvite.reauth": "관리자 권한을 적용하려면 다시 로그인해야 해요.",
+  "companyInvite.retry": "다시 확인",
+  "companyInvite.securityRequired": "관리자 초대는 보안 인증이 필요해요. 웹에서 보안 설정과 인증을 확인한 뒤 다시 시도해주세요.",
+  "companyInvite.expiry": "{date}까지",
+  "companyInvite.declineConfirm": "거절 확인",
+  "companyInvite.declineBody": "{name}의 초대를 거절할까요? 참여하려면 새 초대가 필요해요.",
+  "companyInvite.cancel": "취소",
+  "companyInvite.loading": "초대 확인 중…",
+  "companyInvite.acceptLabel": "{name} 초대 수락",
+  "companyInvite.declineLabel": "{name} 초대 거절",
+  "companyInvite.declineConfirmLabel": "{name} 초대 거절 확인",
+  "companyInvite.refreshFailed": "초대 목록을 확인하지 못했어요. 다시 확인해주세요."
 };
 const usageEntryKo = {
   ...selfHostConnectKo,
@@ -1202,7 +1330,7 @@ const usageEntryKo = {
   "localTools.prerequisitesBody": "uv·Git·Node.js(npm 포함)의 설치 상태를 확인합니다. 설치 후 다시 확인하세요.",
   "localTools.prerequisitesTitle": "기본 개발 도구",
   "onboarding.preparationComplete": "필수 설정 완료",
-  "onboarding.additionalStepsBody": "Saycode 지시, AI 계정, 알림, 컴퓨터·브라우저 제어는 선택 단계입니다. 나중에 설정해도 바로 시작할 수 있습니다.",
+  "onboarding.additionalStepsBody": "Saycode 지시, AI 계정, 알림은 선택 단계입니다. 나중에 설정해도 바로 시작할 수 있습니다.",
   "onboarding.additionalStep": "추가 단계",
   "onboarding.requiredSettings": "필수 설정",
   "onboarding.additionalSettings": "추가 설정 — 선택",
@@ -1285,6 +1413,11 @@ const projectRelocationKO = {
   "sessionCreation.workspaceNotSet": "이 머신의 워크스페이스 경로가 설정되지 않았습니다. 머신 워크스페이스를 먼저 설정해주세요."
 };
 const chatSchedulesKo = {
+  "chatSchedules.chatTitle": "이 대화의 예약",
+  "chatSchedules.sharedHint": "예약 메뉴에서도 같은 예약을 확인하고 관리할 수 있어요.",
+  "chatSchedules.allSchedules": "전체 예약 보기",
+  "chatSchedules.advanced": "고급 자동화 설정",
+  "chatSchedules.advancedHint": "AI 선택·조건 실행·스크립트 자동화를 설정해요. 위 예약과 같은 AI 예약을 관리하며, 스크립트 자동화는 별도 실행 유형이에요.",
   "chatSchedules.allReplies": "회차별 답변",
   "chatSchedules.allRepliesHint": "최근 실행 기록의 답변을 시간순으로 보여줘요. 최근 20회까지 확인할 수 있어요.",
   "chatSchedules.replyLoadError": "답변을 불러오지 못했어요.",
@@ -1730,7 +1863,12 @@ const machineUsageKo = {
   "machineUsage.autoSwitched": "{provider} 계정을 자동 전환했습니다: {from} → {to}",
   "machineUsage.pinned": "고정됨",
   "machineUsage.codexAccounts": "Codex 계정",
-  "machineUsage.usageStale": "사용량 갱신 중"
+  "machineUsage.usageStale": "사용량 갱신 중",
+  "machineUsage.autoRotation": "자동순환계정",
+  "machineUsage.autoRotationOn": "한도에 가까워지면 다른 계정으로 자동 전환해요.",
+  "machineUsage.autoRotationOff": "선택한 계정을 계속 사용해요.",
+  "machineUsage.autoRotationPaused": "계정을 직접 선택해 자동 순환을 껐어요.",
+  "machineUsage.autoRotationFailed": "자동 순환을 바꾸지 못했어요. 다시 시도해주세요."
 };
 const machineResourceMetricsKo = {
   "machineResourceMetrics.title": "작업PC 리소스",
@@ -2145,7 +2283,7 @@ const outboundWebhookKo = {
 };
 const messengerChannelsKo = {
   "settings.messengerChannels.title": "메신저 채널",
-  "settings.messengerChannels.privacyNotice": "연결된 메신저에는 요청의 상태와 최종 답변만 전송됩니다 — raw tool output·과거 기록·첨부는 전송되지 않습니다. 메신저 구간은 Saycode의 종단간 암호화 범위 밖입니다.",
+  "settings.messengerChannels.privacyNotice": "연결된 메신저에는 요청의 상태와 최종 답변이 전송되고, Slack에서는 그 답변에서 에이전트가 지정한 프로젝트 폴더 안 파일도 함께 전송됩니다. raw tool output·과거 기록은 전송되지 않습니다. 메신저 구간은 Saycode의 종단간 암호화 범위 밖입니다.",
   "settings.messengerChannels.alwaysOnTitle": "앱 종료 후에도 연결 유지",
   "settings.messengerChannels.alwaysOnHelp": "Saycode 앱을 종료해도 메시지를 받고 작업을 이어갑니다. 컴퓨터가 켜져 있고 인터넷에 연결되어 있어야 합니다.",
   "settings.messengerChannels.alwaysOnBlocked": "사용할 수 없습니다: 이 기기에서 봇 자격 증명을 안전하게 저장할 수 없어, Desktop 종료 후에는 아무것도 수신할 수 없습니다.",
@@ -2303,7 +2441,7 @@ const messengerQuickSetupKo = {
   "settings.messengerChannels.quickSlack.openInSlack": "Slack에서 열기",
   "settings.messengerChannels.quickSlack.waiting": "Slack에서 메시지를 보내면 여기에 연결 요청이 떠요. 허용하면 끝이에요.",
   "settings.messengerChannels.quickSlack.pairedWith": "{name}님의 Slack과 연결됨",
-  "settings.messengerChannels.quickSlack.connectedHelp": "코드를 보낸 DM에서 봇에게 그냥 말을 걸면 돼요. 명령어는 봇을 멘션한 뒤 /help 로 볼 수 있어요.",
+  "settings.messengerChannels.quickSlack.connectedHelp": "코드를 보낸 DM에서 봇에게 그냥 말을 걸면 돼요. 봇을 초대한 채널에서 멘션하면 그 글의 스레드로 답해요(답변은 채널 멤버에게 보여요). 명령어는 봇을 멘션한 뒤 /help 로 볼 수 있어요.",
   "settings.messengerChannels.quickDiscord.title": "Discord 연결",
   "settings.messengerChannels.quickDiscord.subtitle": "Discord에서 Saycode에게 바로 일을 맡길 수 있어요. 두 단계면 끝나요.",
   "settings.messengerChannels.quickDiscord.installTitle": "Discord 기능이 아직 꺼져 있어요",
@@ -2608,6 +2746,9 @@ const extensionPanelKo = {
 const extensionInstallKo = {
   "extensions.installOfficial": "확장 설치",
   "extensions.installNamedOfficial": "{name} 설치",
+  "extensions.officialUpdate": "{version}으로 공식 업데이트",
+  "extensions.updateSaved": "새 버전은 설치됐지만 마무리 확인을 하지 못했어요. 확장 상태를 다시 확인하세요.",
+  "extensions.projectToolHint": "프로젝트 대화의 오른쪽 작업 패널 더보기(⋮) 메뉴에서 엽니다: {tools}",
   "extensions.officialName.artifactPublisher": "공개 링크 확장",
   "extensions.officialName.pluginManager": "플러그인 관리자 확장",
   "extensions.officialName.projectTemplates": "프로젝트 템플릿 확장",
@@ -2636,25 +2777,26 @@ const extensionInstallKo = {
   "artifactPublication.error.network": "서버에 연결할 수 없습니다. 네트워크 상태를 확인해 주세요.",
   "artifactPublication.error.unauthenticated": "로그인 세션이 만료되었습니다. 다시 로그인한 뒤 시도해 주세요.",
   "artifactPublication.error.notFound": "파일을 찾을 수 없습니다. 파일이 저장되었는지 확인해 주세요.",
+  "artifactPublication.error.notFoundInFolder": "작업 폴더 {folder}에서 {file} 파일을 찾을 수 없습니다. 다른 작업 폴더(worktree)에서 만든 파일이면 이 폴더로 옮긴 뒤 다시 시도해 주세요.",
   "artifactPublication.error.tooLarge": "파일이 너무 큽니다. 공개할 HTML 파일은 10MB 이하여야 합니다.",
   "artifactPublication.error.rateLimited": "공개 링크 요청이 너무 많습니다. 잠시 후 다시 시도해 주세요.",
   "artifactPublication.error.rejected": "서버가 이 파일의 공개 요청을 거부했습니다.",
   "artifactPublication.error.serverError": "서버 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.",
   "artifactPublication.error.extensionUnavailable": "확장이 비활성화되었거나 공개 권한이 없습니다. 설정에서 Artifact Publisher를 확인해 주세요.",
-  "artifactPublication.error.invalidResponse": "서버 응답을 확인할 수 없어 중단했습니다."
+  "artifactPublication.error.invalidResponse": "서버 응답을 확인할 수 없어 중단했습니다.",
+  "extensions.permission.filePreviewsRead": "앱에서 연 파일의 미리보기 내용을 읽을 수 있습니다. 원본 경로와 인증 정보는 Saycode Core가 관리합니다."
 };
 const artifactLibraryTranslations$3 = {
-  "artifactLibrary.title": "산출물 모아보기",
+  "artifactLibrary.title": "작업물 모아보기",
   "artifactLibrary.scope": "범위",
   "artifactLibrary.conversation": "이 대화",
   "artifactLibrary.project": "이 프로젝트",
-  "artifactLibrary.all": "전체 프로젝트",
   "artifactLibrary.search": "파일·프로젝트·대화·경로 검색",
-  "artifactLibrary.hint": "대화에서 만든 문서와 미리보기를 모았습니다. 원본 파일을 엽니다.",
-  "artifactLibrary.loading": "산출물을 찾고 있습니다…",
+  "artifactLibrary.loading": "작업물을 찾고 있습니다…",
   "artifactLibrary.error": "일부 대화를 조회하지 못했습니다. 다시 시도해 주세요.",
-  "artifactLibrary.empty": "아직 산출물이 없습니다.",
+  "artifactLibrary.empty": "아직 작업물이 없습니다.",
   "artifactLibrary.noMatches": "검색 결과가 없습니다.",
+  "artifactLibrary.readUnsupported": "이 PC에서는 작업물 원본 읽기를 지원하지 않습니다. 현재 macOS 작업PC에서 지원됩니다.",
   "artifactLibrary.retry": "다시 시도"
 };
 const personalChatsLandingKo = {
@@ -3518,9 +3660,15 @@ const sidebarUpdateKo = {
   "sidebarUpdate.completedBody": "Saycode v{version} 업데이트가 완료됐어요.",
   "sidebarUpdate.installing": "업데이트 적용 중…",
   "sidebarUpdate.update": "업데이트",
-  "sidebarUpdate.restartNotice": "재시작 전에 대화 상태를 저장합니다.",
+  "sidebarUpdate.restartNotice": "재시작 전에 대화 상태를 저장합니다. 설치가 끝나면 Saycode가 자동으로 다시 열려요.",
   "sidebarUpdate.minimize": "최소화",
-  "sidebarUpdate.releaseNotes": "Release notes"
+  "sidebarUpdate.releaseNotes": "Release notes",
+  "sidebarUpdate.relaunchWaitTitle": "업데이트를 설치하고 있어요",
+  "sidebarUpdate.relaunchWaitBody": "설치가 끝나면 Saycode v{version}이 자동으로 열려요. 이 창을 닫아도 설치는 계속됩니다.",
+  "sidebarUpdate.relaunchTimeoutTitle": "업데이트 설치를 마치지 못했어요",
+  "sidebarUpdate.relaunchTimeoutBody": "현재 버전(v{version})으로 열 수 있어요. 앱에서 업데이트를 다시 받을 수 있습니다.",
+  "sidebarUpdate.relaunchOpenCurrent": "현재 버전으로 열기",
+  "sidebarUpdate.relaunchQuit": "종료"
 };
 const globalPauseKo = {
   "settings.globalPause.enable": "자동 작업 일시정지",
@@ -4248,8 +4396,8 @@ const designGuideChatKo = {
   "designGuide.chat.card.question": "사용자 질문",
   "designGuide.chat.card.activity": "진행 상태 행",
   "designGuide.chat.card.error": "답변 오류",
-  "designGuide.chat.card.preview": "미리보기, 산출물 링크",
-  "designGuide.chat.card.artifact": "Chat 산출물",
+  "designGuide.chat.card.preview": "미리보기, 작업물 링크",
+  "designGuide.chat.card.artifact": "Chat 작업물",
   "designGuide.chat.card.checkpoint": "파일 복원지점",
   "designGuide.chat.card.subagent": "보조 AI도구",
   "designGuide.chat.card.queue": "입력 대기열",
@@ -4845,7 +4993,6 @@ const onboardingKo = {
   "onboarding.page.addProject": "첫 프로젝트 추가",
   "onboarding.page.configured": "설정됨",
   "onboarding.page.optional": "선택",
-  "onboarding.page.computerReveal": "내부 테스트: 컴퓨터·브라우저 제어 표시",
   "onboarding.page.testNotification": "테스트 알림 보내기",
   "onboarding.page.testNotificationSending": "테스트 알림 보내는 중…",
   "onboarding.page.testNotificationSuccess": "테스트 알림을 보냈습니다.",
@@ -5020,6 +5167,7 @@ const ko = {
   "aiModelPolicy.machineChanged": "선택한 PC에 연결할 수 없어 대화 시작을 멈췄어요. PC를 확인한 뒤 다시 보내 주세요.",
   "aiModelPolicy.policyChanged": "허용 모델 정책이 바뀌어 대화 시작을 멈췄어요. 질문과 첨부를 확인한 뒤 다시 보내 주세요.",
   "aiModelPolicy.noModels": "이 컴퓨터에서 선택할 수 있는 허용 모델이 없어요.",
+  ...personalAiKo,
   ...conversationTabsKo,
   ...questionComposerKo,
   ...aiRecoveryKo,
@@ -5980,7 +6128,7 @@ const ko = {
   "deployModal.pbAdmin": "PocketBase 관리자 계정",
   "deployModal.email": "이메일:",
   "deployModal.credentialsFile": "자격증명 파일:",
-  "deployModal.pbPasswordNote": "비밀번호는 배포 산출물의 자격증명 파일에 저장됩니다. 안전한 곳에 보관하세요.",
+  "deployModal.pbPasswordNote": "비밀번호는 배포 작업물의 자격증명 파일에 저장됩니다. 안전한 곳에 보관하세요.",
   // Project settings panel
   "repositorySettings.title": "코드 저장소",
   "repositorySettings.statusSaved": "저장됨",
@@ -7354,6 +7502,9 @@ const ko = {
   "projectGitView.branchDelete": "Branch 삭제",
   // Remote terminal + API client (non-hook)
   "terminal.connectTimeout": "터미널 연결 시간이 초과되었습니다.",
+  "terminal.strictMachineUnsupported": "보안 강화(strict) 작업PC에는 아직 원격 터미널을 열 수 없습니다. 작업PC에서 직접 터미널을 사용하세요.",
+  "terminal.machineControlUnknown": "이 작업PC의 CLI가 보안 모드를 알려주지 않아 원격 터미널을 열 수 없습니다. 작업PC에서 happy CLI를 최신 버전으로 업데이트하세요.",
+  "terminal.machineKeyUnavailable": "이 작업PC의 키를 열 수 없어 원격 터미널을 열지 않았습니다. 계정 키 잠금을 해제한 뒤 다시 시도하세요.",
   "terminal.connectFailed": "터미널 연결에 실패했습니다.",
   "terminal.cwdPrepFailed": "원격 터미널 작업 디렉토리를 준비하지 못했습니다.",
   "terminal.restoredOutputDivider": "이전 세션 출력",
@@ -7685,8 +7836,8 @@ const ko = {
   "fileDiscovery.results": "검색 결과",
   "fileDiscovery.empty": "일치하는 내용 없음",
   "fileDiscovery.lineChanged": "파일이 변경되어 이동 가능한 가장 가까운 행을 표시합니다.",
-  "fileDiscovery.newArtifacts": "새 산출물",
-  "fileDiscovery.newArtifact": "새 산출물"
+  "fileDiscovery.newArtifacts": "새 작업물",
+  "fileDiscovery.newArtifact": "새 작업물"
 };
 const CATALOGS = { ko };
 function registerCatalog(language, catalog2) {
@@ -8325,10 +8476,10 @@ In a chat
   /model · /effort · /voice [path] · /detach · /exit  live chat commands
 
 Leaving never stops a remote session — it keeps running on the machine.`;
-const record$i = (value2) => !!value2 && typeof value2 === "object" && !Array.isArray(value2);
+const record$j = (value2) => !!value2 && typeof value2 === "object" && !Array.isArray(value2);
 const ids = (value2) => Array.isArray(value2) && value2.length <= 1e3 && value2.every((id2) => typeof id2 === "string" && id2.trim().length > 0);
 function parseMachineSharing(value2) {
-  if (!record$i(value2) || !record$i(value2.machine)) throw new Error("Invalid machine sharing response");
+  if (!record$j(value2) || !record$j(value2.machine)) throw new Error("Invalid machine sharing response");
   const m = value2.machine;
   if (typeof value2.revision !== "string" || !value2.revision || !["canShare", "canMakeDedicated", "canManageAccess"].every((key) => typeof value2[key] === "boolean") || !["machineId", "ownerId", "companyId", "infraMode"].every((key) => typeof m[key] === "string" && !!m[key]) || !["dedicated", "shared"].includes(String(m.type)) || !ids(m.accessList) || m.accessList.length === 0 || m.accessList.includes("*") && m.accessList.length !== 1 || m.assignedUserId != null && typeof m.assignedUserId !== "string" || value2.missingUserIds !== void 0 && !ids(value2.missingUserIds)) throw new Error("Invalid machine sharing response");
   return {
@@ -8593,7 +8744,7 @@ function parseCompanyMemberDirectoryPage(value2) {
     nextCursor: rawCursor
   };
 }
-function record$h(value2) {
+function record$i(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("Invalid team collaboration response");
   return value2;
 }
@@ -8606,12 +8757,12 @@ function choice(value2, values) {
   return value2;
 }
 function parseCollaboration(value2) {
-  const row2 = record$h(value2);
+  const row2 = record$i(value2);
   if (!Array.isArray(row2.teamIds) || row2.teamIds.length > 1e3 || !Array.isArray(row2.bindings) || row2.bindings.length > 1e3) throw new Error("Invalid team collaboration list");
   return {
     teamIds: row2.teamIds.map(identifier$4),
     bindings: row2.bindings.map((value22) => {
-      const binding = record$h(value22);
+      const binding = record$i(value22);
       return {
         accountId: identifier$4(binding.accountId),
         membershipOrigin: choice(binding.membershipOrigin, ["unresolved", "team", "preexisting"]),
@@ -8623,8 +8774,8 @@ function parseCollaboration(value2) {
   };
 }
 function parseMutation(value2) {
-  const row2 = record$h(value2);
-  const sync = row2.sync === null ? null : record$h(row2.sync);
+  const row2 = record$i(value2);
+  const sync = row2.sync === null ? null : record$i(row2.sync);
   if (sync && [sync.synced, sync.failed, sync.rejected].some((value22) => !Number.isSafeInteger(value22) || Number(value22) < 0)) throw new Error("Invalid team synchronization counts");
   return { collaboration: parseCollaboration(row2.collaboration), sync, ...parseProjectMemberRemovalResult(row2) };
 }
@@ -8632,7 +8783,7 @@ function createProjectTeamCollaborationApi(request2) {
   const path2 = (id2) => `/api/projects/${encodeURIComponent(id2)}/collaboration/teams`;
   return {
     async getProjectTeamCollaboration(id2) {
-      return parseCollaboration(record$h(await request2(path2(id2))).collaboration);
+      return parseCollaboration(record$i(await request2(path2(id2))).collaboration);
     },
     async updateProjectTeamCollaboration(id2, teamIds) {
       if (teamIds.length > 1e3) throw new Error("Too many collaboration teams");
@@ -8646,6 +8797,8 @@ function createProjectTeamCollaborationApi(request2) {
 }
 const AI_GROUP_ERROR_KINDS = [
   "AI_GROUP_ACCOUNT_IDENTITY_UNAVAILABLE",
+  "AI_GROUP_ACCOUNT_KEY_LOCKED",
+  "AI_GROUP_ACCOUNT_KEY_REQUIRED",
   "AI_GROUP_ACCOUNT_MISSING",
   "AI_GROUP_APPLY_BUSY",
   "AI_GROUP_APPLY_FAILED",
@@ -8671,6 +8824,8 @@ const AI_GROUP_ERROR_KINDS = [
   "AI_GROUP_ORGANIZATION_KEY_REQUIRED",
   "AI_GROUP_PAYLOAD_CONFLICT",
   "AI_GROUP_PAYLOAD_TOO_LARGE",
+  "AI_GROUP_PC_NOT_ASSIGNED",
+  "AI_GROUP_PC_REREGISTER_REQUIRED",
   "AI_GROUP_PREPARE_FAILED",
   "AI_GROUP_RECEIPT_INVALID",
   "AI_GROUP_RECEIPT_MISMATCH",
@@ -8701,11 +8856,11 @@ function parseAiGroupErrorKind(value2) {
   return typeof value2 === "string" && AI_GROUP_ERROR_KINDS.includes(value2) ? value2 : "UNKNOWN_ERROR";
 }
 const MANAGED_ACCOUNT_ID = /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i;
-function record$g(value2) {
+function record$h(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("Invalid AI group metadata");
   return value2;
 }
-function text$8(value2, max = 254) {
+function text$9(value2, max = 254) {
   if (typeof value2 !== "string" || !value2 || value2.length > max) throw new Error("Invalid AI group metadata");
   return value2;
 }
@@ -8730,31 +8885,31 @@ function receiptMetadata(result2) {
     ...result2.assignmentGeneration == null ? {} : { assignmentGeneration: positiveInteger(result2.assignmentGeneration) },
     ...result2.fingerprint == null ? {} : { fingerprint: digest$2(result2.fingerprint) },
     ...result2.appliedCredentials == null ? {} : { appliedCredentials: list$1(result2.appliedCredentials, 500).map((entry) => {
-      const credential = record$g(entry), managedAccountId = text$8(credential.managedAccountId, 80);
+      const credential = record$h(entry), managedAccountId = text$9(credential.managedAccountId, 80);
       if (!MANAGED_ACCOUNT_ID.test(managedAccountId)) throw new Error("Invalid AI group metadata");
       return { managedAccountId, credentialGeneration: positiveInteger(credential.credentialGeneration) };
     }) }
   };
 }
 function parseAiGroupAssignments(value2, companyId) {
-  const body = record$g(value2);
+  const body = record$h(value2);
   if (body.version !== 1 || body.companyId !== companyId) throw new Error("Invalid AI group scope");
   return { version: 1, companyId, groups: list$1(body.groups, 1e3).map((value22) => {
-    const group = record$g(value22);
+    const group = record$h(value22);
     return {
-      credentialGroupId: text$8(group.credentialGroupId, 128),
-      credentialGroupName: text$8(group.credentialGroupName, 80),
-      userGroupName: text$8(group.userGroupName, 80),
+      credentialGroupId: text$9(group.credentialGroupId, 128),
+      credentialGroupName: text$9(group.credentialGroupName, 80),
+      userGroupName: text$9(group.userGroupName, 80),
       accounts: list$1(group.accounts, 500).map((value3) => {
-        const account = record$g(value3), identity = text$8(account.identity);
+        const account = record$h(value3), identity = text$9(account.identity);
         if (!/^[a-f0-9]{64}$/.test(identity) || !Number.isSafeInteger(account.bundleVersion) || Number(account.bundleVersion) < 1 || account.kind !== "oauth" && account.kind !== "api_key") throw new Error("Invalid AI group account");
         const managed = account.credentialType === "setup_token";
         if (managed && (account.provider !== "claude" || account.kind !== "oauth" || typeof account.managedAccountId !== "string" || !MANAGED_ACCOUNT_ID.test(account.managedAccountId) || !Number.isSafeInteger(account.credentialGeneration) || Number(account.credentialGeneration) < 1)) throw new Error("Invalid AI group managed account");
         return {
-          bundleId: text$8(account.bundleId, 128),
+          bundleId: text$9(account.bundleId, 128),
           identity,
           provider: provider$1(account.provider),
-          label: text$8(account.label),
+          label: text$9(account.label),
           kind: account.kind,
           bundleVersion: Number(account.bundleVersion),
           ...managed ? { credentialType: "setup_token", managedAccountId: String(account.managedAccountId), credentialGeneration: Number(account.credentialGeneration), authState: "unverified" } : {}
@@ -8762,11 +8917,11 @@ function parseAiGroupAssignments(value2, companyId) {
       })
     };
   }), results: list$1(body.results, 5e3).map((value22) => {
-    const result2 = record$g(value22), status = result2.status;
+    const result2 = record$h(value22), status = result2.status;
     if (status !== "pending" && status !== "applied" && status !== "revoked" && status !== "failed" && status !== "action_required") throw new Error("Invalid AI group result");
     const errorKind = parseAiGroupErrorKind(result2.errorKind);
     return {
-      machineId: text$8(result2.machineId, 128),
+      machineId: text$9(result2.machineId, 128),
       provider: provider$1(result2.provider),
       status,
       ...errorKind ? { errorKind } : {},
@@ -8837,8 +8992,10 @@ function parseCollectorAssignment(value2) {
   const machineId = v.machineId === null ? null : identifier$3(v.machineId);
   const credentialGeneration = int$1(v.credentialGeneration, 0), policyRevision = int$1(v.policyRevision, 0);
   if (v.enabled && (!machineId || !credentialGeneration || !policyRevision) || v.probeAllowed && (!v.enabled || v.status !== "ready")) throw new Error("CLAUDE_COLLECTOR_INVALID_RESPONSE");
+  if (v.principalType !== void 0 && v.principalType !== "user" && v.principalType !== "machine") throw new Error("CLAUDE_COLLECTOR_INVALID_RESPONSE");
   return {
     version: 1,
+    principalType: v.principalType ?? "user",
     enabled: v.enabled,
     probeAllowed: v.probeAllowed,
     status: v.status,
@@ -8890,26 +9047,26 @@ function createClaudeCollectorApi(transport) {
     }
   };
 }
-const record$f = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
-const timestamp = (value2) => Number.isSafeInteger(value2) && value2 >= 0;
+const record$g = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+const timestamp$1 = (value2) => Number.isSafeInteger(value2) && value2 >= 0;
 function parseWindow(value2) {
-  const row2 = record$f(value2);
-  if (!row2 || typeof row2.id !== "string" || !row2.id || !timestamp(row2.openedAt) || !timestamp(row2.endsAt) || !timestamp(row2.waitMinutes)) return null;
+  const row2 = record$g(value2);
+  if (!row2 || typeof row2.id !== "string" || !row2.id || !timestamp$1(row2.openedAt) || !timestamp$1(row2.endsAt) || !timestamp$1(row2.waitMinutes)) return null;
   return { id: row2.id, openedAt: row2.openedAt, endsAt: row2.endsAt, waitMinutes: row2.waitMinutes };
 }
 function parseMe(value2) {
-  const row2 = record$f(value2);
+  const row2 = record$g(value2);
   if (!row2) return null;
   const { hasLatestGrant, pending: pending2, autoEligible, autoAt, held } = row2;
   if (typeof hasLatestGrant !== "boolean" || typeof pending2 !== "boolean" || typeof autoEligible !== "boolean" || typeof held !== "boolean") return null;
-  if (autoAt !== null && !timestamp(autoAt)) return null;
+  if (autoAt !== null && !timestamp$1(autoAt)) return null;
   return { hasLatestGrant, pending: pending2, autoEligible, autoAt, held };
 }
 function companyKeyAutoWindowHeaders(options) {
   return options?.distributor ? { "X-Saycode-Auto-Grant-Client": "desktop" } : {};
 }
 function parseCompanyKeyAutoWindow(raw) {
-  const body = record$f(raw);
+  const body = record$g(raw);
   return { window: parseWindow(body?.window), me: parseMe(body?.me) };
 }
 function companyKeyGrantFailure(error) {
@@ -8919,7 +9076,7 @@ function companyKeyGrantFailure(error) {
   const body = "body" in error ? error.body : void 0;
   if (typeof body === "string") {
     try {
-      const parsed2 = record$f(JSON.parse(body));
+      const parsed2 = record$g(JSON.parse(body));
       if (typeof parsed2?.error === "string") reason = parsed2.error;
     } catch {
     }
@@ -11590,32 +11747,32 @@ function invalidateRendererQueries(kind, scope2) {
 }
 const ROUTING_POLICY = "org-shared-difficulty-routing.v1";
 const ROUTING_AGENTS = ["claude", "codex"];
-function record$e(value2) {
+function record$f(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function id$2(value2) {
   return typeof value2 === "string" && value2.length > 0 && value2.length <= 256;
 }
 function parseRoutingResult(value2) {
-  const r = record$e(value2);
-  const baseRoute = record$e(r?.baseRoute);
-  const previousApplied = record$e(r?.previousApplied);
+  const r = record$f(value2);
+  const baseRoute = record$f(r?.baseRoute);
+  const previousApplied = record$f(r?.previousApplied);
   if (!r || r.version !== 1 || r.mode !== "auto" || r.policyVersion !== ROUTING_POLICY || !id$2(r.clientRequestId) || !id$2(r.model) || !(r.effort === null || id$2(r.effort)) || !(r.policyRevision === null || Number.isSafeInteger(r.policyRevision) && r.policyRevision >= 0) || !["trivial", "routine", "hard", "escalated"].includes(String(r.difficulty)) || !["p1-local", "p2-org-shared", "p2-local", "fallback-p1", "manual-legacy"].includes(String(r.classifierSource)) || r.stage !== void 0 && !["selected", "queued", "applied", "failed", "cancelled", "unknown"].includes(String(r.stage)) || r.revision !== void 0 && (!Number.isSafeInteger(r.revision) || r.revision < 0) || r.evidence !== void 0 && !["engine-applied", "legacy-selection", "unknown"].includes(String(r.evidence)) || r.executionId !== void 0 && !id$2(r.executionId) || r.clientRequestIds !== void 0 && (!Array.isArray(r.clientRequestIds) || r.clientRequestIds.length > 256 || !r.clientRequestIds.every(id$2)) || r.candidateDifficulty !== void 0 && !["trivial", "routine", "hard", "escalated"].includes(String(r.candidateDifficulty)) || r.baseRoute !== void 0 && (!baseRoute || !["trivial", "routine", "hard", "escalated"].includes(String(baseRoute.difficulty)) || !id$2(baseRoute.model) || !(baseRoute.effort === null || id$2(baseRoute.effort))) || r.temporaryEscalation !== void 0 && typeof r.temporaryEscalation !== "boolean" || r.decisionReasons !== void 0 && (!Array.isArray(r.decisionReasons) || r.decisionReasons.length > 16 || !r.decisionReasons.every((reason) => typeof reason === "string" && reason.length > 0 && reason.length <= 64)) || r.providerConfirmedModel !== void 0 && !id$2(r.providerConfirmedModel) || r.previousApplied !== void 0 && (!previousApplied || !id$2(previousApplied.model) || !(previousApplied.effort === null || id$2(previousApplied.effort)) || !["trivial", "routine", "hard", "escalated"].includes(String(previousApplied.difficulty)) || !["auto", "local-auto-bootstrap", "manual"].includes(String(previousApplied.kind)))) return null;
   return r;
 }
 function parseRoutingPolicy(value2) {
-  const p = record$e(value2);
+  const p = record$f(value2);
   if (!p || p.schemaVersion !== 1 || typeof p.enabled !== "boolean" || p.policyVersion !== ROUTING_POLICY || !Number.isSafeInteger(p.revision) || p.revision < 0 || typeof p.appliesToSharedMachines !== "boolean" || !(p.hostMachineId === null || id$2(p.hostMachineId)) || !["off", "ready", "host-offline", "host-unsupported", "not-authorized"].includes(String(p.status))) return null;
   if (p.enabled && !id$2(p.hostMachineId)) return null;
   return p;
 }
 function parseRoutingSettings(value2) {
-  const v = record$e(value2), s = record$e(v?.settings), r = record$e(v?.rollout), h = v?.host === null ? null : record$e(v?.host);
+  const v = record$f(value2), s = record$f(v?.settings), r = record$f(v?.rollout), h = v?.host === null ? null : record$f(v?.host);
   if (!s || s.schemaVersion !== 1 || s.policyVersion !== ROUTING_POLICY || typeof s.enabled !== "boolean" || !(s.hostMachineId === null || id$2(s.hostMachineId)) || s.enabled && !id$2(s.hostMachineId) || !Number.isSafeInteger(s.revision) || s.revision < 0 || !(s.updatedById === null || id$2(s.updatedById)) || !(s.updatedAt === null || typeof s.updatedAt === "number" && Number.isFinite(s.updatedAt)) || !r || !["sharedMachineCount", "capableSharedMachineCount", "unsupportedSharedMachineCount"].every((k) => Number.isSafeInteger(r[k]) && r[k] >= 0) || v?.host !== null && (!h || !id$2(h.machineId) || !(h.displayName === null || typeof h.displayName === "string") || typeof h.online !== "boolean" || typeof h.shared !== "boolean" || !["ready", "missing", "unsupported", "not-ready"].includes(String(h.capability)) || !(h.hostProcessKeyId === null || id$2(h.hostProcessKeyId)))) throw new Error("Invalid organization routing settings");
   return v;
 }
 function canNegotiateOrgRouting(input) {
-  const capability = record$e(input.machine?.difficultyRouting);
+  const capability = record$f(input.machine?.difficultyRouting);
   return !input.manual && id$2(input.requestId) && !!input.companyId && ROUTING_AGENTS.includes(input.agent ?? "") && input.machine?.registry?.type === "shared" && input.machine.registry.companyId === input.companyId && capability?.version === 1 && capability.protocol === ROUTING_POLICY;
 }
 function prepareRoutingIntent(input) {
@@ -15078,7 +15235,7 @@ const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
-function record$d(keyType, valueType, params) {
+function record$e(keyType, valueType, params) {
   return new ZodRecord({
     type: "record",
     keyType,
@@ -15312,7 +15469,7 @@ function superRefine(fn) {
 }
 function json(params) {
   const jsonSchema = lazy(() => {
-    return union([string$1(params), number(), boolean(), _null(), array$4(jsonSchema), record$d(string$1(), jsonSchema)]);
+    return union([string$1(params), number(), boolean(), _null(), array$4(jsonSchema), record$e(string$1(), jsonSchema)]);
   });
   return jsonSchema;
 }
@@ -17610,14 +17767,14 @@ const scriptAutomationPayloadSchema = strictObject({
     entrypoint: entrypointSchema,
     args: array$4(string$1().max(4e3)).max(64),
     timeoutSeconds: number().int().min(1).max(1800),
-    secretRefs: record$d(secretName, string$1().min(1).max(200)),
+    secretRefs: record$e(secretName, string$1().min(1).max(200)),
     allowedOrigins: array$4(originSchema).max(100)
   }),
   schedule: scriptScheduleSchema.nullable(),
   externalEnabled: boolean(),
-  inputSchema: record$d(string$1(), json())
+  inputSchema: record$e(string$1(), json())
 });
-strictObject({ input: record$d(string$1(), json()) });
+strictObject({ input: record$e(string$1(), json()) });
 const scriptAdmissionSchema = scriptAutomationPayloadSchema.pick({
   schedule: true,
   externalEnabled: true,
@@ -17644,7 +17801,7 @@ discriminatedUnion("operation", [
   strictObject({ operation: literal("upsert"), registration: scriptRegistrationRequestSchema }),
   strictObject({ operation: literal("runs"), automationId: managementId, runId: managementId.optional() }),
   strictObject({ operation: literal("artifact"), artifactId: managementId }),
-  strictObject({ operation: literal("run"), automationId: managementId, input: record$d(string$1(), json()), idempotencyKey: managementId }),
+  strictObject({ operation: literal("run"), automationId: managementId, input: record$e(string$1(), json()), idempotencyKey: managementId }),
   strictObject({ operation: literal("cancel"), automationId: managementId, runId: managementId })
 ]);
 const scriptAutomationRowSchema = object$3({
@@ -17935,14 +18092,14 @@ function parseCloudLoginResult(raw) {
 }
 const HANDOFF_ID_PATTERN = /^mph-[A-Za-z0-9_-]{22}$/;
 const CAPABILITY_PATTERN = /^[A-Za-z0-9_-]{43}$/;
-function record$c(value2) {
+function record$d(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
 function validExpiry$1(value2) {
   return typeof value2 === "number" && Number.isSafeInteger(value2) && value2 > 0;
 }
 function parseMfaPasskeyHandoff(raw, apiBaseUrl) {
-  const value2 = record$c(raw);
+  const value2 = record$d(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$1(value2.expiresAt)) {
     throw new Error("MFA_PASSKEY_HANDOFF_RESPONSE_INVALID");
   }
@@ -17966,7 +18123,7 @@ function parseMfaPasskeyHandoff(raw, apiBaseUrl) {
   };
 }
 function parsePendingMfaPasskeyExchange(raw) {
-  const value2 = record$c(raw);
+  const value2 = record$d(raw);
   if (!value2 || value2.status !== "pending" || !validExpiry$1(value2.expiresAt)) {
     throw new Error("MFA_PASSKEY_HANDOFF_RESPONSE_INVALID");
   }
@@ -18205,6 +18362,9 @@ async function preDecryptSessionHeaders(sessions, accountPrivateKey, sinceGenera
     }
   }));
 }
+function readsAsStrictMachineControl(machine) {
+  return !machine.serverDataEncryptionKey && typeof machine.serverRpcKeyEnvelope === "string" && machine.serverRpcKeyEnvelope !== "";
+}
 const MACHINE_KEY_ATTESTATION_VERSION = 1;
 const DIGEST_DOMAIN = new TextEncoder().encode("happy machine key fingerprint v1");
 const HEADER_BYTES = 1 + nacl.box.publicKeyLength + nacl.box.nonceLength;
@@ -18518,7 +18678,7 @@ function personalMachinesPath(companyId) {
 function myMachinesPath(companyId) {
   return `/api/admin/companies/${encodeURIComponent(companyId)}/my-machines`;
 }
-function record$b(value2) {
+function record$c(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 }
 function array$3(value2) {
@@ -18537,7 +18697,7 @@ function provider(value2) {
   return PROVIDERS.includes(str$1(value2)) ? str$1(value2) : null;
 }
 function parseBundle(value2) {
-  const row2 = record$b(value2);
+  const row2 = record$c(value2);
   const id2 = str$1(row2.id);
   const bundleProvider = provider(row2.provider);
   if (!id2 || !bundleProvider) return null;
@@ -18556,7 +18716,7 @@ function parseBundle(value2) {
   };
 }
 function parseDeployment(value2) {
-  const row2 = record$b(value2);
+  const row2 = record$c(value2);
   const machineId = str$1(row2.machineId);
   const bundleId = str$1(row2.bundleId);
   if (!machineId || !bundleId) return null;
@@ -18576,10 +18736,10 @@ function parseDeployment(value2) {
   };
 }
 function parseStatus(value2) {
-  const row2 = record$b(value2);
+  const row2 = record$c(value2);
   const statusProvider = provider(row2.provider);
   if (!statusProvider) return void 0;
-  const rotationRow = record$b(row2.rotation);
+  const rotationRow = record$c(row2.rotation);
   const state = str$1(rotationRow.state);
   const warningKinds = Array.isArray(rotationRow.warningKinds) ? [...new Set(rotationRow.warningKinds.filter(
     (kind) => kind === "ACCOUNT_NEEDS_REAUTH" || kind === "NO_COMPARISON"
@@ -18604,7 +18764,7 @@ function parseStatus(value2) {
   };
 }
 function parseMachineResult(value2) {
-  const row2 = record$b(value2);
+  const row2 = record$c(value2);
   const machineId = str$1(row2.machineId);
   if (!machineId) return null;
   if (row2.ok !== true) {
@@ -18619,28 +18779,28 @@ function parseMachineResult(value2) {
   };
 }
 function parseAiCredentialVaultSnapshot(value2) {
-  const body = record$b(value2);
+  const body = record$c(value2);
   return {
     bundles: array$3(body.bundles).map(parseBundle).filter((bundle) => bundle !== null),
     deployments: array$3(body.deployments).map(parseDeployment).filter((deployment) => deployment !== null)
   };
 }
 function parseAiCredentialCaptureResponse(value2) {
-  const body = record$b(value2);
+  const body = record$c(value2);
   const bundle = parseBundle(body.bundle);
   if (!bundle) throw new Error("AI credential capture response did not contain a bundle");
   return { bundle, warnings: array$3(body.warnings).filter((warning) => typeof warning === "string") };
 }
 function parseAiCredentialBatchResult(value2) {
-  const body = record$b(value2);
+  const body = record$c(value2);
   return {
     results: array$3(body.results).map(parseMachineResult).filter((result2) => result2 !== null),
     warnings: array$3(body.warnings).filter((warning) => typeof warning === "string")
   };
 }
 function parseSelfServiceMachines(value2) {
-  return array$3(record$b(value2).machines).map((entry) => {
-    const row2 = record$b(entry);
+  return array$3(record$c(value2).machines).map((entry) => {
+    const row2 = record$c(entry);
     return {
       machineId: str$1(row2.machineId),
       type: row2.type === "shared" ? "shared" : "personal",
@@ -18653,8 +18813,8 @@ function parseSelfServiceMachines(value2) {
   }).filter((machine) => machine.machineId !== "");
 }
 function parsePersonalMachines(value2) {
-  return array$3(record$b(value2).machines).map((entry) => {
-    const row2 = record$b(entry);
+  return array$3(record$c(value2).machines).map((entry) => {
+    const row2 = record$c(entry);
     const type = row2.type === "shared" ? "shared" : "personal";
     return {
       machineId: str$1(row2.machineId),
@@ -18689,7 +18849,7 @@ const orgSearchPaths = {
   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$a(value2) {
+function record$b(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 }
 function str(value2, fallback = "") {
@@ -18700,9 +18860,9 @@ function num(value2, fallback = 0) {
 }
 const PHASES = ["idle", "waiting", "indexing", "done"];
 function parseOrgSearchCursors(raw) {
-  const list2 = Array.isArray(record$a(raw).cursors) ? record$a(raw).cursors : [];
+  const list2 = Array.isArray(record$b(raw).cursors) ? record$b(raw).cursors : [];
   return list2.flatMap((item) => {
-    const c = record$a(item);
+    const c = record$b(item);
     if (typeof c.sessionId !== "string" || typeof c.lastSeq !== "number") return [];
     return [{
       sessionId: c.sessionId,
@@ -18714,7 +18874,7 @@ function parseOrgSearchCursors(raw) {
   });
 }
 function parseProjectProgress(raw) {
-  const p = record$a(raw);
+  const p = record$b(raw);
   return {
     projectId: str(p.projectId),
     sessionsTotal: num(p.sessionsTotal),
@@ -18727,7 +18887,7 @@ function parseProjectProgress(raw) {
   };
 }
 function parseOrgSearchProgress(raw) {
-  const r = record$a(raw);
+  const r = record$b(raw);
   return {
     phase: PHASES.includes(r.phase) ? r.phase : "idle",
     sessionsTotal: num(r.sessionsTotal),
@@ -19204,7 +19364,7 @@ const PUBLICATION_KEYS = /* @__PURE__ */ new Set([
 function fail$9(detail) {
   throw new Error(`artifact publication response is invalid: ${detail}`);
 }
-function record$9(value2, label) {
+function record$a(value2, label) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) fail$9(`${label} must be an object`);
   return value2;
 }
@@ -19250,7 +19410,7 @@ function sourceIdentity(source2) {
   ]) : JSON.stringify([source2.chatId, source2.path]);
 }
 function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
-  const publication = record$9(value2, "publication");
+  const publication = record$a(value2, "publication");
   if (Object.keys(publication).some((key) => !PUBLICATION_KEYS.has(key))) {
     fail$9("publication contains an unexpected field");
   }
@@ -19283,7 +19443,7 @@ function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
   };
 }
 function parseStaticArtifactPublicationResult(value2, options) {
-  const response2 = record$9(value2, "response");
+  const response2 = record$a(value2, "response");
   if (options.operation === "publish") {
     exactKeys$3(response2, ["publication", "publicUrl", "reused"]);
     if (typeof response2.reused !== "boolean") fail$9("reused is invalid");
@@ -19305,20 +19465,20 @@ const MAX_ID = 256;
 function isRecord$4(value2) {
   return !!value2 && typeof value2 === "object" && !Array.isArray(value2);
 }
-function text$7(value2, max = MAX_TEXT) {
+function text$8(value2, max = MAX_TEXT) {
   return typeof value2 === "string" && value2.length >= 1 && value2.length <= max;
 }
 function list(value2, minItems) {
-  return Array.isArray(value2) && value2.length >= minItems && value2.length <= MAX_ITEMS && value2.every((item) => text$7(item));
+  return Array.isArray(value2) && value2.length >= minItems && value2.length <= MAX_ITEMS && value2.every((item) => text$8(item));
 }
 function parseLessonCandidate(value2) {
   if (!isRecord$4(value2) || value2.t !== "lesson-candidate") return null;
   if (Object.keys(value2).some((key) => !EVENT_KEYS.has(key))) return null;
   const { candidateId, revision, payloadHash, lesson } = value2;
-  if (!text$7(candidateId, MAX_ID) || !text$7(payloadHash, MAX_ID)) return null;
+  if (!text$8(candidateId, MAX_ID) || !text$8(payloadHash, MAX_ID)) return null;
   if (typeof revision !== "number" || !Number.isInteger(revision) || revision < 0) return null;
   if (!isRecord$4(lesson) || Object.keys(lesson).some((key) => !LESSON_KEYS.has(key))) return null;
-  if (!text$7(lesson.name) || !text$7(lesson.trigger) || !text$7(lesson.scope) || !text$7(lesson.reconsiderWhen)) return null;
+  if (!text$8(lesson.name) || !text$8(lesson.trigger) || !text$8(lesson.scope) || !text$8(lesson.reconsiderWhen)) return null;
   if (!list(lesson.steps, 1) || !list(lesson.validation, 1) || !list(lesson.failureModes, 0)) return null;
   if (lesson.validVersions !== void 0 && !list(lesson.validVersions, 0)) return null;
   return {
@@ -19544,16 +19704,20 @@ const CLAUDE_PROVIDER_PATTERN = /rate.?limit|too many requests|overloaded|model[
 const INACTIVITY_PREFIX = "stopped automatically";
 const PROCESS_EXITED_NOTICE = "process exited unexpectedly";
 const CLAUDE_OAUTH_FAILURE = /^Failed to authenticate\. API Error: 401 OAuth access token is invalid\.$/i;
-const CLAUDE_NOT_SIGNED_IN = /^(?:Not logged in · Please run \/login|Claude Code is not signed in on this machine\.)/i;
+const CLAUDE_NOT_SIGNED_IN = /^Not logged in · Please run \/login/i;
 const CLAUDE_SUBSCRIPTION_REFUSAL = /^Your organization has disabled Claude subscription access for Claude Code(?:\s*[·.—-]\s*Use an Anthropic API key instead, or ask your admin to enable access)?\.?$/i;
 function unsupportedModelSurface(text2) {
   if (detectModelLimitNotice(text2) || text2.toLowerCase().includes("requires a newer version of codex")) return null;
   return /\b(?:model[_ -](?:not[_ -]found|unsupported|not[_ -]supported)|unsupported[_ -]model|unknown model)\b|\bmodel(?:\s+["'`][^"'`\r\n]{1,120}["'`])?\s+(?:is not supported|is unsupported|does not exist)\b/i.test(text2) ? { layer: "provider", code: "model_unsupported", retryable: true } : null;
 }
+function capacitySurface(text2) {
+  if (detectModelLimitNotice(text2) || text2.toLowerCase().includes("requires a newer version of codex")) return null;
+  return /\bselected model is at capacity\b/i.test(text2) ? { layer: "provider", code: "model_capacity", retryable: true } : null;
+}
 function messageErrorSurface(message) {
   if ((message.role === "agent" || message.role === "system") && !message.thinking && !message.toolCall && message.errorSurface?.layer === "provider" && ["codex_error", "claude_error"].includes(message.errorSurface.code)) {
     const text22 = message.content ?? "";
-    const refined = !AUTH_PATTERNS.some((pattern) => pattern.test(text22.toLowerCase())) ? unsupportedModelSurface(text22) : null;
+    const refined = !AUTH_PATTERNS.some((pattern) => pattern.test(text22.toLowerCase())) ? unsupportedModelSurface(text22) ?? (message.errorSurface.code === "codex_error" ? capacitySurface(text22) : null) : null;
     if (refined) return refined;
   }
   if (message.errorSurface && isErrorSurfaceLayer(message.errorSurface.layer)) return message.errorSurface;
@@ -19587,7 +19751,7 @@ function classifyErrorSurface(rawText) {
       if (lower.startsWith(CODEX_ERROR_PREFIX) && lower.includes("requires a newer version of codex")) {
         return { layer: "provider", code: "codex_needs_update", retryable: false };
       }
-      const modelFailure = unsupportedModelSurface(text2);
+      const modelFailure = unsupportedModelSurface(text2) ?? (lower.startsWith(CODEX_ERROR_PREFIX) ? capacitySurface(text2) : null);
       if (modelFailure) return modelFailure;
       if (lower.startsWith(CLAUDE_ERROR_PREFIX) && !CLAUDE_PROVIDER_PATTERN.test(lower)) return null;
       return { layer: "provider", code: lower.startsWith(CODEX_ERROR_PREFIX) ? "codex_error" : "claude_error", retryable: true };
@@ -28764,6 +28928,53 @@ async function prepareMcpCallerGrantEnvelope(input, deps) {
     return { ok: false, reason: "invalid-key" };
   }
 }
+function record$9(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+}
+function text$7(value2) {
+  return typeof value2 === "string" && value2.trim() ? value2.trim() : null;
+}
+function timestamp(value2, fallback) {
+  if (typeof value2 === "number" && Number.isFinite(value2)) return value2;
+  if (typeof value2 === "string" && value2.trim()) {
+    const parsed2 = Date.parse(value2);
+    if (Number.isFinite(parsed2)) return parsed2;
+  }
+  return fallback;
+}
+function parseInvite(value2) {
+  const row2 = record$9(value2);
+  if (!row2) return null;
+  const inviteId = text$7(row2.inviteId ?? row2.id);
+  const companyId = text$7(row2.companyId);
+  const companyDisplayName = text$7(row2.companyDisplayName ?? row2.companyName);
+  const companySlug = text$7(row2.companySlug ?? row2.slug);
+  const role = row2.role === "admin" || row2.role === "member" ? row2.role : null;
+  const createdAt = timestamp(row2.createdAt, null);
+  if (!inviteId || !companyId || !companyDisplayName || !companySlug || !role || createdAt === null) return null;
+  return {
+    inviteId,
+    companyId,
+    companyDisplayName,
+    companySlug,
+    role,
+    expiresAt: timestamp(row2.expiresAt, null),
+    createdAt
+  };
+}
+function parsePendingCompanyInvites(value2) {
+  const rows = Array.isArray(value2) ? value2 : record$9(value2)?.invites;
+  if (!Array.isArray(rows)) throw new Error("Invalid invitation response");
+  const seen = /* @__PURE__ */ new Set();
+  const result2 = [];
+  for (const row2 of rows) {
+    const invite = parseInvite(row2);
+    if (!invite || seen.has(invite.inviteId)) continue;
+    seen.add(invite.inviteId);
+    result2.push(invite);
+  }
+  return result2;
+}
 const CLEARABLE_STRING_KEYS = /* @__PURE__ */ new Set(["branch", "baseBranch"]);
 function buildWorktreeMutationBody(input, options = {}) {
   return JSON.stringify(Object.fromEntries(
@@ -29535,6 +29746,7 @@ function normalizeMachine(row2, candidateKeys, dataKeyFields = null) {
     ...authenticatedEnvelopes ? { authenticatedEnvelopes } : {},
     // specs/e2ee-machine-control-boundary R22 — the attestation decision for the key this app opened.
     ...keyTrust ? { keyTrust } : {},
+    ...readsAsStrictMachineControl(row2) ? { machineControl: "strict" } : {},
     channelSupport,
     // Owner metadata only: the host key in it is what Desktop seals credentials to.
     channelHost: parseChannelHostCapability(decrypted.channelHost),
@@ -29941,6 +30153,30 @@ class ApiClient {
     const data = await this.request("/api/companies/me", { boundary: "api" });
     return Array.isArray(data) ? data : data.companies ?? [];
   }
+  async getPendingCompanyInvites() {
+    const invites = [], cursors = /* @__PURE__ */ new Set();
+    let cursor = null;
+    do {
+      const data = await this.request(`/api/companies/pending-invites-for-me?limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`, { boundary: "api" });
+      invites.push(...parsePendingCompanyInvites(data));
+      cursor = !Array.isArray(data) && data && typeof data === "object" && "nextCursor" in data && typeof data.nextCursor === "string" ? data.nextCursor : null;
+      if (cursor && cursors.has(cursor)) throw new Error("Repeated invitation cursor");
+      if (cursor) cursors.add(cursor);
+    } while (cursor);
+    return invites.filter((row2, index) => invites.findIndex((other) => other.inviteId === row2.inviteId) === index);
+  }
+  async acceptCompanyInvite(inviteId, mfaSessionToken) {
+    const data = await this.request("/api/companies/join", {
+      method: "POST",
+      boundary: "api",
+      body: JSON.stringify({ inviteId }),
+      headers: mfaSessionToken ? { "X-Saycode-Mfa-Session": mfaSessionToken } : {}
+    });
+    return { reauthenticationRequired: data.reauthenticationRequired === true };
+  }
+  async declineCompanyInvite(inviteId) {
+    await this.request(`/api/companies/pending-invites-for-me/${encodeURIComponent(inviteId)}`, { method: "DELETE", boundary: "api" });
+  }
   async getAiGroupAssignments(companyId, signal, mfaSessionToken) {
     const value2 = await this.request(`/api/companies/${encodeURIComponent(companyId)}/ai-groups/me`, {
       boundary: "api",
@@ -34465,7 +34701,7 @@ class ChatInputController {
     this.readline.off("close", this.handleClose);
   }
 }
-function readString$3(source2, key) {
+function readString$4(source2, key) {
   const value2 = source2[key];
   return typeof value2 === "string" && value2 ? value2 : void 0;
 }
@@ -34484,8 +34720,8 @@ function normalizeSessionRows(rows, candidateKeys) {
     if (!metadata) continue;
     sessions.push({
       id: row2.id,
-      machineId: readString$3(metadata, "machineId") ?? "",
-      directory: readString$3(metadata, "path") ?? "",
+      machineId: readString$4(metadata, "machineId") ?? "",
+      directory: readString$4(metadata, "path") ?? "",
       summary: readSummary(metadata),
       active: row2.active === true,
       updatedAt: row2.updatedAt ?? 0,
@@ -37990,7 +38226,7 @@ async function replyToPermission(connection, request2, answer) {
     ...answer === "approve-always" ? { mode: "bypassPermissions" } : {}
   });
 }
-function readString$2(source2, key) {
+function readString$3(source2, key) {
   const value2 = source2?.[key];
   return typeof value2 === "string" && value2 ? value2 : void 0;
 }
@@ -37999,9 +38235,9 @@ function normalizeMachineRows(rows, candidateKeys) {
     const metadata = decryptJsonWithCandidates(row2.metadata, candidateKeys);
     return {
       id: row2.id,
-      host: readString$2(metadata, "host") ?? row2.id.slice(0, 8),
-      platform: readString$2(metadata, "platform") ?? "unknown",
-      ...readString$2(metadata, "homeDir") ? { homeDir: readString$2(metadata, "homeDir") } : {},
+      host: readString$3(metadata, "host") ?? row2.id.slice(0, 8),
+      platform: readString$3(metadata, "platform") ?? "unknown",
+      ...readString$3(metadata, "homeDir") ? { homeDir: readString$3(metadata, "homeDir") } : {},
       online: typeof row2.online === "boolean" ? row2.online : row2.active === true,
       // Unknown last-seen renders as "unknown", never as "just now" — same
       // reasoning as src/api/client.ts#normalizeMachine.
@@ -40352,7 +40588,7 @@ async function startFrontDoor(options) {
       return;
     }
     const target = upstreams[route];
-    const upstream = request({
+    const upstream = request$1({
       host: target.hostname,
       port: target.port,
       method: req.method,
@@ -40721,9 +40957,9 @@ function serverLogWriter(layout, name) {
   };
 }
 const happyCliPackageName = "@buzzni/happy-cli";
-const happyCliVersion = "1.1.10-aplus.318";
-const happyCliTag = "happy-cli-v1.1.10-aplus.318";
-const vendorCommit = "236706106627e00c5b212fab7f9f98ce3ea05d97";
+const happyCliVersion = "1.1.10-aplus.319";
+const happyCliTag = "happy-cli-v1.1.10-aplus.319";
+const vendorCommit = "4cc930893e9530c5d88ab0280575979b433738a3";
 const saycodeCliVersion = "0.8.2";
 const happyServerVersion = "0.1.2";
 const releaseFeatures = { "mcpRuntimeRecovery": { "enabled": true, "releaseState": "released", "sourceBranch": "main", "sourceHead": "a79a10e288cf7775cb15955f716693c6a7df1640", "requiredCommit": "975e32cf" } };
@@ -45901,7 +46137,7 @@ function requireLib$2() {
     }
     if (this.state !== PENDING) {
       var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
-      unwrap(promise, resolver, this.outcome);
+      unwrap2(promise, resolver, this.outcome);
     } else {
       this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
     }
@@ -45922,15 +46158,15 @@ function requireLib$2() {
     handlers.resolve(this.promise, value2);
   };
   QueueItem.prototype.otherCallFulfilled = function(value2) {
-    unwrap(this.promise, this.onFulfilled, value2);
+    unwrap2(this.promise, this.onFulfilled, value2);
   };
   QueueItem.prototype.callRejected = function(value2) {
     handlers.reject(this.promise, value2);
   };
   QueueItem.prototype.otherCallRejected = function(value2) {
-    unwrap(this.promise, this.onRejected, value2);
+    unwrap2(this.promise, this.onRejected, value2);
   };
-  function unwrap(promise, func, value2) {
+  function unwrap2(promise, func, value2) {
     immediate(function() {
       var returnValue;
       try {
@@ -54534,6 +54770,52 @@ const conversationTabsEn = {
   "workspaceHost.closeConversationHint": "Closes this tab. Your conversation history is kept.",
   "workspaceHost.newConversation": "Open a new conversation"
 };
+const personalAiEn = {
+  "aiConnection.sectionTitle": "Check connected AI",
+  "aiConnection.ai": "AI",
+  "aiConnection.pc": "PC",
+  "aiConnection.selectPc": "Select a PC",
+  "aiConnection.pcUnknown": "Unavailable",
+  "aiConnection.selectAi": "Select AI",
+  "aiConnection.chooseAiHint": "Select an AI to check its connection on this PC.",
+  "personalAi.settingsTitle": "My AI account",
+  "personalAi.settingsDescription": "Connect the ChatGPT or Claude account you already use.",
+  "personalAi.title": "Connect a personal AI account",
+  "personalAi.imageAlt": "A web account connected to a desktop chat",
+  "personalAi.intro": "Connect your ChatGPT or Claude account\nto chat with AI in SayCode.",
+  "personalAi.note": "Sign in with the AI account you already use.",
+  "personalAi.later": "Maybe later",
+  "personalAi.connect": "Connect my AI account",
+  "personalAi.choose": "Choose an AI service",
+  "personalAi.chooseDescription": "Sign in on the selected service’s website.",
+  "personalAi.withProvider": "Connect with {provider}",
+  "personalAi.back": "Back",
+  "personalAi.providerTitle": "Connect {provider}",
+  "personalAi.waiting": "Finish signing in in your browser.",
+  "personalAi.approval": "After signing in and approving access,\nwe’ll automatically check the connection.",
+  "personalAi.cancel": "Cancel",
+  "personalAi.reopen": "Reopen browser",
+  "personalAi.expired": "We couldn’t confirm the connection yet.",
+  "personalAi.retryDescription": "Reconnect and finish signing in\nin your browser.",
+  "personalAi.retry": "Reconnect",
+  "personalAi.connected": "Your {provider} account is connected.",
+  "personalAi.ready": "Ready to use on this computer.",
+  "personalAi.done": "Done",
+  "personalAi.localOnly": "Connect personal AI accounts on this computer. Select this computer as your work PC, then reconnect.",
+  "personalAi.unavailable": "Check this computer’s connection and AI tool installation, then open this again.",
+  "aiConnection.loginLinkFailed": "Could not open the sign-in link. Select the link under Show terminal instead.",
+  "aiConnection.openLoginLink": "Open sign-in link",
+  "aiConnection.loginPreparing": "Preparing sign-in…",
+  "aiConnection.codeLabel": "Paste the authentication code shown after signing in on the web page.",
+  "aiConnection.codeSend": "Send code",
+  "aiConnection.loginFailed": "Sign-in failed. Check the authentication code and try again.",
+  "aiConnection.loginRetry": "Try again",
+  "aiConnection.loginTerminalFailed": "Could not open the sign-in terminal. Reopen it from the terminal below.",
+  "aiConnection.loginTerminalClosed": "The sign-in terminal closed. Reopen it from the terminal below.",
+  "aiConnection.loginLinkSlow": "The sign-in link has not appeared yet. Check the progress in the terminal below.",
+  "aiConnection.codeSent": "Code sent. When sign-in finishes, select Sign-in complete.",
+  "aiConnection.showTerminal": "Show terminal"
+};
 const questionComposerEn = {
   "askUser.skip": "Skip",
   "askUser.skipAnswer": "The user skipped answering this question.",
@@ -54755,6 +55037,12 @@ const projectSettingsEn = {
   "projectSettings.diagnostics": "Developer information"
 };
 const aiRecoveryEn = {
+  "aiRecovery.capacityTitle": "Model capacity recovery",
+  "aiRecovery.capacitySummary": "There are a lot of requests right now. Please try again shortly.",
+  "aiRecovery.capacityCountdown": "Retrying in {seconds}s ({attempt}/3)",
+  "aiRecovery.capacityCancel": "Cancel",
+  "aiRecovery.capacityExhausted": "Automatic retries finished. Retry later or change the model in the composer.",
+  "aiRecovery.capacityModelHint": "You can choose another model in the composer.",
   "aiRecovery.modelUnsupported": "This AI cannot use the selected model. Change the model in the message box, then retry.",
   "aiRecovery.accessSummary": "This account cannot use Claude.",
   "aiRecovery.connectAccount": "Reconnect AI",
@@ -54872,6 +55160,8 @@ const managedClaudeEn = {
   "managedClaude.loading": "Connecting AI…"
 };
 const workEn = {
+  "work.mediaChanged": "The original file changed. Reopen it to continue.",
+  "work.mediaUnsupported": "Media streaming is unavailable on this computer. Save the original and open it locally.",
   "work.homeTitle": "What can I help you with?",
   "work.new": "Start new chat",
   "work.archived": "Archived chats",
@@ -54927,7 +55217,8 @@ const workEn = {
   "work.sourceNotice.denied": "You do not have access to this file. Check your permissions.",
   "work.sourceNotice.unavailable": "Could not check the file. Try again.",
   "work.saveCheck": "Check saved copy",
-  "work.checkingFile": "Checking…"
+  "work.checkingFile": "Checking…",
+  "work.mediaViewerNeeded": "Install a media preview extension and allow it to read the selected file."
 };
 const FILE_ACCESS_TRANSLATIONS_EN = {
   "fileAccess.retry": "Try again",
@@ -55003,6 +55294,8 @@ const organizationInstallRecoveryEn = {
   "organizationStart.toolDiagnostic.reason.TOOL_EXECUTION_FAILED": "The file could not run or report its version.",
   "organizationStart.toolDiagnostic.reason.TOOL_INSTALL_FAILED": "Tool preparation failed. The exact cause is not yet known.",
   "organizationStart.toolDiagnostic.reason.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "The installed cswap does not support the required authentication capability.",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_AUTH_REQUIRED": "The company proxy asked for sign-in authentication, so the connection failed.",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_BLOCKED": "The company proxy did not allow the connection to the download or package server.",
   "organizationStart.toolDiagnostic.action.TOOL_NOT_FOUND": "Retry, or install the tool using the guide and check again.",
   "organizationStart.toolDiagnostic.action.TOOL_PREREQUISITE_REQUIRED": "Prepare the listed prerequisite first, then retry.",
   "organizationStart.toolDiagnostic.action.TOOL_NETWORK_FAILED": "Check the internet, company network and proxy, then retry.",
@@ -55015,12 +55308,55 @@ const organizationInstallRecoveryEn = {
   "organizationStart.toolDiagnostic.action.TOOL_TIMEOUT": "Check the network and retry. Share this diagnostic if it repeats.",
   "organizationStart.toolDiagnostic.action.TOOL_EXECUTION_FAILED": "Check installation completeness and whether company policy permits execution.",
   "organizationStart.toolDiagnostic.action.TOOL_INSTALL_FAILED": "Retry. If it repeats, share this diagnostic.",
-  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "Retry to install the authentication tool used by Saycode."
+  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "Retry to install the authentication tool used by Saycode.",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_AUTH_REQUIRED": "Share this diagnostic with IT and ask them to exempt the download server from proxy authentication.",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_BLOCKED": "Share this diagnostic with IT and ask them to allow access to the download server."
+};
+const organizationAccountKeyEn = {
+  "organizationStart.accountKey.title": "Turn on conversation encryption",
+  "organizationStart.accountKey.body": "To use organization AI on this computer, turn on conversation encryption first. Your current password creates this account's encryption key.",
+  "organizationStart.accountKey.row": "Conversation encryption",
+  "organizationStart.accountKey.passwordLabel": "Current password",
+  "organizationStart.accountKey.checking": "Checking password…",
+  "organizationStart.accountKey.recoveryTitle": "Keep your Recovery Key",
+  "organizationStart.accountKey.recoveryNotice": "It opens your conversations if you forget your password. If you lose both your password and your Recovery Key, encrypted conversations cannot be opened. You cannot see this Recovery Key again after closing this screen.",
+  "organizationStart.accountKey.copy": "Copy",
+  "organizationStart.accountKey.copied": "Recovery Key copied.",
+  "organizationStart.accountKey.save": "Save to file",
+  "organizationStart.accountKey.saved": "Recovery Key saved.",
+  "organizationStart.accountKey.confirmLabel": "Enter the Recovery Key again",
+  "organizationStart.accountKey.confirmMismatch": "This does not match the Recovery Key above.",
+  "organizationStart.accountKey.enable": "Turn on conversation encryption",
+  "organizationStart.accountKey.saving": "Turning on…",
+  "organizationStart.accountKey.renewBody": "The check timed out, so confirm your password once more. The Recovery Key you kept stays the same.",
+  "organizationStart.accountKey.renew": "Check again",
+  "organizationStart.accountKey.error.wrong-password": "The current password is incorrect.",
+  "organizationStart.accountKey.error.rate-limited": "Too many attempts. Try again in a moment.",
+  "organizationStart.accountKey.error.already-enabled": "Conversation encryption is already on for this account. Sign out and sign in again.",
+  "organizationStart.accountKey.error.signed-out": "Your sign-in expired. Sign out and sign in again.",
+  "organizationStart.accountKey.error.expired": "The check timed out. Enter your password again.",
+  "organizationStart.accountKey.error.failed": "Couldn't turn on conversation encryption. Try again in a moment.",
+  "organizationStart.accountKey.error.recovery-mismatch": "This does not match the Recovery Key above.",
+  "organizationStart.accountKey.lockedTitle": "Sign in again",
+  "organizationStart.accountKey.lockedBody": "Conversation encryption is on for this account, but it is not open on this computer yet. Sign out and sign in again to continue.",
+  "organizationStart.accountKey.signInAgain": "Sign in again",
+  "organizationStart.diagnostic.reason.accountKey": "Conversation encryption is not on for this account yet.",
+  "organizationStart.diagnostic.action.accountKey": "Turn on conversation encryption in start-up preparation.",
+  "organizationStart.diagnostic.reason.accountKeyLocked": "This account's encryption key is not open on this computer yet.",
+  "organizationStart.diagnostic.action.accountKeyLocked": "Sign out and sign in again."
+};
+const organizationPcRegistrationEn = {
+  "organizationStart.diagnostic.reason.pcNotAssigned": "This PC is not assigned to this account as a dedicated PC in the selected organization.",
+  "organizationStart.diagnostic.action.pcNotAssigned": "Check that you selected the right organization. If so, ask an organization administrator to assign this PC to this account.",
+  "organizationStart.diagnostic.reason.pcReregister": "This PC's earlier registration can't be used anymore.",
+  "organizationStart.diagnostic.action.pcReregister": "Ask an organization administrator to register this PC again."
 };
 const organizationStartEn = {
   "organizationStart.toolsDetails": "Tool preparation details",
   "organizationStart.toolsProgress": "Tool preparation status",
   ...organizationInstallRecoveryEn,
+  ...organizationAccountKeyEn,
+  ...organizationPcRegistrationEn,
   "organizationStart.connectingTitle": "Connecting to your organization",
   "organizationStart.connectingBody": "Getting ready to work in {name}.",
   "organizationStart.welcome": "Start working with your organization",
@@ -55048,6 +55384,9 @@ const organizationStartEn = {
   "organizationStart.aiGroupConflict": "Your organization’s AI account settings need attention. Contact your organization administrator.",
   "organizationStart.aiChecking": "Connecting AI…",
   "organizationStart.connectLater": "Connect later",
+  "organizationStart.skip": "Skip",
+  "organizationStart.noAi.body": "{name} has no organization AI accounts yet. Skip this step and start with your own AI account.",
+  "organizationStart.noAi.status": "No organization AI accounts",
   "organizationStart.existingConnection": "Select Next to connect this PC to {name}.",
   "organizationStart.failed": "Onboarding setup",
   "organizationStart.recovery.title": "The app needs repair",
@@ -55154,7 +55493,32 @@ const organizationStartEn = {
   "organizationStart.diagnostic.reason.registrationChanged": "This PC's organization registration was changed or deleted, so it cannot connect with this account.",
   "organizationStart.diagnostic.action.registrationChanged": "Ask your organization administrator to check this PC's registration under Organization admin → PCs, then try again.",
   "organizationStart.diagnostic.reason.publicVerify": "Shared credentials were applied, but usable AI authentication was not confirmed.",
-  "organizationStart.diagnostic.action.publicVerify": "Ask your administrator to restore the latest shared credentials, then reconnect."
+  "organizationStart.diagnostic.action.publicVerify": "Ask your administrator to restore the latest shared credentials, then reconnect.",
+  "companyInvite.title": "Organization invitations",
+  "companyInvite.checkFailed": "Check organization invitations",
+  "companyInvite.body": "You have new organization invitations. Choose which organizations to join.",
+  "companyInvite.onboardingBody": "Review your organization invitations before choosing a work organization.",
+  "companyInvite.member": "Member",
+  "companyInvite.admin": "Admin",
+  "companyInvite.accept": "Accept",
+  "companyInvite.decline": "Decline",
+  "companyInvite.later": "Later",
+  "companyInvite.dismiss": "Close organization invitations",
+  "companyInvite.accepted": "You joined the organization.",
+  "companyInvite.declined": "Organization invitation declined.",
+  "companyInvite.failed": "We couldn't process the invitation. Try again later.",
+  "companyInvite.reauth": "Sign in again to apply the administrator role.",
+  "companyInvite.retry": "Check again",
+  "companyInvite.securityRequired": "Admin invitations need security verification. Check your security settings and verification on the web, then retry.",
+  "companyInvite.expiry": "Expires {date}",
+  "companyInvite.declineConfirm": "Confirm decline",
+  "companyInvite.declineBody": "Decline the invitation from {name}? Joining later requires a new invitation.",
+  "companyInvite.cancel": "Cancel",
+  "companyInvite.loading": "Checking invitations…",
+  "companyInvite.acceptLabel": "Accept invitation from {name}",
+  "companyInvite.declineLabel": "Decline invitation from {name}",
+  "companyInvite.declineConfirmLabel": "Confirm decline of invitation from {name}",
+  "companyInvite.refreshFailed": "Could not refresh invitations. Check again."
 };
 const usageEntryEn = {
   ...selfHostConnectEn,
@@ -55294,7 +55658,7 @@ const usageEntryEn = {
   "localTools.prerequisitesBody": "Check uv, Git and Node.js (including npm). Check again after installing.",
   "localTools.prerequisitesTitle": "Development prerequisites",
   "onboarding.preparationComplete": "Required setup complete",
-  "onboarding.additionalStepsBody": "Saycode instructions, AI accounts, notifications, and computer & browser control are optional. You can start now and configure them later.",
+  "onboarding.additionalStepsBody": "Saycode instructions, AI accounts, and notifications are optional. You can start now and configure them later.",
   "onboarding.additionalStep": "Additional step",
   "onboarding.requiredSettings": "Required setup",
   "onboarding.additionalSettings": "Additional setup — optional",
@@ -55377,6 +55741,11 @@ const projectRelocationEN = {
   "sessionCreation.workspaceNotSet": "This machine’s workspace path is not set. Please set the machine workspace first."
 };
 const chatSchedulesEn = {
+  "chatSchedules.chatTitle": "Schedules for this chat",
+  "chatSchedules.sharedHint": "These same tasks are also available in the schedules menu.",
+  "chatSchedules.allSchedules": "View all schedules",
+  "chatSchedules.advanced": "Advanced automation settings",
+  "chatSchedules.advancedHint": "Configure the AI, execution conditions and script automations. AI tasks are shared with the list above; script automations are a separate execution type.",
   "chatSchedules.olderReplies": "Earlier replies",
   "chatSchedules.newerReplies": "Newer replies",
   "chatSchedules.limitedReplies": "Showing part of this run. Open the conversation to read the full replies.",
@@ -55822,7 +56191,12 @@ const machineUsageEn = {
   "machineUsage.autoSwitched": "Automatically switched {provider}: {from} → {to}",
   "machineUsage.pinned": "pinned",
   "machineUsage.codexAccounts": "Codex accounts",
-  "machineUsage.usageStale": "refreshing usage"
+  "machineUsage.usageStale": "refreshing usage",
+  "machineUsage.autoRotation": "Auto account rotation",
+  "machineUsage.autoRotationOn": "Switches to another account when limits get close.",
+  "machineUsage.autoRotationOff": "Keeps using the selected account.",
+  "machineUsage.autoRotationPaused": "Auto rotation turned off because you picked an account.",
+  "machineUsage.autoRotationFailed": "Couldn't change auto rotation. Please try again."
 };
 const machineResourceMetricsEn = {
   "machineResourceMetrics.title": "Session machine CPU and memory",
@@ -56237,7 +56611,7 @@ const outboundWebhookEn = {
 };
 const messengerChannelsEn = {
   "settings.messengerChannels.title": "Messenger channels",
-  "settings.messengerChannels.privacyNotice": "Only the request's status and its final answer are sent to the connected messenger — never raw tool output, history, or attachments. Messenger transport is outside Saycode's end-to-end encryption.",
+  "settings.messengerChannels.privacyNotice": "The request's status and its final answer are sent to the connected messenger; on Slack, so are files the agent names in that answer from its project folder. Raw tool output and history are never sent. Messenger transport is outside Saycode's end-to-end encryption.",
   "settings.messengerChannels.alwaysOnTitle": "Keep channels connected after quitting",
   "settings.messengerChannels.alwaysOnHelp": "Receive messages and continue work after quitting Saycode. Your computer must be awake and connected to the internet.",
   "settings.messengerChannels.alwaysOnBlocked": "Not available: this device cannot store the bot credential securely, so nothing could receive once Desktop exits.",
@@ -56395,7 +56769,7 @@ const messengerQuickSetupEn = {
   "settings.messengerChannels.quickSlack.openInSlack": "Open in Slack",
   "settings.messengerChannels.quickSlack.waiting": "Once you send it in Slack, the connection request appears here. Allow it and you are done.",
   "settings.messengerChannels.quickSlack.pairedWith": "Connected to {name}'s Slack",
-  "settings.messengerChannels.quickSlack.connectedHelp": "Just talk to the bot in the DM you sent the code from. Mention the bot and send /help to see commands.",
+  "settings.messengerChannels.quickSlack.connectedHelp": "Just talk to the bot in the DM you sent the code from. In a channel you invited the bot to, mention it and it answers in a thread under your message (visible to channel members). Mention the bot and send /help to see commands.",
   "settings.messengerChannels.quickDiscord.title": "Connect Discord",
   "settings.messengerChannels.quickDiscord.subtitle": "Hand work to Saycode from Discord. Two steps and you are done.",
   "settings.messengerChannels.quickDiscord.installTitle": "Discord is not turned on yet",
@@ -56700,6 +57074,9 @@ const extensionPanelEn = {
 const extensionInstallEn = {
   "extensions.installOfficial": "Install extension",
   "extensions.installNamedOfficial": "Install {name}",
+  "extensions.officialUpdate": "Update to {version}",
+  "extensions.updateSaved": "The new version was installed, but finishing it could not be confirmed. Check the extension again.",
+  "extensions.projectToolHint": "Open it from the More (⋮) menu of the right work area in a project conversation: {tools}",
   "extensions.officialName.artifactPublisher": "Public link extension",
   "extensions.officialName.pluginManager": "Plugin manager extension",
   "extensions.officialName.projectTemplates": "Project templates extension",
@@ -56728,25 +57105,26 @@ const extensionInstallEn = {
   "artifactPublication.error.network": "Could not reach the server. Check your network connection.",
   "artifactPublication.error.unauthenticated": "Your session expired. Sign in again and retry.",
   "artifactPublication.error.notFound": "The file was not found. Make sure it has been saved.",
+  "artifactPublication.error.notFoundInFolder": "{file} was not found in the working folder {folder}. If it was created in another worktree, move it into this folder and try again.",
   "artifactPublication.error.tooLarge": "The file is too large. A published HTML file must be 10MB or smaller.",
   "artifactPublication.error.rateLimited": "Too many public link requests. Please try again in a moment.",
   "artifactPublication.error.rejected": "The server rejected the request to publish this file.",
   "artifactPublication.error.serverError": "The server hit an error. Please try again in a moment.",
   "artifactPublication.error.extensionUnavailable": "The extension is disabled or missing the publish permission. Check Artifact Publisher in settings.",
-  "artifactPublication.error.invalidResponse": "The server response could not be verified, so the action stopped."
+  "artifactPublication.error.invalidResponse": "The server response could not be verified, so the action stopped.",
+  "extensions.permission.filePreviewsRead": "Read preview content of files opened in the app. Saycode Core keeps source paths and credentials private."
 };
 const artifactLibraryTranslations$2 = {
   "artifactLibrary.title": "Artifacts",
   "artifactLibrary.scope": "Scope",
   "artifactLibrary.conversation": "This conversation",
   "artifactLibrary.project": "This project",
-  "artifactLibrary.all": "All projects",
   "artifactLibrary.search": "Search files, projects, conversations and paths",
-  "artifactLibrary.hint": "Documents and previews from conversations. Opens the original file.",
   "artifactLibrary.loading": "Finding artifacts…",
   "artifactLibrary.error": "Some conversations could not be loaded. Please retry.",
   "artifactLibrary.empty": "No artifacts yet.",
   "artifactLibrary.noMatches": "No matching artifacts.",
+  "artifactLibrary.readUnsupported": "This PC does not support opening original work files. This feature currently supports macOS work PCs.",
   "artifactLibrary.retry": "Retry"
 };
 const personalChatsLandingEn = {
@@ -57610,9 +57988,15 @@ const sidebarUpdateEn = {
   "sidebarUpdate.completedBody": "Saycode v{version} has been updated.",
   "sidebarUpdate.installing": "Applying update…",
   "sidebarUpdate.update": "Update",
-  "sidebarUpdate.restartNotice": "Your sessions are saved before restarting.",
+  "sidebarUpdate.restartNotice": "Your sessions are saved before restarting. Saycode reopens on its own when the install finishes.",
   "sidebarUpdate.minimize": "Minimize",
-  "sidebarUpdate.releaseNotes": "Release notes"
+  "sidebarUpdate.releaseNotes": "Release notes",
+  "sidebarUpdate.relaunchWaitTitle": "Installing the update",
+  "sidebarUpdate.relaunchWaitBody": "Saycode v{version} opens on its own when the install finishes. Closing this window does not stop the install.",
+  "sidebarUpdate.relaunchTimeoutTitle": "The update did not finish installing",
+  "sidebarUpdate.relaunchTimeoutBody": "You can open the current version (v{version}) and get the update again from the app.",
+  "sidebarUpdate.relaunchOpenCurrent": "Open current version",
+  "sidebarUpdate.relaunchQuit": "Quit"
 };
 const globalPauseEn = {
   "settings.globalPause.enable": "Global pause (block new automatic actions)",
@@ -58937,7 +59321,6 @@ const onboardingEn = {
   "onboarding.page.addProject": "Add your first project",
   "onboarding.page.configured": "Configured",
   "onboarding.page.optional": "Optional",
-  "onboarding.page.computerReveal": "Internal test: show computer and browser control",
   "onboarding.page.testNotification": "Send test notification",
   "onboarding.page.testNotificationSending": "Sending test notification…",
   "onboarding.page.testNotificationSuccess": "Test notification sent.",
@@ -59112,6 +59495,7 @@ const en = {
   "aiModelPolicy.machineChanged": "Chat creation stopped because the selected PC is unavailable. Check the PC before sending again.",
   "aiModelPolicy.policyChanged": "Chat creation stopped because the allowed model policy changed. Review your question and attachments before sending again.",
   "aiModelPolicy.noModels": "No allowed models are available on this computer.",
+  ...personalAiEn,
   ...conversationTabsEn,
   ...questionComposerEn,
   ...aiRecoveryEn,
@@ -61369,6 +61753,9 @@ const en = {
   "projectGitView.branchRename": "Rename branch",
   "projectGitView.branchDelete": "Delete branch",
   "terminal.connectTimeout": "Terminal connection timed out.",
+  "terminal.strictMachineUnsupported": "Remote terminals are not available yet on machines in strict machine control. Use a terminal on the machine itself.",
+  "terminal.machineControlUnknown": "This machine's CLI does not report its security mode, so a remote terminal cannot be opened. Update the happy CLI on the machine.",
+  "terminal.machineKeyUnavailable": "This machine's key is not available, so the remote terminal was not opened. Unlock your account key and try again.",
   "terminal.connectFailed": "Failed to connect to the terminal.",
   "terminal.cwdPrepFailed": "Failed to prepare the remote terminal working directory.",
   "terminal.restoredOutputDivider": "Previous session output",
@@ -61870,6 +62257,52 @@ const conversationTabsZh = {
   "workspaceHost.closeConversationHint": "仅关闭标签页，对话记录会保留。",
   "workspaceHost.newConversation": "打开新对话"
 };
+const personalAiZh = {
+  "aiConnection.sectionTitle": "查看已连接的AI",
+  "aiConnection.ai": "AI",
+  "aiConnection.pc": "PC",
+  "aiConnection.selectPc": "选择PC",
+  "aiConnection.pcUnknown": "无法确认",
+  "aiConnection.selectAi": "选择AI",
+  "aiConnection.chooseAiHint": "选择AI后，即可查看此PC的连接状态。",
+  "personalAi.settingsTitle": "我的AI账号",
+  "personalAi.settingsDescription": "连接您正在使用的ChatGPT或Claude账号。",
+  "personalAi.title": "连接个人AI账号",
+  "personalAi.imageAlt": "网页账号连接到桌面对话界面的示意图",
+  "personalAi.intro": "连接ChatGPT或Claude账号，\n即可在SayCode中与AI对话。",
+  "personalAi.note": "请使用您正在使用的AI账号登录。",
+  "personalAi.later": "以后再说",
+  "personalAi.connect": "连接我的AI账号",
+  "personalAi.choose": "请选择要连接的AI",
+  "personalAi.chooseDescription": "在所选服务的网站上登录。",
+  "personalAi.withProvider": "使用{provider}账号连接",
+  "personalAi.back": "返回",
+  "personalAi.providerTitle": "连接{provider}账号",
+  "personalAi.waiting": "请在浏览器中完成登录。",
+  "personalAi.approval": "完成登录并授权连接后，\n将自动确认连接状态。",
+  "personalAi.cancel": "取消",
+  "personalAi.reopen": "重新打开浏览器",
+  "personalAi.expired": "暂时无法确认连接。",
+  "personalAi.retryDescription": "请重新连接并在浏览器中\n完成登录。",
+  "personalAi.retry": "重新连接",
+  "personalAi.connected": "已连接{provider}账号。",
+  "personalAi.ready": "已准备好在此电脑上使用。",
+  "personalAi.done": "完成",
+  "personalAi.localOnly": "个人AI账号只能在此电脑上连接。请选择此电脑作为工作电脑后再连接。",
+  "personalAi.unavailable": "请检查此电脑的连接和AI工具安装情况，然后重新打开。",
+  "aiConnection.loginLinkFailed": "无法打开登录链接。请在显示终端中直接点击链接。",
+  "aiConnection.openLoginLink": "打开登录链接",
+  "aiConnection.loginPreparing": "正在准备登录…",
+  "aiConnection.codeLabel": "请粘贴在浏览器登录后显示的验证码。",
+  "aiConnection.codeSend": "发送验证码",
+  "aiConnection.loginFailed": "登录失败。请检查验证码后重试。",
+  "aiConnection.loginRetry": "重试",
+  "aiConnection.loginTerminalFailed": "无法打开登录终端。请在下方终端中重新打开。",
+  "aiConnection.loginTerminalClosed": "登录终端已关闭。请在下方终端中重新打开。",
+  "aiConnection.loginLinkSlow": "登录链接尚未出现。请在下方终端中查看进度。",
+  "aiConnection.codeSent": "验证码已发送。登录完成后请点击登录完成。",
+  "aiConnection.showTerminal": "显示终端"
+};
 const questionComposerZh = {
   "askUser.skip": "跳过",
   "askUser.skipAnswer": "用户跳过了这个问题的回答。",
@@ -62091,6 +62524,12 @@ const projectSettingsZh = {
   "projectSettings.diagnostics": "开发信息"
 };
 const aiRecoveryZh = {
+  "aiRecovery.capacityTitle": "模型繁忙重试",
+  "aiRecovery.capacitySummary": "当前请求较多。请稍后重试。",
+  "aiRecovery.capacityCountdown": "{seconds}秒后重试 ({attempt}/3)",
+  "aiRecovery.capacityCancel": "取消",
+  "aiRecovery.capacityExhausted": "自动重试已结束。请稍后重试或在输入框中更换模型。",
+  "aiRecovery.capacityModelHint": "可以在输入框中选择其他模型。",
   "aiRecovery.modelUnsupported": "当前 AI 无法使用所选模型。请在输入框中更换模型后重试。",
   "aiRecovery.accessSummary": "此账号无法使用Claude。",
   "aiRecovery.connectAccount": "重新连接AI",
@@ -62208,6 +62647,8 @@ const managedClaudeZh = {
   "managedClaude.loading": "正在连接AI…"
 };
 const workZh = {
+  "work.mediaChanged": "原文件已更改。请重新打开。",
+  "work.mediaUnsupported": "此计算机不支持媒体流式播放。请保存原文件并在本地打开。",
   "work.homeTitle": "需要我帮您完成什么工作？",
   "work.new": "开始新chat",
   "work.archived": "已归档chat",
@@ -62263,7 +62704,8 @@ const workZh = {
   "work.sourceNotice.denied": "您无权访问此文件。请检查权限。",
   "work.sourceNotice.unavailable": "无法检查文件。请重试。",
   "work.saveCheck": "检查保存的副本",
-  "work.checkingFile": "检查中…"
+  "work.checkingFile": "检查中…",
+  "work.mediaViewerNeeded": "请安装媒体预览扩展，并允许其读取所选文件。"
 };
 const FILE_ACCESS_TRANSLATIONS_ZH = {
   "fileAccess.retry": "重试",
@@ -62339,6 +62781,8 @@ const organizationInstallRecoveryZh = {
   "organizationStart.toolDiagnostic.reason.TOOL_EXECUTION_FAILED": "无法运行文件或检查版本。",
   "organizationStart.toolDiagnostic.reason.TOOL_INSTALL_FAILED": "工具准备失败，具体原因尚未确认。",
   "organizationStart.toolDiagnostic.reason.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "已安装的 cswap 不支持所需认证功能。",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_AUTH_REQUIRED": "公司代理要求登录认证，因此无法连接。",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_BLOCKED": "公司代理不允许连接下载或软件包服务器。",
   "organizationStart.toolDiagnostic.action.TOOL_NOT_FOUND": "请重试，或按指南安装后再次检查。",
   "organizationStart.toolDiagnostic.action.TOOL_PREREQUISITE_REQUIRED": "请先准备所列前置工具，然后重试。",
   "organizationStart.toolDiagnostic.action.TOOL_NETWORK_FAILED": "请检查互联网、公司网络和代理，然后重试。",
@@ -62351,12 +62795,55 @@ const organizationInstallRecoveryZh = {
   "organizationStart.toolDiagnostic.action.TOOL_TIMEOUT": "请检查网络后重试；若重复发生，请提供诊断。",
   "organizationStart.toolDiagnostic.action.TOOL_EXECUTION_FAILED": "请检查安装完整性及公司策略是否允许执行。",
   "organizationStart.toolDiagnostic.action.TOOL_INSTALL_FAILED": "请重试；若重复发生，请提供此诊断。",
-  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "请重试以安装 Saycode 使用的认证工具。"
+  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "请重试以安装 Saycode 使用的认证工具。",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_AUTH_REQUIRED": "请将此诊断提供给 IT，请求将下载服务器设为代理认证例外。",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_BLOCKED": "请将此诊断提供给 IT，请求允许访问下载服务器。"
+};
+const organizationAccountKeyZh = {
+  "organizationStart.accountKey.title": "开启对话加密",
+  "organizationStart.accountKey.body": "要在这台电脑上使用组织 AI，请先开启对话加密。将使用当前密码创建此账号的加密密钥。",
+  "organizationStart.accountKey.row": "对话加密",
+  "organizationStart.accountKey.passwordLabel": "当前密码",
+  "organizationStart.accountKey.checking": "正在验证密码…",
+  "organizationStart.accountKey.recoveryTitle": "请保管好恢复密钥",
+  "organizationStart.accountKey.recoveryNotice": "忘记密码时可用它打开对话。如果密码和恢复密钥都丢失，将无法打开已加密的对话。关闭此页面后将无法再次查看恢复密钥。",
+  "organizationStart.accountKey.copy": "复制",
+  "organizationStart.accountKey.copied": "已复制恢复密钥。",
+  "organizationStart.accountKey.save": "保存为文件",
+  "organizationStart.accountKey.saved": "已保存恢复密钥。",
+  "organizationStart.accountKey.confirmLabel": "再次输入恢复密钥",
+  "organizationStart.accountKey.confirmMismatch": "输入的恢复密钥与上方的不一致。",
+  "organizationStart.accountKey.enable": "开启对话加密",
+  "organizationStart.accountKey.saving": "正在开启…",
+  "organizationStart.accountKey.renewBody": "验证已超时，请再确认一次密码。已保管的恢复密钥保持不变。",
+  "organizationStart.accountKey.renew": "重新验证",
+  "organizationStart.accountKey.error.wrong-password": "当前密码不正确。",
+  "organizationStart.accountKey.error.rate-limited": "尝试次数过多，请稍后再试。",
+  "organizationStart.accountKey.error.already-enabled": "此账号已开启对话加密。请退出登录后重新登录。",
+  "organizationStart.accountKey.error.signed-out": "登录已过期。请退出登录后重新登录。",
+  "organizationStart.accountKey.error.expired": "验证已超时，请重新输入密码。",
+  "organizationStart.accountKey.error.failed": "未能开启对话加密，请稍后再试。",
+  "organizationStart.accountKey.error.recovery-mismatch": "输入的恢复密钥与上方的不一致。",
+  "organizationStart.accountKey.lockedTitle": "请重新登录",
+  "organizationStart.accountKey.lockedBody": "此账号已开启对话加密，但在这台电脑上尚未打开。退出登录后重新登录即可继续。",
+  "organizationStart.accountKey.signInAgain": "重新登录",
+  "organizationStart.diagnostic.reason.accountKey": "此账号尚未开启对话加密。",
+  "organizationStart.diagnostic.action.accountKey": "请在启动准备中开启对话加密。",
+  "organizationStart.diagnostic.reason.accountKeyLocked": "这台电脑上尚未打开账号加密密钥。",
+  "organizationStart.diagnostic.action.accountKeyLocked": "请退出登录后重新登录。"
+};
+const organizationPcRegistrationZh = {
+  "organizationStart.diagnostic.reason.pcNotAssigned": "这台电脑在所选组织中未被分配为此账号的专用电脑。",
+  "organizationStart.diagnostic.action.pcNotAssigned": "请确认所选组织是否正确；若正确，请联系组织管理员将这台电脑分配为此账号的专用电脑。",
+  "organizationStart.diagnostic.reason.pcReregister": "无法继续使用这台电脑之前的注册信息。",
+  "organizationStart.diagnostic.action.pcReregister": "请联系组织管理员重新注册这台电脑。"
 };
 const organizationStartZh = {
   "organizationStart.toolsDetails": "工具准备详情",
   "organizationStart.toolsProgress": "工具准备状态",
   ...organizationInstallRecoveryZh,
+  ...organizationAccountKeyZh,
+  ...organizationPcRegistrationZh,
   "organizationStart.connectingTitle": "正在连接组织",
   "organizationStart.connectingBody": "正在准备进入{name}开展工作。",
   "organizationStart.welcome": "立即在组织中开始",
@@ -62384,6 +62871,9 @@ const organizationStartZh = {
   "organizationStart.aiGroupConflict": "需要检查组织的AI账号设置。请联系组织管理员。",
   "organizationStart.aiChecking": "正在连接AI…",
   "organizationStart.connectLater": "稍后连接",
+  "organizationStart.skip": "跳过",
+  "organizationStart.noAi.body": "{name} 尚未注册组织 AI 账号。可以跳过此步骤，使用自己的 AI 账号开始。",
+  "organizationStart.noAi.status": "没有组织 AI 账号",
   "organizationStart.existingConnection": "要将此电脑连接到{name}，请点击“下一步”。",
   "organizationStart.failed": "入门准备",
   "organizationStart.recovery.title": "需要修复应用",
@@ -62490,7 +62980,32 @@ const organizationStartZh = {
   "organizationStart.diagnostic.reason.registrationChanged": "此电脑的组织登记已被更改或删除，无法用此账号连接。",
   "organizationStart.diagnostic.action.registrationChanged": "请联系组织管理员在 组织管理 → 电脑 中检查此电脑的登记，然后重试。",
   "organizationStart.diagnostic.reason.publicVerify": "共享认证已应用，但未能确认 AI 认证可用。",
-  "organizationStart.diagnostic.action.publicVerify": "请组织管理员恢复最新共享认证，然后重新连接。"
+  "organizationStart.diagnostic.action.publicVerify": "请组织管理员恢复最新共享认证，然后重新连接。",
+  "companyInvite.title": "组织邀请",
+  "companyInvite.checkFailed": "需要检查组织邀请",
+  "companyInvite.body": "您收到了新的组织邀请。请选择要加入的组织。",
+  "companyInvite.onboardingBody": "选择工作组织前，请先查看收到的组织邀请。",
+  "companyInvite.member": "成员",
+  "companyInvite.admin": "管理员",
+  "companyInvite.accept": "接受",
+  "companyInvite.decline": "拒绝",
+  "companyInvite.later": "稍后",
+  "companyInvite.dismiss": "关闭组织邀请",
+  "companyInvite.accepted": "您已加入组织。",
+  "companyInvite.declined": "已拒绝组织邀请。",
+  "companyInvite.failed": "无法处理此邀请，请稍后重试。",
+  "companyInvite.reauth": "请重新登录以应用管理员权限。",
+  "companyInvite.retry": "重新检查",
+  "companyInvite.securityRequired": "管理员邀请需要安全验证。请在网页检查安全设置和验证后重试。",
+  "companyInvite.expiry": "到期：{date}",
+  "companyInvite.declineConfirm": "确认拒绝",
+  "companyInvite.declineBody": "拒绝{name}的邀请？之后加入需要新的邀请。",
+  "companyInvite.cancel": "取消",
+  "companyInvite.loading": "正在检查邀请…",
+  "companyInvite.acceptLabel": "接受{name}的邀请",
+  "companyInvite.declineLabel": "拒绝{name}的邀请",
+  "companyInvite.declineConfirmLabel": "确认拒绝{name}的邀请",
+  "companyInvite.refreshFailed": "无法刷新邀请，请重新检查。"
 };
 const usageEntryZh = {
   ...selfHostConnectZh,
@@ -62630,7 +63145,7 @@ const usageEntryZh = {
   "localTools.prerequisitesBody": "检查 uv、Git 和 Node.js（含 npm）的安装状态。安装后请重新检查。",
   "localTools.prerequisitesTitle": "基本开发工具",
   "onboarding.preparationComplete": "必需设置完成",
-  "onboarding.additionalStepsBody": "Saycode 指令、AI 账户、通知以及电脑与浏览器控制均为可选步骤。您可以立即开始，稍后再设置。",
+  "onboarding.additionalStepsBody": "Saycode 指令、AI 账户和通知均为可选步骤。您可以立即开始，稍后再设置。",
   "onboarding.additionalStep": "附加步骤",
   "onboarding.requiredSettings": "必需设置",
   "onboarding.additionalSettings": "附加设置 — 可选",
@@ -62713,6 +63228,11 @@ const projectRelocationZH = {
   "sessionCreation.workspaceNotSet": "此机器的工作区路径尚未设置。请先设置机器工作区。"
 };
 const chatSchedulesZh = {
+  "chatSchedules.chatTitle": "此对话的预约",
+  "chatSchedules.sharedHint": "您也可以在预约菜单中查看和管理相同的预约。",
+  "chatSchedules.allSchedules": "查看所有预约",
+  "chatSchedules.advanced": "高级自动化设置",
+  "chatSchedules.advancedHint": "设置 AI、执行条件和脚本自动化。AI 预约与上方列表共享，脚本自动化是另一种执行类型。",
   "chatSchedules.olderReplies": "较早的回答",
   "chatSchedules.newerReplies": "较新的回答",
   "chatSchedules.limitedReplies": "当前仅显示本次运行的部分回答。请打开对话查看完整回答。",
@@ -63158,7 +63678,12 @@ const machineUsageZh = {
   "machineUsage.autoSwitched": "已自动切换 {provider}：{from} → {to}",
   "machineUsage.pinned": "已固定",
   "machineUsage.codexAccounts": "Codex 账户",
-  "machineUsage.usageStale": "正在刷新用量"
+  "machineUsage.usageStale": "正在刷新用量",
+  "machineUsage.autoRotation": "自动轮换账户",
+  "machineUsage.autoRotationOn": "接近限额时自动切换到其他账户。",
+  "machineUsage.autoRotationOff": "继续使用所选账户。",
+  "machineUsage.autoRotationPaused": "你手动选择了账户，已关闭自动轮换。",
+  "machineUsage.autoRotationFailed": "无法更改自动轮换，请重试。"
 };
 const machineResourceMetricsZh = {
   "machineResourceMetrics.title": "会话机器的 CPU/内存",
@@ -63573,7 +64098,7 @@ const outboundWebhookZh = {
 };
 const messengerChannelsZh = {
   "settings.messengerChannels.title": "即时通讯渠道",
-  "settings.messengerChannels.privacyNotice": "仅会将请求的状态和最终答复发送到已连接的即时通讯工具 — 绝不发送原始工具输出、历史记录或附件。即时通讯传输不在 Saycode 端到端加密范围内。",
+  "settings.messengerChannels.privacyNotice": "会将请求的状态和最终答复发送到已连接的即时通讯工具；在 Slack 中，还会发送代理在该答复中指定的项目文件夹内的文件。绝不发送原始工具输出或历史记录。即时通讯传输不在 Saycode 端到端加密范围内。",
   "settings.messengerChannels.alwaysOnTitle": "退出应用后保持连接",
   "settings.messengerChannels.alwaysOnHelp": "退出 Saycode 后仍可接收消息并继续工作。电脑必须保持唤醒并连接互联网。",
   "settings.messengerChannels.alwaysOnBlocked": "不可用：此设备无法安全存储机器人凭据，因此 Desktop 退出后将无法接收。",
@@ -63731,7 +64256,7 @@ const messengerQuickSetupZh = {
   "settings.messengerChannels.quickSlack.openInSlack": "在 Slack 中打开",
   "settings.messengerChannels.quickSlack.waiting": "在 Slack 中发送后，连接请求会显示在这里。允许即可完成。",
   "settings.messengerChannels.quickSlack.pairedWith": "已连接 {name} 的 Slack",
-  "settings.messengerChannels.quickSlack.connectedHelp": "在发送连接码的私信中直接和机器人对话即可。提及机器人后发送 /help 可查看命令。",
+  "settings.messengerChannels.quickSlack.connectedHelp": "在发送连接码的私信中直接和机器人对话即可。在已邀请机器人的频道中提及它，它会在该消息的话题中回复（频道成员可见）。提及机器人后发送 /help 可查看命令。",
   "settings.messengerChannels.quickDiscord.title": "连接 Discord",
   "settings.messengerChannels.quickDiscord.subtitle": "在 Discord 中直接把工作交给 Saycode。两步即可完成。",
   "settings.messengerChannels.quickDiscord.installTitle": "Discord 功能尚未开启",
@@ -64036,6 +64561,9 @@ const extensionPanelZh = {
 const extensionInstallZh = {
   "extensions.installOfficial": "安装扩展",
   "extensions.installNamedOfficial": "安装 {name}",
+  "extensions.officialUpdate": "官方更新到 {version}",
+  "extensions.updateSaved": "新版本已安装，但无法确认后续处理已完成。请重新检查扩展状态。",
+  "extensions.projectToolHint": "在项目对话右侧工作面板的更多(⋮)菜单中打开：{tools}",
   "extensions.officialName.artifactPublisher": "公开链接扩展",
   "extensions.officialName.pluginManager": "插件管理扩展",
   "extensions.officialName.projectTemplates": "项目模板扩展",
@@ -64064,25 +64592,26 @@ const extensionInstallZh = {
   "artifactPublication.error.network": "无法连接服务器。请检查网络连接。",
   "artifactPublication.error.unauthenticated": "登录会话已过期。请重新登录后再试。",
   "artifactPublication.error.notFound": "找不到文件。请确认文件已保存。",
+  "artifactPublication.error.notFoundInFolder": "在工作文件夹 {folder} 中找不到 {file}。如果文件是在其他 worktree 中创建的，请将其移到此文件夹后重试。",
   "artifactPublication.error.tooLarge": "文件过大。公开的 HTML 文件必须小于等于 10MB。",
   "artifactPublication.error.rateLimited": "公开链接请求过多。请稍后重试。",
   "artifactPublication.error.rejected": "服务器拒绝了此文件的公开请求。",
   "artifactPublication.error.serverError": "服务器发生错误。请稍后重试。",
   "artifactPublication.error.extensionUnavailable": "扩展已禁用或缺少公开权限。请在设置中检查 Artifact Publisher。",
-  "artifactPublication.error.invalidResponse": "无法校验服务器响应，已中止。"
+  "artifactPublication.error.invalidResponse": "无法校验服务器响应，已中止。",
+  "extensions.permission.filePreviewsRead": "读取在应用中打开的文件的预览内容。源路径和凭据由 Saycode Core 管理。"
 };
 const artifactLibraryTranslations$1 = {
   "artifactLibrary.title": "成果汇总",
   "artifactLibrary.scope": "范围",
   "artifactLibrary.conversation": "当前对话",
   "artifactLibrary.project": "当前项目",
-  "artifactLibrary.all": "所有项目",
   "artifactLibrary.search": "搜索文件、项目、对话和路径",
-  "artifactLibrary.hint": "汇总对话中的文档和预览。打开原始文件。",
   "artifactLibrary.loading": "正在查找成果…",
   "artifactLibrary.error": "部分对话加载失败。请重试。",
   "artifactLibrary.empty": "暂无成果。",
   "artifactLibrary.noMatches": "没有匹配的成果。",
+  "artifactLibrary.readUnsupported": "此电脑不支持打开工作成果原文件。目前此功能支持 macOS 工作电脑。",
   "artifactLibrary.retry": "重试"
 };
 const personalChatsLandingZh = {
@@ -64946,9 +65475,15 @@ const sidebarUpdateZh = {
   "sidebarUpdate.completedBody": "Saycode 已更新至 v{version}。",
   "sidebarUpdate.installing": "正在应用更新…",
   "sidebarUpdate.update": "更新",
-  "sidebarUpdate.restartNotice": "重启前将保存对话状态。",
+  "sidebarUpdate.restartNotice": "重启前将保存对话状态。安装完成后 Saycode 会自动重新打开。",
   "sidebarUpdate.minimize": "最小化",
-  "sidebarUpdate.releaseNotes": "Release notes"
+  "sidebarUpdate.releaseNotes": "Release notes",
+  "sidebarUpdate.relaunchWaitTitle": "正在安装更新",
+  "sidebarUpdate.relaunchWaitBody": "安装完成后 Saycode v{version} 会自动打开。关闭此窗口不会中断安装。",
+  "sidebarUpdate.relaunchTimeoutTitle": "更新未能完成安装",
+  "sidebarUpdate.relaunchTimeoutBody": "可以用当前版本 (v{version}) 打开，并在应用中重新获取更新。",
+  "sidebarUpdate.relaunchOpenCurrent": "用当前版本打开",
+  "sidebarUpdate.relaunchQuit": "退出"
 };
 const globalPauseZh = {
   "settings.globalPause.enable": "全局暂停（阻止新的自动操作）",
@@ -66273,7 +66808,6 @@ const onboardingZh = {
   "onboarding.page.addProject": "添加第一个项目",
   "onboarding.page.configured": "已设置",
   "onboarding.page.optional": "可选",
-  "onboarding.page.computerReveal": "内部测试：显示电脑和浏览器控制",
   "onboarding.page.testNotification": "发送测试通知",
   "onboarding.page.testNotificationSending": "正在发送测试通知…",
   "onboarding.page.testNotificationSuccess": "测试通知已发送。",
@@ -66448,6 +66982,7 @@ const zh = {
   "aiModelPolicy.machineChanged": "所选电脑不可用，已停止创建对话。请检查电脑后重新发送。",
   "aiModelPolicy.policyChanged": "允许模型的策略已更改，已停止创建对话。请检查问题和附件后重新发送。",
   "aiModelPolicy.noModels": "此计算机没有可选择的获准模型。",
+  ...personalAiZh,
   ...conversationTabsZh,
   ...questionComposerZh,
   ...aiRecoveryZh,
@@ -68672,6 +69207,9 @@ const zh = {
   "projectGitView.branchRename": "重命名分支",
   "projectGitView.branchDelete": "删除分支",
   "terminal.connectTimeout": "终端连接超时。",
+  "terminal.strictMachineUnsupported": "安全强化(strict)机器暂不支持远程终端。请直接在该机器上使用终端。",
+  "terminal.machineControlUnknown": "该机器的 CLI 未报告其安全模式，因此无法打开远程终端。请在该机器上更新 happy CLI。",
+  "terminal.machineKeyUnavailable": "无法打开该机器的密钥，因此未打开远程终端。请解锁账户密钥后重试。",
   "terminal.connectFailed": "无法连接到终端。",
   "terminal.cwdPrepFailed": "无法准备远程终端的工作目录。",
   "terminal.restoredOutputDivider": "上一次会话输出",
@@ -69206,6 +69744,52 @@ const conversationTabsJa = {
   "workspaceHost.closeConversationHint": "タブだけを閉じます。会話の履歴は残ります。",
   "workspaceHost.newConversation": "新しい会話を開く"
 };
+const personalAiJa = {
+  "aiConnection.sectionTitle": "接続済みAIを確認",
+  "aiConnection.ai": "AI",
+  "aiConnection.pc": "PC",
+  "aiConnection.selectPc": "PCを選択",
+  "aiConnection.pcUnknown": "確認できません",
+  "aiConnection.selectAi": "AIを選択",
+  "aiConnection.chooseAiHint": "AIを選ぶと、このPCの接続状態を確認できます。",
+  "personalAi.settingsTitle": "自分のAIアカウント",
+  "personalAi.settingsDescription": "お使いのChatGPTまたはClaudeのアカウントを接続してください。",
+  "personalAi.title": "個人AIアカウントを接続",
+  "personalAi.imageAlt": "Webアカウントとデスクトップの会話画面を接続する図",
+  "personalAi.intro": "ChatGPTまたはClaudeのアカウントを接続して\nSayCodeでAIと会話できます。",
+  "personalAi.note": "お使いのAIアカウントでログインしてください。",
+  "personalAi.later": "あとで",
+  "personalAi.connect": "自分のAIアカウントを接続",
+  "personalAi.choose": "接続するAIを選んでください",
+  "personalAi.chooseDescription": "選んだサービスのWebサイトでログインします。",
+  "personalAi.withProvider": "{provider}で接続",
+  "personalAi.back": "戻る",
+  "personalAi.providerTitle": "{provider}アカウントを接続",
+  "personalAi.waiting": "ブラウザでログインを完了してください。",
+  "personalAi.approval": "ログインと接続の承認が完了すると\n接続状態を自動で確認します。",
+  "personalAi.cancel": "キャンセル",
+  "personalAi.reopen": "ブラウザを再度開く",
+  "personalAi.expired": "接続をまだ確認できませんでした。",
+  "personalAi.retryDescription": "再接続してブラウザで\nログインを完了してください。",
+  "personalAi.retry": "再接続",
+  "personalAi.connected": "{provider}アカウントを接続しました。",
+  "personalAi.ready": "このコンピューターで使用できます。",
+  "personalAi.done": "完了",
+  "personalAi.localOnly": "個人AIアカウントはこのコンピューターで接続できます。作業PCにこのコンピューターを選んでから再接続してください。",
+  "personalAi.unavailable": "このコンピューターの接続とAIツールのインストールを確認して、再度開いてください。",
+  "aiConnection.loginLinkFailed": "ログインリンクを開けませんでした。ターミナルを表示してリンクを直接選択してください。",
+  "aiConnection.openLoginLink": "ログインリンクを開く",
+  "aiConnection.loginPreparing": "ログインを準備しています…",
+  "aiConnection.codeLabel": "ブラウザでログインした後に表示される認証コードを貼り付けてください。",
+  "aiConnection.codeSend": "コードを送信",
+  "aiConnection.loginFailed": "ログインできませんでした。認証コードを確認して、もう一度お試しください。",
+  "aiConnection.loginRetry": "再試行",
+  "aiConnection.loginTerminalFailed": "ログイン用ターミナルを開けませんでした。下のターミナルから開き直してください。",
+  "aiConnection.loginTerminalClosed": "ログイン用ターミナルが閉じました。下のターミナルから開き直してください。",
+  "aiConnection.loginLinkSlow": "ログインリンクがまだ表示されていません。下のターミナルで進行状況を確認してください。",
+  "aiConnection.codeSent": "認証コードを送信しました。ログインが終わったらログイン完了を押してください。",
+  "aiConnection.showTerminal": "ターミナルを表示"
+};
 const questionComposerJa = {
   "askUser.skip": "スキップ",
   "askUser.skipAnswer": "ユーザーはこの質問への回答をスキップしました。",
@@ -69427,6 +70011,12 @@ const projectSettingsJa = {
   "projectSettings.diagnostics": "開発情報"
 };
 const aiRecoveryJa = {
+  "aiRecovery.capacityTitle": "モデル混雑時の再試行",
+  "aiRecovery.capacitySummary": "現在リクエストが集中しています。しばらくしてからもう一度お試しください。",
+  "aiRecovery.capacityCountdown": "{seconds}秒後に再試行 ({attempt}/3)",
+  "aiRecovery.capacityCancel": "キャンセル",
+  "aiRecovery.capacityExhausted": "自動再試行が終了しました。後でもう一度試すか、入力欄でモデルを変更してください。",
+  "aiRecovery.capacityModelHint": "入力欄で別のモデルに変更できます。",
   "aiRecovery.modelUnsupported": "このAIでは選択したモデルを使用できません。入力欄でモデルを変更してから再試行してください。",
   "aiRecovery.accessSummary": "このアカウントではClaudeを使用できません。",
   "aiRecovery.connectAccount": "AIに再接続",
@@ -69544,6 +70134,8 @@ const managedClaudeJa = {
   "managedClaude.loading": "AIに接続中…"
 };
 const workJa = {
+  "work.mediaChanged": "元のファイルが変更されました。もう一度開いてください。",
+  "work.mediaUnsupported": "このコンピューターではメディアストリーミングを利用できません。元のファイルを保存して開いてください。",
   "work.homeTitle": "どんな作業をお手伝いしましょうか？",
   "work.new": "新しいchatを開始",
   "work.archived": "アーカイブ済みのchat",
@@ -69599,7 +70191,8 @@ const workJa = {
   "work.sourceNotice.denied": "ファイルへのアクセス権がありません。権限を確認してください。",
   "work.sourceNotice.unavailable": "ファイルを確認できませんでした。再試行してください。",
   "work.saveCheck": "保存ファイルを再確認",
-  "work.checkingFile": "確認中…"
+  "work.checkingFile": "確認中…",
+  "work.mediaViewerNeeded": "メディアプレビュー拡張機能をインストールし、選択したファイルの読み取りを許可してください。"
 };
 const FILE_ACCESS_TRANSLATIONS_JA = {
   "fileAccess.retry": "再試行",
@@ -69675,6 +70268,8 @@ const organizationInstallRecoveryJa = {
   "organizationStart.toolDiagnostic.reason.TOOL_EXECUTION_FAILED": "ファイルの実行またはバージョン確認ができませんでした。",
   "organizationStart.toolDiagnostic.reason.TOOL_INSTALL_FAILED": "ツールの準備に失敗しました。原因はまだ確認できていません。",
   "organizationStart.toolDiagnostic.reason.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "インストール済みcswapは必要な認証機能に対応していません。",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_AUTH_REQUIRED": "会社のプロキシがサインイン認証を求めたため、接続できませんでした。",
+  "organizationStart.toolDiagnostic.reason.TOOL_PROXY_BLOCKED": "会社のプロキシがダウンロードまたはパッケージサーバーへの接続を許可しませんでした。",
   "organizationStart.toolDiagnostic.action.TOOL_NOT_FOUND": "再試行するか、ガイドに従ってインストール後に再確認してください。",
   "organizationStart.toolDiagnostic.action.TOOL_PREREQUISITE_REQUIRED": "表示された前提ツールを準備してから再試行してください。",
   "organizationStart.toolDiagnostic.action.TOOL_NETWORK_FAILED": "インターネット・社内ネットワーク・プロキシを確認して再試行してください。",
@@ -69687,12 +70282,55 @@ const organizationInstallRecoveryJa = {
   "organizationStart.toolDiagnostic.action.TOOL_TIMEOUT": "ネットワークを確認して再試行してください。繰り返す場合は診断を共有してください。",
   "organizationStart.toolDiagnostic.action.TOOL_EXECUTION_FAILED": "インストールの完全性と社内ポリシーの実行許可を確認してください。",
   "organizationStart.toolDiagnostic.action.TOOL_INSTALL_FAILED": "再試行してください。繰り返す場合は診断を共有してください。",
-  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "再試行してSaycode用の認証ツールをインストールしてください。"
+  "organizationStart.toolDiagnostic.action.CLAUDE_SETUP_TOKEN_RUNTIME_UNSUPPORTED": "再試行してSaycode用の認証ツールをインストールしてください。",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_AUTH_REQUIRED": "この診断をIT担当者に伝え、ダウンロードサーバーをプロキシ認証の例外にするよう依頼してください。",
+  "organizationStart.toolDiagnostic.action.TOOL_PROXY_BLOCKED": "この診断をIT担当者に伝え、ダウンロードサーバーへの接続許可を依頼してください。"
+};
+const organizationAccountKeyJa = {
+  "organizationStart.accountKey.title": "会話の暗号化をオンにする",
+  "organizationStart.accountKey.body": "このコンピューターで組織の AI を使うには、先に会話の暗号化をオンにしてください。現在のパスワードでこのアカウントの暗号化キーを作成します。",
+  "organizationStart.accountKey.row": "会話の暗号化",
+  "organizationStart.accountKey.passwordLabel": "現在のパスワード",
+  "organizationStart.accountKey.checking": "パスワードを確認中…",
+  "organizationStart.accountKey.recoveryTitle": "復旧キーを保管してください",
+  "organizationStart.accountKey.recoveryNotice": "パスワードを忘れたときに会話を開く方法です。パスワードと復旧キーの両方を失うと、暗号化された会話は開けません。この画面を閉じると復旧キーは再表示できません。",
+  "organizationStart.accountKey.copy": "コピー",
+  "organizationStart.accountKey.copied": "復旧キーをコピーしました。",
+  "organizationStart.accountKey.save": "ファイルに保存",
+  "organizationStart.accountKey.saved": "復旧キーを保存しました。",
+  "organizationStart.accountKey.confirmLabel": "復旧キーをもう一度入力",
+  "organizationStart.accountKey.confirmMismatch": "入力した復旧キーが上の復旧キーと一致しません。",
+  "organizationStart.accountKey.enable": "会話の暗号化をオンにする",
+  "organizationStart.accountKey.saving": "オンにしています…",
+  "organizationStart.accountKey.renewBody": "確認の有効時間が過ぎたため、もう一度パスワードを確認します。保管した復旧キーはそのままです。",
+  "organizationStart.accountKey.renew": "再確認",
+  "organizationStart.accountKey.error.wrong-password": "現在のパスワードが正しくありません。",
+  "organizationStart.accountKey.error.rate-limited": "試行回数が多すぎます。しばらくしてからもう一度お試しください。",
+  "organizationStart.accountKey.error.already-enabled": "このアカウントはすでに会話の暗号化がオンです。ログアウトしてもう一度ログインしてください。",
+  "organizationStart.accountKey.error.signed-out": "ログインの有効期限が切れました。ログアウトしてもう一度ログインしてください。",
+  "organizationStart.accountKey.error.expired": "確認の有効時間が過ぎました。パスワードをもう一度入力してください。",
+  "organizationStart.accountKey.error.failed": "会話の暗号化をオンにできませんでした。しばらくしてからもう一度お試しください。",
+  "organizationStart.accountKey.error.recovery-mismatch": "入力した復旧キーが上の復旧キーと一致しません。",
+  "organizationStart.accountKey.lockedTitle": "もう一度ログインしてください",
+  "organizationStart.accountKey.lockedBody": "このアカウントは会話の暗号化がオンですが、このコンピューターではまだ開かれていません。ログアウトしてもう一度ログインすると続行します。",
+  "organizationStart.accountKey.signInAgain": "もう一度ログイン",
+  "organizationStart.diagnostic.reason.accountKey": "このアカウントの会話の暗号化はまだオンになっていません。",
+  "organizationStart.diagnostic.action.accountKey": "開始準備で会話の暗号化をオンにしてください。",
+  "organizationStart.diagnostic.reason.accountKeyLocked": "このコンピューターではアカウントの暗号化キーがまだ開かれていません。",
+  "organizationStart.diagnostic.action.accountKeyLocked": "ログアウトしてもう一度ログインしてください。"
+};
+const organizationPcRegistrationJa = {
+  "organizationStart.diagnostic.reason.pcNotAssigned": "このPCは、選択した組織でこのアカウントの専用PCとして割り当てられていません。",
+  "organizationStart.diagnostic.action.pcNotAssigned": "選択した組織が正しいか確認し、正しければ組織の管理者にこのPCをこのアカウントの専用PCとして割り当てるよう依頼してください。",
+  "organizationStart.diagnostic.reason.pcReregister": "このPCの以前の登録情報は引き続き使用できません。",
+  "organizationStart.diagnostic.action.pcReregister": "組織の管理者にこのPCを新しく登録するよう依頼してください。"
 };
 const organizationStartJa = {
   "organizationStart.toolsDetails": "ツール準備の詳細",
   "organizationStart.toolsProgress": "ツール準備状況",
   ...organizationInstallRecoveryJa,
+  ...organizationAccountKeyJa,
+  ...organizationPcRegistrationJa,
   "organizationStart.connectingTitle": "組織に接続中",
   "organizationStart.connectingBody": "{name}で作業を始める準備をしています。",
   "organizationStart.welcome": "組織ですぐに始めましょう",
@@ -69720,6 +70358,9 @@ const organizationStartJa = {
   "organizationStart.aiGroupConflict": "組織のAIアカウント設定の確認が必要です。組織の管理者にお知らせください。",
   "organizationStart.aiChecking": "AI接続中…",
   "organizationStart.connectLater": "後で接続",
+  "organizationStart.skip": "スキップ",
+  "organizationStart.noAi.body": "{name}には組織のAIアカウントが登録されていません。スキップして自分のAIアカウントで始められます。",
+  "organizationStart.noAi.status": "組織のAIアカウントなし",
   "organizationStart.existingConnection": "このPCを{name}に接続するには「次へ」を押してください。",
   "organizationStart.failed": "オンボーディングの準備",
   "organizationStart.recovery.title": "アプリの修復が必要です",
@@ -69826,7 +70467,32 @@ const organizationStartJa = {
   "organizationStart.diagnostic.reason.registrationChanged": "このPCの組織登録が変更または削除されたため、このアカウントで接続できません。",
   "organizationStart.diagnostic.action.registrationChanged": "組織管理者に、組織管理 → PC でこのPCの登録を確認するよう依頼してから、もう一度お試しください。",
   "organizationStart.diagnostic.reason.publicVerify": "共有認証を適用しましたが、AI認証の利用を確認できませんでした。",
-  "organizationStart.diagnostic.action.publicVerify": "組織管理者に最新の共有認証の復旧を依頼してから再接続してください。"
+  "organizationStart.diagnostic.action.publicVerify": "組織管理者に最新の共有認証の復旧を依頼してから再接続してください。",
+  "companyInvite.title": "組織への招待",
+  "companyInvite.checkFailed": "組織への招待の確認が必要です",
+  "companyInvite.body": "新しい組織への招待があります。参加する組織を選択してください。",
+  "companyInvite.onboardingBody": "作業する組織を選ぶ前に、受け取った招待を確認してください。",
+  "companyInvite.member": "メンバー",
+  "companyInvite.admin": "管理者",
+  "companyInvite.accept": "承認",
+  "companyInvite.decline": "辞退",
+  "companyInvite.later": "後で",
+  "companyInvite.dismiss": "組織への招待を閉じる",
+  "companyInvite.accepted": "組織に参加しました。",
+  "companyInvite.declined": "組織への招待を辞退しました。",
+  "companyInvite.failed": "招待を処理できませんでした。後でもう一度お試しください。",
+  "companyInvite.reauth": "管理者権限を適用するには、もう一度ログインしてください。",
+  "companyInvite.retry": "再確認",
+  "companyInvite.securityRequired": "管理者の招待にはセキュリティ認証が必要です。ウェブで設定と認証を確認して再試行してください。",
+  "companyInvite.expiry": "{date}まで",
+  "companyInvite.declineConfirm": "辞退を確認",
+  "companyInvite.declineBody": "{name}からの招待を辞退しますか？後から参加するには新しい招待が必要です。",
+  "companyInvite.cancel": "キャンセル",
+  "companyInvite.loading": "招待を確認中…",
+  "companyInvite.acceptLabel": "{name}の招待を承認",
+  "companyInvite.declineLabel": "{name}の招待を辞退",
+  "companyInvite.declineConfirmLabel": "{name}の招待の辞退を確認",
+  "companyInvite.refreshFailed": "招待一覧を確認できませんでした。再確認してください。"
 };
 const usageEntryJa = {
   ...selfHostConnectJa,
@@ -69966,7 +70632,7 @@ const usageEntryJa = {
   "localTools.prerequisitesBody": "uv・Git・Node.js（npm を含む）のインストール状況を確認します。インストール後に再確認してください。",
   "localTools.prerequisitesTitle": "基本開発ツール",
   "onboarding.preparationComplete": "必須設定完了",
-  "onboarding.additionalStepsBody": "Saycodeの指示、AIアカウント、通知、コンピューター・ブラウザー操作は任意です。すぐに開始して、後で設定できます。",
+  "onboarding.additionalStepsBody": "Saycodeの指示、AIアカウント、通知は任意です。すぐに開始して、後で設定できます。",
   "onboarding.additionalStep": "追加ステップ",
   "onboarding.requiredSettings": "必須設定",
   "onboarding.additionalSettings": "追加設定 — 任意",
@@ -70049,6 +70715,11 @@ const projectRelocationJA = {
   "sessionCreation.workspaceNotSet": "このマシンのワークスペースパスが設定されていません。先にマシンのワークスペースを設定してください。"
 };
 const chatSchedulesJa = {
+  "chatSchedules.chatTitle": "このチャットの予約",
+  "chatSchedules.sharedHint": "予約メニューでも同じ予約を確認・管理できます。",
+  "chatSchedules.allSchedules": "すべての予約を見る",
+  "chatSchedules.advanced": "自動化の詳細設定",
+  "chatSchedules.advancedHint": "AI・実行条件・スクリプト自動化を設定します。AI予約は上の一覧と共通で、スクリプト自動化は別の実行形式です。",
   "chatSchedules.olderReplies": "以前の回答",
   "chatSchedules.newerReplies": "新しい回答",
   "chatSchedules.limitedReplies": "この実行の回答を一部表示しています。全文は会話を開いて確認してください。",
@@ -70494,7 +71165,12 @@ const machineUsageJa = {
   "machineUsage.autoSwitched": "{provider} アカウントを自動切替しました: {from} → {to}",
   "machineUsage.pinned": "固定中",
   "machineUsage.codexAccounts": "Codex アカウント",
-  "machineUsage.usageStale": "使用量を更新中"
+  "machineUsage.usageStale": "使用量を更新中",
+  "machineUsage.autoRotation": "アカウント自動切替",
+  "machineUsage.autoRotationOn": "上限に近づくと別のアカウントに自動で切り替えます。",
+  "machineUsage.autoRotationOff": "選択したアカウントを使い続けます。",
+  "machineUsage.autoRotationPaused": "アカウントを選択したため自動切替をオフにしました。",
+  "machineUsage.autoRotationFailed": "自動切替を変更できませんでした。もう一度お試しください。"
 };
 const machineResourceMetricsJa = {
   "machineResourceMetrics.title": "セッションマシンのCPU/メモリ",
@@ -70909,7 +71585,7 @@ const outboundWebhookJa = {
 };
 const messengerChannelsJa = {
   "settings.messengerChannels.title": "メッセンジャーチャネル",
-  "settings.messengerChannels.privacyNotice": "接続先メッセンジャーには、リクエストの状態と最終回答のみが送信されます — raw tool output・過去の履歴・添付ファイルは送信されません。メッセンジャー区間はSaycodeのエンドツーエンド暗号化の対象外です。",
+  "settings.messengerChannels.privacyNotice": "接続先メッセンジャーには、リクエストの状態と最終回答が送信されます。Slackでは、その回答でエージェントが指定したプロジェクトフォルダー内のファイルも送信されます。raw tool output・過去の履歴は送信されません。メッセンジャー区間はSaycodeのエンドツーエンド暗号化の対象外です。",
   "settings.messengerChannels.alwaysOnTitle": "アプリ終了後も接続を維持",
   "settings.messengerChannels.alwaysOnHelp": "Saycodeを終了してもメッセージを受信し、作業を続けます。コンピューターがスリープせず、インターネットに接続されている必要があります。",
   "settings.messengerChannels.alwaysOnBlocked": "利用できません: この端末ではボットの資格情報を安全に保存できないため、Desktop終了後は何も受信できません。",
@@ -71067,7 +71743,7 @@ const messengerQuickSetupJa = {
   "settings.messengerChannels.quickSlack.openInSlack": "Slack で開く",
   "settings.messengerChannels.quickSlack.waiting": "Slack で送信するとここに接続リクエストが表示されます。許可すれば完了です。",
   "settings.messengerChannels.quickSlack.pairedWith": "{name} さんの Slack と接続済み",
-  "settings.messengerChannels.quickSlack.connectedHelp": "コードを送った DM でボットにそのまま話しかけてください。コマンドはボットをメンションして /help で確認できます。",
+  "settings.messengerChannels.quickSlack.connectedHelp": "コードを送った DM でボットにそのまま話しかけてください。ボットを招待したチャンネルでメンションすると、そのメッセージのスレッドで返信します(チャンネルのメンバーに表示されます)。コマンドはボットをメンションして /help で確認できます。",
   "settings.messengerChannels.quickDiscord.title": "Discord 接続",
   "settings.messengerChannels.quickDiscord.subtitle": "Discord から Saycode にすぐ作業を任せられます。2 ステップで完了します。",
   "settings.messengerChannels.quickDiscord.installTitle": "Discord 機能がまだオフです",
@@ -71372,6 +72048,9 @@ const extensionPanelJa = {
 const extensionInstallJa = {
   "extensions.installOfficial": "拡張機能をインストール",
   "extensions.installNamedOfficial": "{name} をインストール",
+  "extensions.officialUpdate": "{version} に公式アップデート",
+  "extensions.updateSaved": "新しいバージョンはインストールされましたが、仕上げを確認できませんでした。拡張機能の状態を確認してください。",
+  "extensions.projectToolHint": "プロジェクトの会話で、右側の作業パネルのその他(⋮)メニューから開きます: {tools}",
   "extensions.officialName.artifactPublisher": "公開リンク拡張",
   "extensions.officialName.pluginManager": "プラグイン管理拡張",
   "extensions.officialName.projectTemplates": "プロジェクトテンプレート拡張",
@@ -71400,25 +72079,26 @@ const extensionInstallJa = {
   "artifactPublication.error.network": "サーバーに接続できません。ネットワークを確認してください。",
   "artifactPublication.error.unauthenticated": "ログインセッションの有効期限が切れました。再度サインインしてください。",
   "artifactPublication.error.notFound": "ファイルが見つかりません。保存されているか確認してください。",
+  "artifactPublication.error.notFoundInFolder": "作業フォルダー {folder} に {file} が見つかりません。別の worktree で作成したファイルなら、このフォルダーに移してから再試行してください。",
   "artifactPublication.error.tooLarge": "ファイルが大きすぎます。公開する HTML ファイルは 10MB 以下にしてください。",
   "artifactPublication.error.rateLimited": "公開リンクのリクエストが多すぎます。しばらくしてから再試行してください。",
   "artifactPublication.error.rejected": "サーバーがこのファイルの公開リクエストを拒否しました。",
   "artifactPublication.error.serverError": "サーバーエラーが発生しました。しばらくしてから再試行してください。",
   "artifactPublication.error.extensionUnavailable": "拡張機能が無効か、公開権限がありません。設定で Artifact Publisher を確認してください。",
-  "artifactPublication.error.invalidResponse": "サーバーの応答を検証できなかったため中止しました。"
+  "artifactPublication.error.invalidResponse": "サーバーの応答を検証できなかったため中止しました。",
+  "extensions.permission.filePreviewsRead": "アプリで開いたファイルのプレビューを読み取ります。元のパスと認証情報は Saycode Core が管理します。"
 };
 const artifactLibraryTranslations = {
   "artifactLibrary.title": "成果物一覧",
   "artifactLibrary.scope": "範囲",
   "artifactLibrary.conversation": "この会話",
   "artifactLibrary.project": "このプロジェクト",
-  "artifactLibrary.all": "すべてのプロジェクト",
   "artifactLibrary.search": "ファイル・プロジェクト・会話・パスを検索",
-  "artifactLibrary.hint": "会話で作成した文書とプレビューです。元のファイルを開きます。",
   "artifactLibrary.loading": "成果物を検索中…",
   "artifactLibrary.error": "一部の会話を取得できませんでした。再試行してください。",
   "artifactLibrary.empty": "成果物はまだありません。",
   "artifactLibrary.noMatches": "検索結果がありません。",
+  "artifactLibrary.readUnsupported": "このPCでは作業物の元ファイルを開けません。現在はmacOSの作業PCに対応しています。",
   "artifactLibrary.retry": "再試行"
 };
 const personalChatsLandingJa = {
@@ -72282,9 +72962,15 @@ const sidebarUpdateJa = {
   "sidebarUpdate.completedBody": "Saycode v{version} に更新しました。",
   "sidebarUpdate.installing": "更新を適用中…",
   "sidebarUpdate.update": "アップデート",
-  "sidebarUpdate.restartNotice": "再起動の前に会話の状態を保存します。",
+  "sidebarUpdate.restartNotice": "再起動の前に会話の状態を保存します。インストールが終わると Saycode が自動で開きます。",
   "sidebarUpdate.minimize": "最小化",
-  "sidebarUpdate.releaseNotes": "Release notes"
+  "sidebarUpdate.releaseNotes": "Release notes",
+  "sidebarUpdate.relaunchWaitTitle": "アップデートをインストールしています",
+  "sidebarUpdate.relaunchWaitBody": "インストールが終わると Saycode v{version} が自動で開きます。このウィンドウを閉じてもインストールは続きます。",
+  "sidebarUpdate.relaunchTimeoutTitle": "アップデートのインストールを完了できませんでした",
+  "sidebarUpdate.relaunchTimeoutBody": "現在のバージョン (v{version}) で開けます。アプリからもう一度アップデートを取得できます。",
+  "sidebarUpdate.relaunchOpenCurrent": "現在のバージョンで開く",
+  "sidebarUpdate.relaunchQuit": "終了"
 };
 const globalPauseJa = {
   "settings.globalPause.enable": "グローバル一時停止（新しい自動アクションを遮断）",
@@ -73609,7 +74295,6 @@ const onboardingJa = {
   "onboarding.page.addProject": "最初のプロジェクトを追加",
   "onboarding.page.configured": "設定済み",
   "onboarding.page.optional": "任意",
-  "onboarding.page.computerReveal": "内部テスト: コンピューター・ブラウザー操作を表示",
   "onboarding.page.testNotification": "テスト通知を送信",
   "onboarding.page.testNotificationSending": "テスト通知を送信中…",
   "onboarding.page.testNotificationSuccess": "テスト通知を送信しました。",
@@ -73784,6 +74469,7 @@ const ja = {
   "aiModelPolicy.machineChanged": "選択したPCに接続できないため開始を中断しました。PCを確認して再送してください。",
   "aiModelPolicy.policyChanged": "許可モデルのポリシーが変わったため開始を中断しました。質問と添付を確認して再送してください。",
   "aiModelPolicy.noModels": "このコンピューターで選択できる許可済みモデルがありません。",
+  ...personalAiJa,
   ...conversationTabsJa,
   ...questionComposerJa,
   ...aiRecoveryJa,
@@ -76008,6 +76694,9 @@ const ja = {
   "projectGitView.branchRename": "Branch 名変更",
   "projectGitView.branchDelete": "Branch 削除",
   "terminal.connectTimeout": "ターミナル接続がタイムアウトしました。",
+  "terminal.strictMachineUnsupported": "セキュリティ強化(strict)マシンではまだリモートターミナルを開けません。マシン上のターミナルを直接お使いください。",
+  "terminal.machineControlUnknown": "このマシンの CLI がセキュリティモードを通知しないため、リモートターミナルを開けません。マシンの happy CLI を更新してください。",
+  "terminal.machineKeyUnavailable": "このマシンのキーを開けないため、リモートターミナルを開きませんでした。アカウントキーのロックを解除してから再度お試しください。",
   "terminal.connectFailed": "ターミナルへの接続に失敗しました。",
   "terminal.cwdPrepFailed": "リモートターミナルの作業ディレクトリを準備できませんでした。",
   "terminal.restoredOutputDivider": "前回のセッション出力",
@@ -83327,6 +84016,18 @@ function contributionList(value2, path2, allowedKeys, parse2) {
     return parse2(entry, entryPath);
   });
 }
+function parseExtensionFileViewers(value2, apiVersion) {
+  if (apiVersion < 4) fail$7("manifest.contributes.fileViewers", "requires Extension API version 4");
+  return contributionList(value2, "manifest.contributes.fileViewers", ["id", "title", "extensions", "panelId"], (entry, path2) => {
+    if (!Array.isArray(entry.extensions) || !entry.extensions.length || entry.extensions.length > 30 || entry.extensions.some((extension2) => typeof extension2 !== "string" || !/^[a-z0-9]{1,12}$/.test(extension2)) || new Set(entry.extensions).size !== entry.extensions.length) fail$7(`${path2}.extensions`, "expected unique lowercase file extensions");
+    return { id: id$1(entry.id, `${path2}.id`), title: string(entry.title, `${path2}.title`), extensions: entry.extensions, panelId: id$1(entry.panelId, `${path2}.panelId`) };
+  });
+}
+function assertExtensionFileViewers(extensionId, viewers, panels, permissions) {
+  for (const viewer of viewers) {
+    if (!permissions.includes("filePreviews.read") || !viewer.id.startsWith(`${extensionId}.`) || !viewer.panelId.startsWith(`${extensionId}.`) || !panels.some((panel) => panel.id === viewer.panelId)) fail$7("manifest.contributes.fileViewers", "requires filePreviews.read and an owned panel");
+  }
+}
 function parseMachineCommands(value2, extensionId, apiVersion) {
   if (apiVersion < 3) fail$7("manifest.machineCommands", "requires Extension API version 3");
   const root = record$4(value2, "manifest.machineCommands");
@@ -84007,6 +84708,7 @@ const EXTENSION_PERMISSIONS = [
   "browserViewer.install",
   "browserViewer.installChrome",
   "artifacts.publishPublic",
+  "filePreviews.read",
   // One permission per channel wire method (`src/domain/channelProtocol.ts`), deliberately not a
   // single adapter grant. Receiving and acking messages is transport work; reading a session,
   // driving it, or approving a tool call once are three larger and separately-refusable
@@ -84021,7 +84723,7 @@ const EXTENSION_PERMISSIONS = [
   "sessions.control",
   "sessions.approveOnce"
 ];
-const SAYCODE_EXTENSION_API_VERSION = 3;
+const SAYCODE_EXTENSION_API_VERSION = 4;
 const SAYCODE_EXTENSION_MINIMUM_API_VERSION = 2;
 const MAX_EXTENSION_API_WINDOW_WIDTH = 2;
 const SAYCODE_EXTENSION_ENGINE_VERSION = "1.2.0";
@@ -84047,7 +84749,7 @@ const SEMVER_PATTERN$1 = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)
 const ENGINE_RANGE_PATTERN = /^(?:\^|~|>=|<=|>|<)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
 const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
-const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels"]);
+const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers"]);
 const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.open",
   "browserViewer.install",
@@ -84108,7 +84810,7 @@ function engineSupports(range, version2) {
 function parseApiVersion(value2, options) {
   const current2 = options.supportedApiVersion;
   const floor = options.minimumSupportedApiVersion ?? current2;
-  if (floor > current2 || current2 - floor + 1 > MAX_EXTENSION_API_WINDOW_WIDTH) {
+  if (floor > current2 || current2 - floor + 1 > (current2 === 4 && floor === 2 ? 3 : MAX_EXTENSION_API_WINDOW_WIDTH)) {
     fail$7(
       "manifest.apiVersion",
       `invalid Desktop API support window [${floor}, ${current2}]`
@@ -84149,6 +84851,7 @@ function parseContributions(value2, apiVersion, channelApiVersion) {
     fail$7("manifest.contributes.artifactActions", "requires Extension API version 3");
   }
   const result2 = {};
+  if (parsed2.fileViewers !== void 0) result2.fileViewers = parseExtensionFileViewers(parsed2.fileViewers, apiVersion);
   if (parsed2.commands !== void 0) {
     result2.commands = contributionList(
       parsed2.commands,
@@ -84300,6 +85003,7 @@ function parseExtensionManifest(value2, options) {
       fail$7("manifest.permissions", `unknown permission ${parsed2}`);
     }
     const typed = parsed2;
+    if (typed === "filePreviews.read" && apiVersion < 4) fail$7("manifest.permissions", "filePreviews.read requires Extension API version 4");
     if (apiVersion < 2 && V2_PERMISSIONS.has(typed)) {
       fail$7(`manifest.permissions[${index}]`, "requires Extension API version 2");
     }
@@ -84371,6 +85075,7 @@ function parseExtensionManifest(value2, options) {
       );
     }
   }
+  assertExtensionFileViewers(parsedId, contributes.fileViewers ?? [], contributes.panels ?? [], permissions);
   assertExtensionProjectToolTargets(parsedId, contributes.projectTools ?? [], contributes.commands ?? []);
   return {
     id: parsedId,
@@ -84429,15 +85134,7 @@ class OfficialExtensionInstaller {
    * ones are the rest of the panel.
    */
   async installable() {
-    let bundled = [];
-    try {
-      bundled = (await this.readCatalog()).extensions;
-    } catch {
-      bundled = [];
-    }
-    const versions = /* @__PURE__ */ new Map();
-    for (const entry of bundled) versions.set(entry.id, entry.version);
-    for (const entry of this.options.remote?.descriptors() ?? []) versions.set(entry.id, entry.version);
+    const versions = await this.offeredVersions();
     return [...versions].filter(([id2, version2]) => !this.options.registry.get(id2) && !this.options.revocations?.isRevoked(id2, version2)).map(([id2, version2]) => ({ id: id2, version: version2 }));
   }
   async install(id2) {
@@ -84456,6 +85153,48 @@ class OfficialExtensionInstaller {
     }
     return { id: installed.id, version: installed.version, releaseUrl: source2.metadata.releaseUrl };
   }
+  /**
+   * Installed official extensions whose offered version is newer. The installable list leaves
+   * installed ids out, and compatibility migration replaces only versions Desktop can no longer
+   * load, so without this an installed official extension never moves past the version it came at.
+   */
+  async updates() {
+    const versions = await this.offeredVersions();
+    const retained = await this.retainedVersions();
+    return [...versions].filter(([id2, version2]) => {
+      const state = this.options.registry.get(id2);
+      return state && isNewerVersion(version2, state.installedVersion) && !this.options.revocations?.isRevoked(id2, version2) && !retained.has(`${id2}@${version2}`);
+    }).map(([id2, version2]) => ({ id: id2, version: version2 }));
+  }
+  /** Same shape as a local update: the new version replaces the active one, approvals reset, the old one stays for rollback. */
+  async update(id2, expectedVersion) {
+    const state = this.options.registry.get(id2);
+    if (!state) throw new Error(`extension is not installed: ${id2}`);
+    if (state.runtime === "active") throw new Error("active extension must be disabled before update");
+    const source2 = await this.resolveArtifact(id2);
+    if (expectedVersion && source2.metadata.version !== expectedVersion) throw new Error(`official extension offered version changed: ${id2}`);
+    if (!isNewerVersion(source2.metadata.version, state.installedVersion)) throw new Error(`official extension is up to date: ${id2}`);
+    if ((await this.retainedVersions()).has(`${id2}@${source2.metadata.version}`)) {
+      throw new Error(`official extension ${id2}@${source2.metadata.version} is still on disk from an earlier install that was rolled back`);
+    }
+    const installed = await this.options.store.install(source2.archive);
+    if (installed.id !== source2.metadata.id || installed.version !== source2.metadata.version) {
+      await this.options.store.removeVersion(installed.id, installed.version);
+      throw new Error("official extension artifact does not match its provenance");
+    }
+    const current2 = this.options.registry.get(id2);
+    if (!current2 || current2.installedVersion !== state.installedVersion || current2.runtime === "active") {
+      await this.options.store.removeVersion(installed.id, installed.version);
+      throw new Error(`official extension ${id2} changed during the update`);
+    }
+    try {
+      await this.options.registry.apply(id2, { type: "update-installed", version: installed.version });
+    } catch (error) {
+      await this.options.store.removeVersion(installed.id, installed.version);
+      throw error;
+    }
+    return { id: id2, version: installed.version, releaseUrl: source2.metadata.releaseUrl };
+  }
   async reconcileBundledCompatibility() {
     const installedEntries = this.options.registry.entries();
     if (installedEntries.length === 0) return;
@@ -84513,6 +85252,26 @@ class OfficialExtensionInstaller {
     if (!metadata) throw new Error(`official extension is unavailable: ${id2}`);
     return { archive: await this.readArchive(metadata), metadata };
   }
+  /**
+   * Versions kept on disk. One newer than the installed version is only left behind by stepping back from it
+   * (quarantine rollback or a downgrade), so it is not offered again: the store refuses to reinstall over it.
+   */
+  async retainedVersions() {
+    return new Set((await this.options.store.listInstalled()).map((entry) => `${entry.id}@${entry.version}`));
+  }
+  /** The version each official id would arrive at: the signed remote catalog over the bundled copy. */
+  async offeredVersions() {
+    let bundled = [];
+    try {
+      bundled = (await this.readCatalog()).extensions;
+    } catch {
+      bundled = [];
+    }
+    const versions = /* @__PURE__ */ new Map();
+    for (const entry of bundled) versions.set(entry.id, entry.version);
+    for (const entry of this.options.remote?.descriptors() ?? []) versions.set(entry.id, entry.version);
+    return versions;
+  }
   async readCatalog() {
     try {
       return catalog(JSON.parse(await readFile(join(this.options.resourceRoot, "catalog.v1.json"), "utf8")));
@@ -88486,6 +89245,107 @@ class ChannelAuthCustody {
   onWindowClosed(_windowId) {
   }
 }
+const CHANNEL_FILE_REPLY_MAX_FILES = 5;
+const CHANNEL_FILE_REPLY_MAX_BYTES = 20 * 1024 * 1024;
+const MARKER = /^\s*MEDIA:(.*)$/;
+const FENCE = /^\s*(```|~~~)/;
+function unwrap(value2) {
+  const trimmed = value2.trim();
+  const quoted = /^(`+|"|'|<)(.*?)(`+|"|'|>)$/.exec(trimmed);
+  return quoted ? quoted[2].trim() : trimmed;
+}
+function extractChannelFileMarkers(text2) {
+  const kept = [];
+  const paths = [];
+  let fenced = false;
+  for (const line2 of text2.split(/\r?\n/)) {
+    if (FENCE.test(line2)) fenced = !fenced;
+    const marker = fenced ? null : MARKER.exec(line2);
+    if (!marker) {
+      kept.push(line2);
+      continue;
+    }
+    const path2 = unwrap(marker[1]);
+    if (path2 && !paths.includes(path2)) paths.push(path2);
+  }
+  if (paths.length === 0) return { text: text2, paths };
+  return { text: kept.join("\n").replace(/\s+$/, ""), paths: Object.freeze(paths) };
+}
+const WINDOWS_ROOT = /^[A-Za-z]:[\\/]/;
+function isHiddenOrSecret(segment) {
+  return segment.startsWith(".") || /\.pem$/i.test(segment) || /^id_/i.test(segment);
+}
+function vetChannelFilePath(path2, workingDirectory) {
+  if (!path2.trim() || /[\u0000-\u001f\u007f]/.test(path2)) return { ok: false, reason: "invalid" };
+  const windows = WINDOWS_ROOT.test(workingDirectory);
+  const flavor = windows ? win32 : posix;
+  if (!workingDirectory || !flavor.isAbsolute(workingDirectory)) return { ok: false, reason: "invalid" };
+  const root = flavor.resolve(workingDirectory);
+  const absolutePath = flavor.resolve(root, path2);
+  const fold = (value2) => windows ? value2.toLowerCase() : value2;
+  const relative2 = flavor.relative(fold(root), fold(absolutePath));
+  if (!relative2 || relative2.startsWith("..") || flavor.isAbsolute(relative2)) {
+    return { ok: false, reason: "outside-workspace" };
+  }
+  const segments2 = absolutePath.slice(root.length).split(flavor.sep).filter(Boolean);
+  if (segments2.some(isHiddenOrSecret)) return { ok: false, reason: "hidden-or-secret" };
+  return { ok: true, absolutePath, root, segments: Object.freeze(segments2) };
+}
+function validDiscoveryPath(path2) {
+  return typeof path2 === "string" && path2.length > 0 && path2.length < 4096 && !/[\\\0]/.test(path2) && !path2.startsWith("/") && path2.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+async function request(access2, params, call2 = callDesktopMachineRpc) {
+  if (!access2.machine.online) throw new Error("offline");
+  const result2 = await call2(access2.auth, access2.machine, "file-discovery", { version: 1, root: access2.root, ...params });
+  if (!result2 || result2.version !== 1 || result2.success !== true) throw new Error(typeof result2?.error === "string" ? result2.error : "unsupported");
+  return result2;
+}
+async function readDiscoveryFile(access2, path2, options = {}) {
+  if (!validDiscoveryPath(path2)) throw new Error("invalid-path");
+  const maxBytes = options.maxBytes ?? 25 * 1024 * 1024;
+  const chunks = [];
+  let offset = 0;
+  let identity;
+  while (offset <= maxBytes) {
+    const result2 = await request(access2, { operation: "read", path: path2, offset, length: 262144, ...identity ? { identity } : {} }, options.call);
+    if (typeof result2.content !== "string" || result2.content.length > 349528 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(result2.content) || typeof result2.identity !== "string" || identity !== void 0 && identity !== result2.identity || result2.offset !== offset || typeof result2.eof !== "boolean" || !Number.isSafeInteger(result2.size) || result2.size < 0 || result2.size > 25 * 1024 * 1024) throw new Error("invalid-response");
+    if (result2.size > maxBytes) throw new Error("too-large");
+    identity = result2.identity;
+    const chunk = Buffer$1.from(result2.content, "base64");
+    offset += chunk.length;
+    chunks.push(chunk);
+    if (result2.eof === true && offset === result2.size) return Buffer$1.concat(chunks).toString("base64");
+    if (!chunk.length || offset >= result2.size) throw new Error("invalid-response");
+  }
+  throw new Error("too-large");
+}
+async function readChannelSessionFile(input) {
+  const { auth, machine, workingDirectory } = input.location;
+  const verdict = vetChannelFilePath(input.path, workingDirectory);
+  if (!verdict.ok) return { ok: false, reason: verdict.reason };
+  if (!machine.online) return { ok: false, reason: "machine-offline" };
+  try {
+    const base642 = await readDiscoveryFile({ auth, machine, root: verdict.root }, verdict.segments.join("/"), {
+      call: input.callMachineRpc,
+      maxBytes: input.maxBytes ?? CHANNEL_FILE_REPLY_MAX_BYTES
+    });
+    return { ok: true, fileName: verdict.segments.at(-1), bytes: new Uint8Array(Buffer.from(base642, "base64")) };
+  } catch (error) {
+    const code = error instanceof Error ? error.message : "";
+    return { ok: false, reason: code === "too-large" ? "too-large" : code === "not-file" ? "not-a-file" : "unreadable" };
+  }
+}
+function createChannelSessionFileLocator(deps) {
+  return async (principalKey, sessionId) => {
+    const auth = deps.authFor(principalKey);
+    if (!auth) return null;
+    const session = await deps.operations.primeSession(auth, sessionId).catch(() => null);
+    if (!session?.machineId || !session.path) return null;
+    const machines2 = await deps.operations.listMachines(auth).catch(() => []);
+    const machine = machines2.find((candidate) => candidate.id === session.machineId);
+    return machine ? { auth, machine, workingDirectory: session.path } : null;
+  };
+}
 class ChannelCapabilityError extends Error {
   constructor(code, message) {
     super(`${code}: ${message}`);
@@ -89076,6 +89936,25 @@ function channelReconnectDelayMs(attempt2, options) {
   const exponential = Math.min(options.maxMs, options.baseMs * 2 ** Math.max(0, attempt2 - 1));
   return Math.floor(exponential * (0.5 + 0.5 * options.jitter()));
 }
+const SLACK_FILE_UPLOAD_ORIGINS = Object.freeze(["https://files.slack.com"]);
+const SLACK_FILE_UPLOAD_OPERATIONS = Object.freeze({
+  filesGetUploadURLExternal: Object.freeze({
+    method: "POST",
+    direction: "core-internal",
+    pathTemplate: "/api/files.getUploadURLExternal",
+    credentialPlacement: "authorizationBearer",
+    parameterPlacement: "query",
+    allowedParams: Object.freeze(["filename", "length"])
+  }),
+  filesCompleteUploadExternal: Object.freeze({
+    method: "POST",
+    direction: "outbound",
+    pathTemplate: "/api/files.completeUploadExternal",
+    credentialPlacement: "authorizationBearer",
+    parameterPlacement: "query",
+    allowedParams: Object.freeze(["files", "channel_id", "thread_ts"])
+  })
+});
 const MAX_SELECTOR_DEPTH = 6;
 const MAX_EVENTS_PER_PAYLOAD = 100;
 const TELEGRAM = Object.freeze({
@@ -89247,7 +90126,9 @@ const SLACK$1 = Object.freeze({
       credentialPlacement: "authorizationBearer",
       parameterPlacement: "jsonBody",
       allowedParams: Object.freeze(["channel", "ts", "text"])
-    }
+    },
+    // Files attached to a final answer (specs/channel-file-replies). Core-only, like the two above.
+    ...SLACK_FILE_UPLOAD_OPERATIONS
   }),
   inbound: Object.freeze({
     eventsPath: Object.freeze(["events"]),
@@ -89405,64 +90286,7 @@ function channelProviderContract(provider2) {
   if (!contract) throw new Error(`no channel contract for provider ${provider2}`);
   return contract;
 }
-async function withdrawIntakeDurably(cancelled, connectionKeys, deps) {
-  const undurable = await journalCancelledIntake(cancelled, deps);
-  if (undurable.length === 0) return EMPTY_WITHDRAWAL;
-  const unsafeToReopen = [];
-  for (const key of connectionKeys) {
-    try {
-      await deps.revokeGeneration(key);
-    } catch {
-      unsafeToReopen.push(key);
-      deps.onDiagnostic?.({
-        code: "INTAKE_WITHDRAWAL_NOT_ENFORCEABLE",
-        message: "a withdrawal was neither recorded nor fenced by a generation move"
-      });
-    }
-  }
-  return Object.freeze({ unsafeToReopen: Object.freeze(unsafeToReopen) });
-}
-const EMPTY_WITHDRAWAL = Object.freeze({
-  unsafeToReopen: Object.freeze([])
-});
-async function journalCancelledIntake(entries, deps) {
-  const undurable = [];
-  for (const entry of entries) {
-    try {
-      await deps.journal.record(entry);
-    } catch {
-      undurable.push(entry.id);
-      deps.onDiagnostic?.({
-        code: "INTAKE_CANCELLATION_NOT_DURABLE",
-        message: "a cancelled request could not be recorded"
-      });
-    }
-  }
-  return Object.freeze(undurable);
-}
-function intakeStateForTurnOutcome(outcome) {
-  if (outcome.kind === "final") return "executed";
-  if (outcome.status === "cancelled") return "cancelled";
-  if (outcome.status === "no-final-answer") return "executed";
-  return "failed";
-}
-async function settleIntakeEntry(queue, requestId, state, deps) {
-  let settled;
-  try {
-    settled = queue.transition(requestId, state);
-  } catch {
-    return;
-  }
-  try {
-    await deps.journal.record(settled);
-  } catch {
-    deps.onDiagnostic?.({
-      code: "INTAKE_TERMINAL_NOT_DURABLE",
-      message: "a finished request could not be recorded"
-    });
-  }
-}
-function readString$1(source2, path2) {
+function readString$2(source2, path2) {
   let current2 = source2;
   for (const key of path2) {
     if (!current2 || typeof current2 !== "object" || Array.isArray(current2)) return null;
@@ -89497,12 +90321,14 @@ function withText(event, text2) {
   return text2 === event.text ? event : { ...event, text: text2 };
 }
 function refineSlack(entry, event, context) {
-  const channelType = readString$1(entry, ["payload", "event", "channel_type"]);
+  const channelType = readString$2(entry, ["payload", "event", "channel_type"]);
   const isDirect = channelType === "im" || channelType === "mpim";
   const rootable = !event.action && !isDirect;
-  const threadRef = event.conversation.threadRef ?? (rootable ? readString$1(entry, ["payload", "event", "ts"]) : null);
+  const threadRef = event.conversation.threadRef ?? (rootable ? readString$2(entry, ["payload", "event", "ts"]) : null);
   const text2 = canonicalizeVerifiedMention(event.text, context.verifiedBotRef);
-  return withText(withThread(event, threadRef), text2);
+  const refined = withText(withThread(event, threadRef), text2);
+  const invited = rootable && readString$2(entry, ["payload", "event", "type"]) === "app_mention" && entry?.payload?.is_ext_shared_channel === false;
+  return invited ? { ...refined, invitedMention: true } : refined;
 }
 function refineDiscord(event, context) {
   const text2 = canonicalizeVerifiedMention(event.text, context.verifiedBotRef);
@@ -89655,7 +90481,7 @@ function readRecord(source2, key) {
   const value2 = source2[key];
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
-function readString(source2, key) {
+function readString$1(source2, key) {
   const value2 = source2?.[key];
   return typeof value2 === "string" && value2.length > 0 ? value2 : null;
 }
@@ -89683,7 +90509,7 @@ function normalizeDiscordInteraction(frame) {
   if (!d || d.type !== DISCORD_APPLICATION_COMMAND) return null;
   const data = readRecord(d, "data");
   if (!data || data.type !== DISCORD_CHAT_INPUT_DATA) return null;
-  const name = readString(data, "name");
+  const name = readString$1(data, "name");
   if (!name || !Object.prototype.hasOwnProperty.call(CHANNEL_COMMAND_SCHEMA, name)) return null;
   const specs = CHANNEL_COMMAND_SCHEMA[name];
   const declared = new Set(specs.map((spec) => spec.endsWith("!") ? spec.slice(0, -1) : spec));
@@ -89693,7 +90519,7 @@ function normalizeDiscordInteraction(frame) {
     if (!Array.isArray(options)) return null;
     for (const option of options) {
       const entry = option && typeof option === "object" && !Array.isArray(option) ? option : null;
-      const optionName = readString(entry, "name");
+      const optionName = readString$1(entry, "name");
       const value2 = entry?.value;
       if (!optionName || !declared.has(optionName)) return null;
       if (entry?.type !== DISCORD_STRING_OPTION$1 || typeof value2 !== "string") return null;
@@ -89707,9 +90533,9 @@ function normalizeDiscordInteraction(frame) {
   }
   const direct = readRecord(d, "user");
   const membership = readRecord(readRecord(d, "member"), "user");
-  if (direct && membership && readString(direct, "id") !== readString(membership, "id")) return null;
+  if (direct && membership && readString$1(direct, "id") !== readString$1(membership, "id")) return null;
   const user = membership ?? direct;
-  const senderRef = readString(user, "id");
+  const senderRef = readString$1(user, "id");
   if (!senderRef) return null;
   const bot = user?.bot;
   if (bot !== void 0 && typeof bot !== "boolean") return null;
@@ -89719,11 +90545,11 @@ function normalizeDiscordInteraction(frame) {
     entry: {
       ...frame,
       d: {
-        id: readString(d, "id"),
-        channel_id: readString(d, "channel_id"),
+        id: readString$1(d, "id"),
+        channel_id: readString$1(d, "channel_id"),
         author: {
           id: senderRef,
-          ...readString(user, "username") ? { username: readString(user, "username") } : {},
+          ...readString$1(user, "username") ? { username: readString$1(user, "username") } : {},
           ...bot === void 0 ? {} : { bot }
         },
         content: text2
@@ -89755,21 +90581,21 @@ function normalizeSlackAction(frame) {
   if (!pressed || pressed.type !== "button") return null;
   const action = parseChannelApprovalActionId(pressed.action_id);
   if (!action) return null;
-  const senderRef = readString(readRecord(payload, "user"), "id");
+  const senderRef = readString$1(readRecord(payload, "user"), "id");
   const container = readRecord(payload, "container");
   if (!container || container.type !== "message") return null;
-  const conversationRef = readString(container, "channel_id");
-  const stated = readString(readRecord(payload, "channel"), "id");
+  const conversationRef = readString$1(container, "channel_id");
+  const stated = readString$1(readRecord(payload, "channel"), "id");
   if (!conversationRef || stated !== null && stated !== conversationRef) return null;
-  const threadRef = readString(readRecord(payload, "message"), "thread_ts") ?? readString(container, "thread_ts");
-  const pressedAt = readString(pressed, "action_ts");
+  const threadRef = readString$1(readRecord(payload, "message"), "thread_ts") ?? readString$1(container, "thread_ts");
+  const pressedAt = readString$1(pressed, "action_ts");
   if (!senderRef || !pressedAt) return null;
   return {
     entry: {
       ...frame,
       payload: {
         ...payload,
-        team_id: readString(readRecord(payload, "team"), "id") ?? void 0,
+        team_id: readString$1(readRecord(payload, "team"), "id") ?? void 0,
         // Rebuilt, not copied: `payload.message` describes the bot's own prompt, and carrying its
         // `user`/`bot_id` through would attribute the click to Saycode.
         event: {
@@ -89793,10 +90619,10 @@ function normalizeDiscordAction(frame, d) {
   if (!action) return null;
   const direct = readRecord(d, "user");
   const membership = readRecord(readRecord(d, "member"), "user");
-  if (direct && membership && readString(direct, "id") !== readString(membership, "id")) return null;
+  if (direct && membership && readString$1(direct, "id") !== readString$1(membership, "id")) return null;
   const user = membership ?? direct;
-  const senderRef = readString(user, "id");
-  const conversationRef = readString(d, "channel_id");
+  const senderRef = readString$1(user, "id");
+  const conversationRef = readString$1(d, "channel_id");
   if (!senderRef || !conversationRef) return null;
   const bot = user?.bot;
   if (bot !== void 0 && typeof bot !== "boolean") return null;
@@ -89805,7 +90631,7 @@ function normalizeDiscordAction(frame, d) {
       ...frame,
       d: {
         // The interaction id, unique per press — a second click is its own event.
-        id: readString(d, "id"),
+        id: readString$1(d, "id"),
         channel_id: conversationRef,
         author: { id: senderRef, ...bot === void 0 ? {} : { bot } },
         content: action.decision
@@ -90713,6 +91539,344 @@ function classifyProgressResult(contract, result2, onDiagnostic) {
   }
   return { ok: false, retryable };
 }
+async function sendChannelOutbound(message, deps) {
+  const contract = channelProviderContract(deps.provider);
+  const mapping = contract.outbound;
+  if (message.body.length > mapping.maxTextLength) {
+    deps.onDiagnostic?.({
+      code: "REPLY_TOO_LONG",
+      message: `the reply exceeds ${mapping.maxTextLength} characters for this provider`
+    });
+    return "failed";
+  }
+  if (!deps.isCurrent()) return "failed";
+  const params = {
+    [mapping.conversationParam]: message.destination.conversationRef,
+    [mapping.textParam]: message.body
+  };
+  if (mapping.threadParam && message.destination.threadRef) {
+    params[mapping.threadParam] = message.destination.threadRef;
+  }
+  if (mapping.replyToParam && message.destination.replyToTransportEventId) {
+    params[mapping.replyToParam] = mapping.replyToIsStructured && mapping.replyToStructuredField ? { [mapping.replyToStructuredField]: message.destination.replyToTransportEventId } : message.destination.replyToTransportEventId;
+  }
+  if (deps.interactive && mapping.interactiveParam) {
+    params[mapping.interactiveParam] = deps.interactive;
+  }
+  let result2;
+  try {
+    result2 = await deps.executor.execute(message.connectionId, {
+      operation: mapping.operation,
+      params,
+      credentialRevision: message.connectionRevision
+    }, void 0, () => {
+      if (!deps.stillSending()) throw new Error("withdrawn");
+    });
+  } catch (error) {
+    if (error?.code === "SEND_FENCED") {
+      deps.onDiagnostic?.({
+        code: "REPLY_WITHDRAWN",
+        message: "the reply was withdrawn before it was sent"
+      });
+      return "failed";
+    }
+    deps.onDiagnostic?.({ code: "REPLY_SEND_UNCONFIRMED", message: "the reply could not be confirmed" });
+    return "unknown";
+  }
+  const refusal = pollRefusal(contract, result2);
+  if (refusal.refused) {
+    deps.onDiagnostic?.({
+      code: "REPLY_REFUSED",
+      message: `the provider refused the reply (${refusal.reason})`
+    });
+    return "failed";
+  }
+  if (deps.onDelivered) {
+    const messageId2 = readProviderMessageId(deps.provider, result2.body);
+    if (messageId2) deps.onDelivered(messageId2);
+  }
+  return "sent";
+}
+const UPLOAD_TIMEOUT_MS = 12e4;
+function readString(body, key) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const value2 = body[key];
+  return typeof value2 === "string" && value2.length > 0 ? value2 : null;
+}
+async function uploadSlackFile(input) {
+  const contract = channelProviderContract("slack");
+  const fail2 = (code, message) => {
+    input.onDiagnostic?.({ code, message });
+    return "failed";
+  };
+  const fence = () => {
+    if (!input.stillCurrent()) throw new Error("withdrawn");
+  };
+  if (!input.stillCurrent()) return fail2("FILE_UPLOAD_WITHDRAWN", "the connection changed before the file was sent");
+  try {
+    const ticket = await input.executor.execute(input.connectionId, {
+      operation: "filesGetUploadURLExternal",
+      params: { filename: input.fileName, length: input.bytes.byteLength },
+      credentialRevision: input.connectionRevision
+    }, void 0, fence);
+    if (pollRefusal(contract, ticket).refused) {
+      return fail2("FILE_UPLOAD_REFUSED", "Slack refused the upload (is files:write granted?)");
+    }
+    const uploadUrl = readString(ticket.body, "upload_url");
+    const fileId = readString(ticket.body, "file_id");
+    if (!uploadUrl || !fileId) return fail2("FILE_UPLOAD_REFUSED", "Slack answered without an upload URL");
+    let target;
+    try {
+      target = assertDestinationAllowed(uploadUrl, { allowedOrigins: SLACK_FILE_UPLOAD_ORIGINS, rejectPrivateNetwork: true });
+    } catch {
+      return fail2("FILE_UPLOAD_ORIGIN_REFUSED", "Slack named an upload host outside the allowlist");
+    }
+    if (!input.stillCurrent()) return fail2("FILE_UPLOAD_WITHDRAWN", "the connection changed before the file was sent");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), UPLOAD_TIMEOUT_MS);
+    let status;
+    try {
+      const response2 = await (input.fetchImpl ?? fetch)(target.toString(), {
+        method: "POST",
+        headers: { "content-type": "application/octet-stream" },
+        // A copy on its own ArrayBuffer: what `fetch` accepts as a body, whatever backed the input.
+        body: new Uint8Array(input.bytes),
+        redirect: "manual",
+        signal: controller.signal
+      });
+      status = response2.status;
+      void response2.body?.cancel().catch(() => {
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (status < 200 || status >= 300) return fail2("FILE_UPLOAD_REFUSED", `the upload host answered ${status}`);
+    const completed = await input.executor.execute(input.connectionId, {
+      operation: "filesCompleteUploadExternal",
+      params: {
+        files: JSON.stringify([{ id: fileId, title: input.fileName }]),
+        channel_id: input.destination.conversationRef,
+        ...input.destination.threadRef ? { thread_ts: input.destination.threadRef } : {}
+      },
+      credentialRevision: input.connectionRevision
+    }, void 0, fence);
+    if (pollRefusal(contract, completed).refused) return fail2("FILE_UPLOAD_REFUSED", "Slack refused to post the file");
+    return "sent";
+  } catch (error) {
+    if (error?.code === "SEND_FENCED") {
+      return fail2("FILE_UPLOAD_WITHDRAWN", "the connection changed before the file was sent");
+    }
+    return fail2("FILE_UPLOAD_UNCONFIRMED", "the file upload could not be confirmed");
+  }
+}
+const MAX_PENDING = 100;
+const MAX_ACTIVE_DELIVERIES = 2;
+class ChannelFileReplies {
+  constructor(options) {
+    this.options = options;
+    this.enabled = "filesGetUploadURLExternal" in channelProviderContract(options.provider).operations;
+  }
+  // Shared across connections: capacity is acquired before locating or reading any file.
+  static active = 0;
+  static waiting = [];
+  pending = /* @__PURE__ */ new Map();
+  enabled;
+  /** The text to queue in place of `text`. Unchanged unless it names files this provider can send. */
+  prepareFinal(binding, text2) {
+    if (!this.enabled) return text2;
+    const extracted = extractChannelFileMarkers(text2);
+    if (extracted.paths.length === 0) return text2;
+    if (this.pending.size >= MAX_PENDING && !this.pending.has(binding.requestId)) {
+      return [extracted.text, this.noticeText(extracted.paths.length, extracted.paths.length)].filter(Boolean).join("\n\n");
+    }
+    this.pending.set(binding.requestId, { binding, paths: extracted.paths });
+    return extracted.text || channelText({ en: "📎 Sending the files.", ko: "📎 파일을 보내요." });
+  }
+  /** No text was admitted/durably recorded, so there is no attachment obligation. */
+  discard(requestId) {
+    this.pending.delete(requestId);
+  }
+  /** The answer's delivery was decided. Resolves when its files are done; callers need not wait. */
+  async settled(message) {
+    const pending2 = this.pending.get(message.requestId);
+    if (!pending2) return;
+    this.pending.delete(message.requestId);
+    if (message.state !== "sent") return;
+    if (ChannelFileReplies.waiting.length >= MAX_PENDING) {
+      await this.attempt(() => this.notify(pending2.binding, pending2.paths.length, pending2.paths.length));
+      return;
+    }
+    await new Promise((resolve2) => {
+      ChannelFileReplies.waiting.push({ run: () => this.attempt(() => this.deliver(pending2)), resolve: resolve2 });
+      ChannelFileReplies.drain();
+    });
+  }
+  static drain() {
+    while (this.active < MAX_ACTIVE_DELIVERIES && this.waiting.length > 0) {
+      const job = this.waiting.shift();
+      this.active += 1;
+      void job.run().finally(() => {
+        this.active -= 1;
+        job.resolve();
+        this.drain();
+      });
+    }
+  }
+  async attempt(run2) {
+    try {
+      await run2();
+    } catch {
+      this.options.onDiagnostic?.({ code: "FILE_REPLY_FAILED", message: "the files could not be delivered" });
+    }
+  }
+  async deliver({ binding, paths }) {
+    const current2 = () => this.options.isCurrent(binding.connectionRevision);
+    if (!current2()) return;
+    const attempted = paths.slice(0, CHANNEL_FILE_REPLY_MAX_FILES);
+    let failed = paths.length - attempted.length;
+    const location2 = await this.options.locate(binding.sessionId).catch(() => null);
+    for (const path2 of attempted) {
+      if (!current2()) return;
+      if (!location2) {
+        failed += 1;
+        continue;
+      }
+      const file = await readChannelSessionFile({ location: location2, path: path2, callMachineRpc: this.options.callMachineRpc });
+      if (!file.ok) {
+        this.options.onDiagnostic?.({ code: "FILE_REPLY_REFUSED", message: `a named file was not sent (${file.reason})` });
+        failed += 1;
+        continue;
+      }
+      const outcome = await uploadSlackFile({
+        connectionId: binding.connectionId,
+        connectionRevision: binding.connectionRevision,
+        destination: binding.destination,
+        fileName: file.fileName,
+        bytes: file.bytes,
+        executor: this.options.executor,
+        stillCurrent: current2,
+        ...this.options.fetchImpl ? { fetchImpl: this.options.fetchImpl } : {},
+        ...this.options.onDiagnostic ? { onDiagnostic: this.options.onDiagnostic } : {}
+      });
+      if (outcome !== "sent") failed += 1;
+    }
+    if (failed > 0 && current2()) await this.notify(binding, failed, paths.length);
+  }
+  noticeText(failed, total) {
+    return channelText({
+      en: `⚠️ ${failed} of ${total} file(s) could not be attached. Open the session in Saycode to get them.`,
+      ko: `⚠️ 파일 ${total}개 중 ${failed}개를 첨부하지 못했어요. Saycode에서 세션을 열어 확인하세요.`
+    });
+  }
+  /** One line, no paths: which files were refused is the session's business, not the channel's. */
+  async notify(binding, failed, total) {
+    if (!this.options.isCurrent(binding.connectionRevision)) return;
+    const body = this.noticeText(failed, total);
+    const notice = {
+      id: `file-notice:${binding.requestId}`,
+      sequence: 0,
+      connectionId: binding.connectionId,
+      connectionRevision: binding.connectionRevision,
+      requestId: `file-notice:${binding.requestId}`,
+      sessionId: binding.sessionId,
+      destination: binding.destination,
+      body,
+      state: "sending",
+      attempts: 0,
+      createdAt: this.options.now(),
+      kind: "status"
+    };
+    const current2 = () => this.options.isCurrent(binding.connectionRevision);
+    await sendChannelOutbound(notice, {
+      provider: this.options.provider,
+      executor: this.options.executor,
+      isCurrent: current2,
+      stillSending: current2,
+      ...this.options.onDiagnostic ? { onDiagnostic: this.options.onDiagnostic } : {}
+    });
+  }
+}
+function channelFileReplyHooks(source2, input) {
+  if (!source2) return {};
+  const { principalKey, ...options } = input;
+  const files = new ChannelFileReplies({
+    ...options,
+    locate: (sessionId) => source2.locate(principalKey, sessionId),
+    callMachineRpc: source2.callMachineRpc
+  });
+  return {
+    prepareFinal: (binding, text2) => files.prepareFinal(binding, text2),
+    onReplySettled: (message) => {
+      void files.settled(message);
+    },
+    onReplyDiscarded: (requestId) => files.discard(requestId)
+  };
+}
+const FILE_REPLY_HINT = `[Saycode · Slack] To send a file back to this thread, add a line \`MEDIA:<path in the working directory>\` to your final answer (up to ${CHANNEL_FILE_REPLY_MAX_FILES} files, ${CHANNEL_FILE_REPLY_MAX_BYTES / 1024 / 1024} MB each).`;
+function withChannelFileReplyHint(connection, operations) {
+  if (!connection.filesAttachable || !("filesGetUploadURLExternal" in channelProviderContract(connection.provider).operations)) return operations;
+  const prompt = (input) => operations.prompt({ ...input, text: `${input.text}
+
+${FILE_REPLY_HINT}` });
+  return Object.assign(Object.create(operations), { prompt });
+}
+async function withdrawIntakeDurably(cancelled, connectionKeys, deps) {
+  const undurable = await journalCancelledIntake(cancelled, deps);
+  if (undurable.length === 0) return EMPTY_WITHDRAWAL;
+  const unsafeToReopen = [];
+  for (const key of connectionKeys) {
+    try {
+      await deps.revokeGeneration(key);
+    } catch {
+      unsafeToReopen.push(key);
+      deps.onDiagnostic?.({
+        code: "INTAKE_WITHDRAWAL_NOT_ENFORCEABLE",
+        message: "a withdrawal was neither recorded nor fenced by a generation move"
+      });
+    }
+  }
+  return Object.freeze({ unsafeToReopen: Object.freeze(unsafeToReopen) });
+}
+const EMPTY_WITHDRAWAL = Object.freeze({
+  unsafeToReopen: Object.freeze([])
+});
+async function journalCancelledIntake(entries, deps) {
+  const undurable = [];
+  for (const entry of entries) {
+    try {
+      await deps.journal.record(entry);
+    } catch {
+      undurable.push(entry.id);
+      deps.onDiagnostic?.({
+        code: "INTAKE_CANCELLATION_NOT_DURABLE",
+        message: "a cancelled request could not be recorded"
+      });
+    }
+  }
+  return Object.freeze(undurable);
+}
+function intakeStateForTurnOutcome(outcome) {
+  if (outcome.kind === "final") return "executed";
+  if (outcome.status === "cancelled") return "cancelled";
+  if (outcome.status === "no-final-answer") return "executed";
+  return "failed";
+}
+async function settleIntakeEntry(queue, requestId, state, deps) {
+  let settled;
+  try {
+    settled = queue.transition(requestId, state);
+  } catch {
+    return;
+  }
+  try {
+    await deps.journal.record(settled);
+  } catch {
+    deps.onDiagnostic?.({
+      code: "INTAKE_TERMINAL_NOT_DURABLE",
+      message: "a finished request could not be recorded"
+    });
+  }
+}
 const PROGRESS_MIN_EDIT_INTERVAL_MS = 1500;
 const PROGRESS_HEARTBEAT_MS = 6e4;
 const PROGRESS_TERMINAL_ATTEMPTS = 3;
@@ -91115,64 +92279,6 @@ function frozenRequestBinding(binding) {
     destination: Object.freeze({ ...binding.destination })
   });
 }
-async function sendChannelOutbound(message, deps) {
-  const contract = channelProviderContract(deps.provider);
-  const mapping = contract.outbound;
-  if (message.body.length > mapping.maxTextLength) {
-    deps.onDiagnostic?.({
-      code: "REPLY_TOO_LONG",
-      message: `the reply exceeds ${mapping.maxTextLength} characters for this provider`
-    });
-    return "failed";
-  }
-  if (!deps.isCurrent()) return "failed";
-  const params = {
-    [mapping.conversationParam]: message.destination.conversationRef,
-    [mapping.textParam]: message.body
-  };
-  if (mapping.threadParam && message.destination.threadRef) {
-    params[mapping.threadParam] = message.destination.threadRef;
-  }
-  if (mapping.replyToParam && message.destination.replyToTransportEventId) {
-    params[mapping.replyToParam] = mapping.replyToIsStructured && mapping.replyToStructuredField ? { [mapping.replyToStructuredField]: message.destination.replyToTransportEventId } : message.destination.replyToTransportEventId;
-  }
-  if (deps.interactive && mapping.interactiveParam) {
-    params[mapping.interactiveParam] = deps.interactive;
-  }
-  let result2;
-  try {
-    result2 = await deps.executor.execute(message.connectionId, {
-      operation: mapping.operation,
-      params,
-      credentialRevision: message.connectionRevision
-    }, void 0, () => {
-      if (!deps.stillSending()) throw new Error("withdrawn");
-    });
-  } catch (error) {
-    if (error?.code === "SEND_FENCED") {
-      deps.onDiagnostic?.({
-        code: "REPLY_WITHDRAWN",
-        message: "the reply was withdrawn before it was sent"
-      });
-      return "failed";
-    }
-    deps.onDiagnostic?.({ code: "REPLY_SEND_UNCONFIRMED", message: "the reply could not be confirmed" });
-    return "unknown";
-  }
-  const refusal = pollRefusal(contract, result2);
-  if (refusal.refused) {
-    deps.onDiagnostic?.({
-      code: "REPLY_REFUSED",
-      message: `the provider refused the reply (${refusal.reason})`
-    });
-    return "failed";
-  }
-  if (deps.onDelivered) {
-    const messageId2 = readProviderMessageId(deps.provider, result2.body);
-    if (messageId2) deps.onDelivered(messageId2);
-  }
-  return "sent";
-}
 function fail(detail) {
   throw new Error(`extension wire message must be JSON-serializable: ${detail}`);
 }
@@ -91612,9 +92718,9 @@ class ChannelReplyRuntime {
       this.bindings.delete(outcome.requestId);
     } else if (launchesContinuation) this.backgroundContinuations.set(outcome.requestId, 1);
     else this.bindings.delete(outcome.requestId);
-    const body = outcome.kind === "final" ? outcome.text : channelTurnFailureText(outcome.status);
     const replyBinding = continuationIndex === void 0 ? binding : { ...binding, requestId: `${binding.requestId}:background:${continuationIndex}` };
-    await this.enqueueReply(replyBinding, body);
+    const body = outcome.kind === "final" ? this.options.prepareFinal?.(replyBinding, outcome.text) ?? outcome.text : channelTurnFailureText(outcome.status);
+    if (!await this.enqueueReply(replyBinding, body)) this.options.onReplyDiscarded?.(replyBinding.requestId);
     this.drain(binding.sessionId);
     return outcome;
   }
@@ -91707,7 +92813,7 @@ class ChannelReplyRuntime {
         code: "REPLY_NOT_ADMITTED",
         message: `the reply was not admitted (${admission.reason})`
       });
-      return;
+      return false;
     }
     try {
       await this.options.journal.recordOutbound(admission.message);
@@ -91717,9 +92823,10 @@ class ChannelReplyRuntime {
         code: "REPLY_NOT_DURABLE",
         message: "the reply could not be recorded"
       });
-      return;
+      return false;
     }
     this.options.outbox.commit(admission.message);
+    return true;
   }
   /** Serial per session; a second call while one is draining joins rather than overlapping. */
   drain(sessionId) {
@@ -91750,6 +92857,7 @@ class ChannelReplyRuntime {
       const settled = this.options.outbox.transition(message.id, outcome);
       await this.options.journal.recordOutbound(settled);
       await this.options.journal.recordOutboundTombstone(tombstoneOf(settled));
+      this.options.onReplySettled?.(settled);
     }
   }
   /** Both halves of "may this reply still leave": the live composition *and* a live adapter. */
@@ -91975,11 +93083,22 @@ class ChannelConnectionComposition {
         mintHandle: this.options.mintId
       }),
       progress,
+      filesAttachable: this.options.sessionFiles !== void 0,
       reply: new ChannelReplyRuntime({
         // Display only, and deliberately after every delivery decision: the rail is handed the
         // provider's id for an acknowledgement that has already been delivered, so nothing here
         // can affect whether a reply goes out or how it is recorded.
         onStatusDelivered: (message, messageId2) => progress.adopt(message, messageId2),
+        // After delivery too: an answer's files leave only once the answer itself was sent.
+        ...channelFileReplyHooks(this.options.sessionFiles, {
+          provider: input.provider,
+          principalKey: input.principalKey,
+          executor: this.outboundExecutor,
+          now: this.options.now,
+          isCurrent: (revision) => this.parts.get(input.identity.connectionId) === parts2 && this.options.generations.current(connectionKey) === revision && (this.options.adapterLive?.(input.identity.connectionId, input.provider) ?? false),
+          ...this.options.fetchImpl ? { fetchImpl: this.options.fetchImpl } : {},
+          ...this.options.onDiagnostic ? { onDiagnostic: this.options.onDiagnostic } : {}
+        }),
         ...this.options.formatReply ? { formatReply: this.options.formatReply } : {},
         provider: input.provider,
         connectionId: input.identity.connectionId,
@@ -92146,6 +93265,39 @@ function bindChannelControlRequest(input, deps) {
     return { ok: false, code: typeof code === "string" ? code : "REQUEST_REFUSED" };
   }
 }
+async function adoptInvitedMentionGrant(input) {
+  const { event, identity, grants } = input;
+  const subject = { connectionId: event.connectionId, senderRef: event.sender.ref, conversationRef: event.conversation.ref };
+  if (grants.find(identity, subject)) return "existing";
+  if (event.invitedMention !== true || event.sender.bot || event.connectionId !== identity.connectionId) return "none";
+  const source2 = grants.list(identity).find((grant) => grant.senderRef === event.sender.ref);
+  if (!source2 || source2.revision !== event.connectionRevision) return "none";
+  try {
+    await grants.putDurable(identity, { ...source2, conversationRef: event.conversation.ref, allowedSessionRefs: [] });
+    return "adopted";
+  } catch {
+    return "none";
+  }
+}
+function channelInvitedMentionText() {
+  return channelText({
+    en: "👋 I’ll answer your mentions in this channel from now on. Replies here are visible to everyone in this channel.",
+    ko: "👋 이제 이 채널에서도 멘션에 답할게요. 여기 답변은 채널 멤버 모두에게 보여요."
+  });
+}
+async function adoptInvitedMention(input, deps) {
+  const outcome = await adoptInvitedMentionGrant({ event: input.event, identity: deps.parts.identity, grants: deps.grants });
+  if (outcome !== "adopted" || !deps.answerable()) return;
+  await deps.parts.reply.replyStatus({
+    // Its own request id: the acknowledgement that follows owns `status:<requestId>`.
+    requestId: `${input.requestId}:invited`,
+    connectionId: input.connectionId,
+    connectionRevision: input.event.connectionRevision,
+    sessionId: `command:${input.connectionId}`,
+    destination: input.event.destination,
+    boundAt: deps.now()
+  }, channelInvitedMentionText());
+}
 const SYNCHRONOUS_OPERATIONS = new Set(
   CHANNEL_SESSION_OPERATIONS.filter((operation) => operation !== "prompt")
 );
@@ -92166,6 +93318,7 @@ async function dispatchChannelControl(input, deps) {
     });
     return !!authCustody.current(parts2.principalKey) && !!current2 && current2.revision === input.event.connectionRevision && generations.current(connectionKey) === input.event.connectionRevision;
   };
+  await adoptInvitedMention(input, { parts: parts2, grants, answerable, now: deps.now });
   const word = classifyChannelCommandWord(input.event.text ?? "");
   if (word) {
     if (answerable()) {
@@ -96160,7 +97313,7 @@ function createChannelRequestCoordinator(deps) {
       generations,
       grants,
       custody: authCustody,
-      operations,
+      operations: withChannelFileReplyHint(parts2, operations),
       isEstopEngaged: () => options.isEstopEngaged(),
       ...options.mayActForConnection ? { mayActForConnection: options.mayActForConnection } : {},
       ownership,
@@ -98351,6 +99504,11 @@ async function assemble(options, rootDir) {
     now: () => Date.now(),
     mintId: () => randomUUID(),
     onRequestSettled: (requestId) => forgetRequest?.(requestId),
+    // Files a Slack answer names, read from the session's own machine (specs/channel-file-replies).
+    ...options.sessionFileRpc ? { sessionFiles: {
+      locate: createChannelSessionFileLocator({ authFor: (key) => authCustody.current(key), operations }),
+      callMachineRpc: options.sessionFileRpc
+    } } : {},
     approvalOpen: (approvalHandle) => approvalOpen?.(approvalHandle) ?? false,
     onDiagnostic: (detail) => options.onDiagnostic?.(detail),
     ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {},