@buzzni/saycode-cli 0.3.1 → 0.3.3

package/index.mjs

@@ -40,35 +40,36 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.3.1";
+const version = "0.3.3";
 const manifest = {
   version
 };
 const AGENT_CONTROL_VERBS = ["steer", "stop"];
-function parseAgentControlArgs(verb, target, rest) {
+function parseAgentControlArgs(verb, target, rest, hasPositionalTarget) {
   if (verb === "steer") {
     if (!target) return { command: "error", message: "agent steer needs a session id (see `saycode agent ls`)" };
-    const text2 = rest.slice(1).join(" ").trim();
+    const text2 = rest.slice(hasPositionalTarget ? 1 : 0).join(" ").trim();
     return text2 ? { command: "agent", verb: "steer", sessionId: target, text: text2 } : { command: "error", message: "agent steer needs the text to send" };
   }
   if (verb === "stop") {
     if (!target) return { command: "error", message: "agent stop needs a session id (see `saycode agent ls`)" };
-    return rest.length === 1 ? { command: "agent", verb: "stop", sessionId: target } : { command: "error", message: "agent stop takes exactly one session id" };
+    return rest.length === (hasPositionalTarget ? 1 : 0) ? { command: "agent", verb: "stop", sessionId: target } : { command: "error", message: "agent stop takes exactly one session id" };
   }
   return null;
 }
 const AGENT_VERBS = ["whoami", "ls", "read", "wait", "prompt", "spawn", ...AGENT_CONTROL_VERBS];
-function fail(message) {
+function fail$1(message) {
   return { command: "error", message };
 }
 function parseAgentArgs(flags, positionals) {
   const [verb, ...rest] = positionals;
   if (!verb || !AGENT_VERBS.includes(verb)) {
-    return fail(`agent needs one of: ${AGENT_VERBS.join(", ")}`);
+    return fail$1(`agent needs one of: ${AGENT_VERBS.join(", ")}`);
   }
   const timeout = flags.timeoutMs !== void 0 ? { timeoutMs: flags.timeoutMs } : {};
-  const target = rest[0] ?? flags.sessionId;
-  const control = parseAgentControlArgs(verb, target, rest);
+  const hasPositionalTarget = flags.sessionId === void 0 && rest[0] !== void 0;
+  const target = flags.sessionId ?? rest[0];
+  const control = parseAgentControlArgs(verb, target, rest, hasPositionalTarget);
   if (control) return control;
   switch (verb) {
     case "whoami":
@@ -76,18 +77,18 @@ function parseAgentArgs(flags, positionals) {
     case "ls":
       return { command: "agent", verb: "ls" };
     case "read": {
-      if (!target) return fail("agent read needs a session id (see `saycode agent ls`)");
+      if (!target) return fail$1("agent read needs a session id (see `saycode agent ls`)");
       return { command: "agent", verb: "read", sessionId: target, ...flags.last !== void 0 ? { last: flags.last } : {} };
     }
     case "wait": {
-      if (!target) return fail("agent wait needs a session id (see `saycode agent ls`)");
-      if (!flags.until) return fail("agent wait needs --until turn-end|waiting-input|completed");
+      if (!target) return fail$1("agent wait needs a session id (see `saycode agent ls`)");
+      if (!flags.until) return fail$1("agent wait needs --until turn-end|waiting-input|completed");
       return { command: "agent", verb: "wait", sessionId: target, until: flags.until, ...timeout };
     }
     case "prompt": {
-      if (!target) return fail("agent prompt needs a session id (see `saycode agent ls`)");
-      const text2 = rest.slice(1).join(" ").trim();
-      if (!text2) return fail("agent prompt needs the text to send");
+      if (!target) return fail$1("agent prompt needs a session id (see `saycode agent ls`)");
+      const text2 = rest.slice(hasPositionalTarget ? 1 : 0).join(" ").trim();
+      if (!text2) return fail$1("agent prompt needs the text to send");
       return {
         command: "agent",
         verb: "prompt",
@@ -103,36 +104,40 @@ function parseAgentArgs(flags, positionals) {
       const files = flags.files ?? [];
       if (flags.handoff) {
         if (flags.prompt !== void 0) {
-          return fail("agent spawn --handoff sends the conversation, so it cannot also take --prompt");
+          return fail$1("agent spawn --handoff sends the conversation, so it cannot also take --prompt");
         }
         if (files.length > 0) {
-          return fail("agent spawn --handoff sends the conversation, so it cannot also take --file");
+          return fail$1("agent spawn --handoff sends the conversation, so it cannot also take --file");
         }
         const mode = flags.mode?.trim() || "summary";
         if (mode === "full") {
-          return fail("agent spawn --handoff does not support --mode full yet; only summary is available");
+          return fail$1("agent spawn --handoff does not support --mode full yet; only summary is available");
         }
-        if (mode !== "summary") return fail(`agent spawn --handoff got an unknown --mode: ${mode}`);
+        if (mode !== "summary") return fail$1(`agent spawn --handoff got an unknown --mode: ${mode}`);
         const from = flags.from?.trim();
         return {
           command: "agent",
           verb: "spawn",
           handoff: { mode: "summary", ...from ? { from } : {} },
-          ...flags.agent ? { agent: flags.agent } : {}
+          ...flags.agent ? { agent: flags.agent } : {},
+          ...flags.model !== void 0 ? { model: flags.model } : {},
+          ...flags.effort !== void 0 ? { effort: flags.effort } : {}
         };
       }
       const text2 = flags.prompt?.trim();
-      if (!text2) return fail("agent spawn needs --prompt <text>");
+      if (!text2) return fail$1("agent spawn needs --prompt <text>");
       return {
         command: "agent",
         verb: "spawn",
         text: text2,
         ...flags.agent ? { agent: flags.agent } : {},
+        ...flags.model !== void 0 ? { model: flags.model } : {},
+        ...flags.effort !== void 0 ? { effort: flags.effort } : {},
         ...files.length > 0 ? { files } : {}
       };
     }
     default:
-      return fail(`unsupported agent verb: ${verb}`);
+      return fail$1(`unsupported agent verb: ${verb}`);
   }
 }
 function fencedMarkdownRanges(content) {
@@ -296,7 +301,8 @@ const completionInboxKo = {
   "completionInbox.emptyReadDescription": "확인한 알림이 여기에 표시됩니다.",
   "completionInbox.unreadList": "미확인 알림 목록",
   "completionInbox.readList": "확인한 알림 목록",
-  "completionInbox.projectFallback": "프로젝트"
+  "completionInbox.projectFallback": "프로젝트",
+  "completionInbox.platformNoticeFallbackTitle": "알림"
 };
 const agentBoardKo = {
   "agentBoard.preparingResponse": "응답을 준비하는 중…",
@@ -810,12 +816,21 @@ const extensionPanelKo = {
 };
 const extensionInstallKo = {
   "extensions.installOfficial": "확장 설치",
+  "extensions.installArtifactPublisher": "공개 링크 확장 설치",
   "extensions.installDescription": "계속하려면 공식 확장을 설치하세요.",
   "extensions.machineExecutePermission": "이 확장은 미리 정의된 동작에만 machine.execute 권한을 요청합니다.",
   "extensions.notInstalled": "요청한 확장이 설치되지 않았습니다.",
   "extensions.disabled": "요청한 확장이 비활성화되어 있습니다.",
   "extensions.quarantined": "요청한 확장이 반복된 오류로 격리되었습니다.",
-  "extensions.unavailable": "요청한 확장이 설치되어 있지만 현재 사용할 수 없습니다."
+  "extensions.unavailable": "요청한 확장이 설치되어 있지만 현재 사용할 수 없습니다.",
+  "extensions.permission.artifactPublishPublic": "선택한 결과물의 공개 링크를 만들 수 있습니다. 파일 내용과 링크 처리는 Saycode Core가 담당합니다.",
+  "artifactPublication.dialogTitle": "공개 링크",
+  "artifactPublication.copy": "링크 복사",
+  "artifactPublication.copied": "복사됨",
+  "artifactPublication.open": "링크 열기",
+  "artifactPublication.revoke": "공개 중지",
+  "artifactPublication.revoking": "중지 중…",
+  "artifactPublication.failed": "공개 링크 작업에 실패했습니다."
 };
 const personalChatsLandingKo = {
   "personalChats.heroTitle": "무엇을 도와드릴까요?",
@@ -1126,7 +1141,9 @@ const machineSettingsConsoleKo = {
   "machineConsole.updateTimeout": "업데이트가 시작됐지만 완료를 확인하지 못했습니다. 잠시 후 다시 진단해 주세요.",
   "machineConsole.updateFailed": "CLI 업데이트에 실패했습니다.",
   "machineConsole.aiCliStarted": "Codex와 Claude Code 설치를 시작했습니다.",
-  "machineConsole.aiCliFailed": "AI CLI 설치를 시작하지 못했습니다."
+  "machineConsole.aiCliFailed": "AI CLI 설치를 시작하지 못했습니다.",
+  "machineConsole.machineActionFailed": "머신 작업에 실패했습니다.",
+  "machineConsole.extensionCommandsUnavailable": "Extension 명령을 사용할 수 없습니다."
 };
 const sessionTokenUsageKo = {
   "sessionTokenUsage.total": "누적 {count} 토큰",
@@ -1254,7 +1271,12 @@ const additionalDirectoriesKo = {
   "additionalDirectories.limitReached": "추가 디렉터리는 최대 8개까지 등록할 수 있습니다.",
   "additionalDirectories.machineMismatch": "현재 머신과 다른 위치에서 선택한 디렉터리입니다.",
   "additionalDirectories.saveFailed": "디렉터리를 등록하지 못했습니다.",
-  "additionalDirectories.folderLoadFailed": "디렉터리를 불러오지 못했습니다."
+  "additionalDirectories.folderLoadFailed": "디렉터리를 불러오지 못했습니다.",
+  "additionalDirectories.relatedMountMissing": "관련 프로젝트 디렉터리 {count}개를 자동 마운트에서 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountLinkLookupFailed": "관련 프로젝트 목록을 불러오지 못해 자동 마운트 없이 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountLookupFailed": "관련 프로젝트 {count}개를 불러오지 못해 제외하고 세션을 시작했습니다.",
+  "additionalDirectories.relatedMountRuntimeUnsupported": "이 머신의 Happy CLI가 관련 프로젝트 자동 마운트를 지원하지 않아 기본 세션으로 시작했습니다.",
+  "additionalDirectories.relatedMountLimit": "관련 프로젝트 디렉터리 상한을 넘어 {count}개를 제외하고 세션을 시작했습니다."
 };
 const agentHandoffKo = {
   "agentHandoff.open": "다른 에이전트로 이어가기",
@@ -1323,6 +1345,18 @@ const subagentKo = {
   "subagent.error.inFlight": "이전 제어 요청을 처리하는 중입니다.",
   "subagent.error.rejected": "요청이 거부됐습니다: {detail}"
 };
+const reviewNavigationKo = {
+  "review.action.openSourceSession": "원본 대화로 이동: {title}"
+};
+const chatFolderUploadKo = {
+  "upload.kindFolder": "폴더",
+  "upload.folderReference": "{path} ({count}개 파일)",
+  "upload.folderChip": "{name} · {count}개 파일",
+  "upload.folderEmpty": "폴더에 업로드할 파일이 없습니다: {name}",
+  "upload.progress": "파일 업로드 중 {done}/{total}",
+  "upload.partialIssue": "업로드 실패 {failed}개 · 건너뜀 {skipped}개",
+  "upload.invalidPath": "안전하지 않은 첨부 경로입니다."
+};
 const aiCommitPrKo = {
   "aiCommitPr.stagedCount": "스테이지된 파일 {count}개",
   "aiCommitPr.noStaged": "스테이지된 변경이 없습니다.",
@@ -1363,7 +1397,46 @@ const aiCommitPrKo = {
   "aiCommitPr.pr.create": "Pull Request 만들기",
   "aiCommitPr.pr.creating": "만드는 중…"
 };
-const catalogExtensionsKo = { ...taskNotificationKo, ...machineUsageKo, ...completionInboxKo, ...agentBoardKo, ...fanoutLifecycleKo, ...conversationSearchKo, ...browserCookieImportKo, ...orcaPortKo, ...usageAnalyticsKo, ...outboundWebhookKo, ...scheduledAutomationsKo, ...githubTriggersKo, ...memoryHubKo, ...extensionPanelKo, ...extensionInstallKo, ...personalChatsKo, ...newSessionStarterKo, ...browserConsoleCaptureKo, ...completionSignalKo, ...agentLoopDetectionKo, ...operationModelRetryKo, ...skillCatalogKo, ...ciAutoFixKo, ...collaborationKo, ...backgroundTaskKo, ...sessionTitleKo, ...accountSettingsKo, ...projectScopeKo, ...machineSettingsConsoleKo, ...sessionTokenUsageKo, ...worktreeSetupKo, ...connectionIndicatorKo, ...voiceDictationKo, ...newSessionProfileKo, ...agentBoardBroadcastKo, ...judgementEvidenceKo, ...releaseNoteKo, ...notificationSoundKo, ...officeViewerKo, ...additionalDirectoriesKo, ...agentHandoffKo, ...sidebarUpdateKo, ...autopilotSelfReviewRoundsKo, ...aiCommitPrKo, ...externalWorktreeInboxKo, ...externalSessionVaultKo, ...terminalFontKo, ...globalPauseKo, ...subagentKo };
+const projectHandoffKo = {
+  "projectHandoff.loading": "핸드오프를 확인하는 중…",
+  "projectHandoff.notFound": "핸드오프를 찾을 수 없습니다.",
+  "projectHandoff.autoApproving": "자동 승인 중…",
+  "projectHandoff.autoApproveFailed": "자동 승인에 실패했습니다.",
+  "projectHandoff.status.queued": "대기 중",
+  "projectHandoff.status.running": "진행 중",
+  "projectHandoff.status.completed": "완료됨",
+  "projectHandoff.status.failed": "실패함",
+  "projectHandoff.status.cancelled": "거절됨",
+  "projectHandoff.status.blocked": "막힘",
+  "projectHandoff.indicatorLabel": "넘긴 작업 {count}건 진행 중"
+};
+const projectLinksKo = {
+  "projectLinks.empty": "등록된 관련 프로젝트가 없습니다.",
+  "projectLinks.loading": "불러오는 중…",
+  "projectLinks.loadFailed": "관련 프로젝트를 불러오지 못했습니다.",
+  "projectLinks.unknownProject": "알 수 없는 프로젝트",
+  "projectLinks.removeAria": "{name} 관련 등록 해제",
+  "projectLinks.removeFailed": "관련 등록을 해제하지 못했습니다.",
+  "projectLinks.selectProject": "프로젝트 선택",
+  "projectLinks.selectProjectAria": "관련 프로젝트로 등록할 프로젝트",
+  "projectLinks.rolePlaceholder": "역할 (예: 웹, 백엔드, 앱)",
+  "projectLinks.add": "등록",
+  "projectLinks.adding": "등록 중…",
+  "projectLinks.addFailed": "관련 프로젝트를 등록하지 못했습니다.",
+  "projectLinks.noCandidates": "등록할 수 있는 다른 프로젝트가 없습니다.",
+  "projectLinks.unavailableInDemo": "데모 모드에서는 관련 프로젝트를 관리할 수 없습니다.",
+  "projectLinks.mcpToggleLabel": "AI가 이 프로젝트에서 작업을 넘길 수 있게 허용",
+  "projectLinks.mcpToggleHint": "켜면 AI가 관련 프로젝트로 작업을 제안했을 때 확인 없이 바로 진행됩니다.",
+  "projectLinks.mcpToggleFailed": "설정을 바꾸지 못했습니다."
+};
+const connectorReadinessKo = {
+  "connectorReadiness.badge": "커넥터 {count}건 확인 필요",
+  "connectorReadiness.state.needsAuth": "다시 연결 필요",
+  "connectorReadiness.state.runtimeFailed": "연결 실패",
+  "connectorReadiness.state.configMissing": "설정 없음",
+  "connectorReadiness.state.unknown": "상태 미확인"
+};
+const catalogExtensionsKo = { ...taskNotificationKo, ...machineUsageKo, ...completionInboxKo, ...agentBoardKo, ...fanoutLifecycleKo, ...conversationSearchKo, ...browserCookieImportKo, ...orcaPortKo, ...usageAnalyticsKo, ...outboundWebhookKo, ...scheduledAutomationsKo, ...githubTriggersKo, ...memoryHubKo, ...extensionPanelKo, ...extensionInstallKo, ...personalChatsKo, ...newSessionStarterKo, ...browserConsoleCaptureKo, ...completionSignalKo, ...agentLoopDetectionKo, ...operationModelRetryKo, ...skillCatalogKo, ...ciAutoFixKo, ...collaborationKo, ...backgroundTaskKo, ...sessionTitleKo, ...accountSettingsKo, ...projectScopeKo, ...machineSettingsConsoleKo, ...sessionTokenUsageKo, ...worktreeSetupKo, ...connectionIndicatorKo, ...voiceDictationKo, ...newSessionProfileKo, ...agentBoardBroadcastKo, ...judgementEvidenceKo, ...releaseNoteKo, ...notificationSoundKo, ...officeViewerKo, ...additionalDirectoriesKo, ...agentHandoffKo, ...sidebarUpdateKo, ...autopilotSelfReviewRoundsKo, ...aiCommitPrKo, ...externalWorktreeInboxKo, ...externalSessionVaultKo, ...terminalFontKo, ...globalPauseKo, ...subagentKo, ...reviewNavigationKo, ...projectLinksKo, ...projectHandoffKo, ...chatFolderUploadKo, ...connectorReadinessKo };
 const onboardingKo = {
   "onboarding.dialogAria": "시작 설정",
   "onboarding.eyebrow": "처음 시작하기",
@@ -1459,6 +1532,44 @@ const ko = {
   "common.reset": "초기화",
   "common.cancel": "취소",
   "common.close": "닫기",
+  "networkDataSaver.transferConfirm": "{operation} 작업은 데이터를 많이 사용할 수 있습니다. 예상 크기: {size}. 계속할까요?",
+  "networkDataSaver.sizeUnknown": "알 수 없음",
+  "networkDataSaver.operation.update-download": "업데이트 다운로드",
+  "networkDataSaver.operation.file-upload": "파일 업로드",
+  "networkDataSaver.operation.folder-upload": "폴더 업로드",
+  "networkDataSaver.operation.file-download": "파일 다운로드",
+  "networkDataSaver.operation.project-deploy": "프로젝트 배포",
+  "networkDataSaver.operation.project-import": "프로젝트 가져오기",
+  "networkDataSaver.title": "네트워크 데이터 절약",
+  "networkDataSaver.description": "macOS가 비용이 들거나 저데이터 모드인 경로로 판단하면 백그라운드 데이터 사용을 자동으로 줄입니다.",
+  "networkDataSaver.loading": "네트워크 상태를 확인하는 중…",
+  "networkDataSaver.unsupported": "이 앱 버전에서는 네트워크 비용 상태를 확인할 수 없습니다.",
+  "networkDataSaver.status.active": "데이터 절약 중",
+  "networkDataSaver.status.inactive": "데이터 절약 꺼짐",
+  "networkDataSaver.modeLabel": "절약 방식",
+  "networkDataSaver.mode.automatic": "자동",
+  "networkDataSaver.mode.always-save": "항상 절약",
+  "networkDataSaver.mode.never-save": "절약 안 함",
+  "networkDataSaver.interfaceLabel": "현재 연결",
+  "networkDataSaver.interface.wifi": "Wi-Fi",
+  "networkDataSaver.interface.wired-ethernet": "유선 이더넷",
+  "networkDataSaver.interface.cellular": "셀룰러",
+  "networkDataSaver.interface.loopback": "로컬 연결",
+  "networkDataSaver.interface.other": "기타 연결",
+  "networkDataSaver.interface.unknown": "알 수 없음",
+  "networkDataSaver.reasonLabel": "판단 이유",
+  "networkDataSaver.reason.expensive": "비용이 드는 네트워크로 감지됨",
+  "networkDataSaver.reason.constrained": "저데이터 모드로 감지됨",
+  "networkDataSaver.reason.offline": "오프라인",
+  "networkDataSaver.reason.unrestricted": "일반 네트워크로 감지됨",
+  "networkDataSaver.reason.unknown": "네트워크 비용 상태를 알 수 없음",
+  "networkDataSaver.reason.user-always": "사용자가 항상 절약을 선택함",
+  "networkDataSaver.reason.user-never": "사용자가 절약 안 함을 선택함",
+  "networkDataSaver.deferred.title": "절약 중 지연되는 작업",
+  "networkDataSaver.activeHelp": "수동 새로고침은 계속 사용할 수 있고, 대용량 작업은 확인 후 한 번 허용할 수 있습니다.",
+  "networkDataSaver.deferred.model": "난이도 모델 최초 다운로드",
+  "networkDataSaver.deferred.memory": "Memory Layer 대화 백필",
+  "networkDataSaver.deferred.gitPr": "백그라운드 Git 및 PR 새로고침",
   "happyCliUpdate.title": "Happy CLI 업데이트가 있습니다",
   "happyCliUpdate.checkTitle": "Happy CLI 업데이트 확인",
   "happyCliUpdate.managerTitle": "Happy CLI 업데이트 관리",
@@ -2306,6 +2417,7 @@ const ko = {
   "projectSettings.tabRepository": "코드 저장소",
   "projectSettings.tabDeploy": "배포 저장소",
   "projectSettings.tabCollaboration": "협업",
+  "projectSettings.tabLinks": "관련 프로젝트",
   "projectSettings.tabMachine": "머신 및 경로",
   "projectSettings.tabRun": "실행",
   "projectSettings.tabMcp": "MCP 서버/스킬",
@@ -2935,6 +3047,7 @@ const ko = {
   "worktreeOp.checkingStatus": "worktree 상태 확인 중...",
   "worktreeOp.forceDeleteUnpushed": "worktree에 푸시되지 않은 커밋 {count}개가 있습니다. 강제로 삭제할까요? 커밋이 사라집니다.",
   "worktreeOp.forceDeleteDirty": "worktree에 정리되지 않은 변경이 있습니다. 강제로 삭제할까요? 변경 사항이 사라집니다.",
+  "worktreeOp.trackedChangesBlocked": "이 worktree에 커밋되지 않은 tracked 변경이 있습니다. 변경을 커밋하거나 stash하거나 명시적으로 버린 뒤 다시 시도하세요.",
   "worktreeOp.removeCancelled": "정리되지 않은 변경/커밋이 있어 삭제를 취소했습니다.",
   "worktreeOp.removed": "worktree를 삭제했습니다.",
   "project.sharedBy": " · 공유: {owner}",
@@ -3300,6 +3413,7 @@ const ko = {
   "saycodePromptPreference.eyebrow": "에이전트 지시 선택",
   "saycodePromptPreference.title": "Saycode 기본 지시를 사용할까요?",
   "saycodePromptPreference.body": "내가 만든 Claude/Codex 스킬과 하네스를 그대로 쓰려면 꺼진 상태를 유지하세요. 나중에 환경설정에서 언제든 바꿀 수 있습니다.",
+  "saycodePromptPreference.defaultOnNotice": "자식 Agent 호출, 내부 작업 위임, 결과물 인라인 미리보기는 기본으로 계속 켜집니다. 이 기능도 끄려면 환경설정 → 시스템 프롬프트에서 각각 해제하세요.",
   "saycodePromptPreference.keepOff": "꺼진 상태 유지",
   "saycodePromptPreference.enable": "Saycode 지시 켜기",
   "saycodePromptPreference.saving": "저장 중…",
@@ -3308,9 +3422,11 @@ const ko = {
   "saycodePromptPreference.settingsEnable": "Saycode가 제공하는 기본 행동 지시 사용",
   "saycodePromptPreference.settingsHelp": "사용자 시스템 프롬프트, 프로젝트 지침, 설치한 스킬과 하네스는 이 설정과 관계없이 유지됩니다.",
   "saycodePromptPreference.blocksTitle": "개별 지시 선택",
-  "saycodePromptPreference.blocksHelp": "Saycode 지시를 항목별로 켜고 끕니다. 선택하지 않은 항목은 위의 전체 설정을 따릅니다.",
+  "saycodePromptPreference.blocksHelp": "자식 Agent 호출, 내부 작업 위임, 결과물 인라인 미리보기는 기본으로 켜지며, 나머지 항목은 위의 전체 설정을 따릅니다.",
   "saycodePromptPreference.alwaysOnNotice": "채팅 제목 생성은 항상 켜져 있으며 끌 수 없습니다. 채팅 목록에서 대화를 다시 찾으려면 필요합니다.",
-  "saycodePromptPreference.block.workerDelegation.label": "작업 위임",
+  "saycodePromptPreference.block.agentOrchestration.label": "자식 Agent 호출",
+  "saycodePromptPreference.block.agentOrchestration.description": "자연어로 요청한 작업을 독립된 자식 Agent 세션에 맡기고 결과를 회수하도록 지시합니다.",
+  "saycodePromptPreference.block.workerDelegation.label": "내부 작업 위임",
   "saycodePromptPreference.block.workerDelegation.description": "기계적인 작업을 저렴한 worker 에이전트에 넘기도록 지시합니다.",
   "saycodePromptPreference.block.axBase.label": "기획부터 시작 워크플로우",
   "saycodePromptPreference.block.axBase.description": "AX 워크플로우의 기본 지시를 사용합니다.",
@@ -3351,6 +3467,7 @@ const ko = {
   "file.readFailed": "파일을 읽지 못했습니다.",
   "session.loadMessagesFailed": "대화 메시지를 불러올 수 없습니다.",
   "session.sendToSessionFailed": "대화에 메시지를 보낼 수 없습니다.",
+  "session.sendBlockedAccountKeyLocked": "이 대화는 계정 키로 잠겨 있습니다. 잠금을 해제한 뒤 다시 시도하세요.",
   "message.noEncryptKey": "메시지 삭제 이벤트를 암호화할 세션 키를 찾을 수 없습니다.",
   "machineSel.boundMissing": "프로젝트에 연결된 머신 정보를 찾을 수 없습니다. 새로고침 후 다시 시도해주세요.",
   "machineSel.connectedMachine": "연결된 머신",
@@ -3738,6 +3855,7 @@ const ko = {
   "settingsTab.language": "언어",
   "settingsTab.machines": "머신",
   "settingsTab.mobile": "모바일 연결",
+  "settingsTab.network": "네트워크 데이터 절약",
   "settingsTab.env": "환경 변수",
   "settingsTab.security": "보안",
   "settingsTab.memory": "Memory",
@@ -3746,12 +3864,15 @@ const ko = {
   "settingsTab.extensions": "확장",
   "settingsTab.about": "정보",
   "settingsTab.shortcuts": "단축키",
-  "extensions.help": "필요한 기능만 로컬 확장 패키지로 설치하고 관리합니다.",
+  "extensions.help": "필요한 기능만 공식 또는 로컬 확장 패키지로 설치하고 관리합니다.",
   "extensions.installLocal": "로컬 파일 설치",
   "extensions.loading": "설치된 확장을 불러오는 중입니다.",
   "extensions.empty": "설치된 확장이 없습니다.",
   "extensions.permissions": "권한",
   "extensions.noPermissions": "요청 권한 없음",
+  "extensions.permission.browserViewerOpen": "접근 가능한 온라인 머신에서 원격 Chrome 화면을 준비해 기본 브라우저로 엽니다. 소프트웨어 설치는 포함하지 않습니다.",
+  "extensions.permission.browserViewerInstall": "선택한 머신에 원격 화면용 시스템 패키지(Xvfb/noVNC)를 설치합니다. Chrome 설치는 포함하지 않습니다.",
+  "extensions.permission.browserViewerInstallChrome": "선택한 머신에 Google Chrome을 설치합니다. 머신의 시스템 소프트웨어가 변경됩니다.",
   "extensions.approvePermission": "'{permission}' 승인",
   "extensions.revokePermission": "'{permission}' 철회",
   "extensions.enable": "활성화",
@@ -4450,7 +4571,7 @@ Options
   -p, --project <id|name>   Project id prefix or name
   -d, --directory <path>    Working directory on that machine
   -s, --session <id>        Session id (see \`saycode ls\`)
-      --agent <name>        claude (default), codex, gemini, openclaw, opencode
+      --agent <name>        claude (default), codex, gemini, grok, openclaw, opencode
       --model <name>        Model for new-session messages (Default if omitted)
       --effort <level>      Model effort (validated against agent + model)
       --worktree            Create an isolated worktree for a project chat
@@ -4473,7 +4594,8 @@ Agent commands (machine-readable JSON on stdout, exit 3 on failure)
   agent prompt <session> <text> [--wait] Send a prompt, optionally wait for it
   agent steer <session> <text>        Redirect an owned child's active response
   agent stop <session>                Stop an owned child's active response
-  agent spawn --prompt <text> [--agent n]  Start a sibling in the same directory
+  agent spawn --prompt <text> [--agent n] [--model n] [--effort n]
+                                      Start a sibling with an explicit execution choice
   agent spawn --prompt <text> --file <path>  ...with context files it reads first
   Only works inside a session Saycode started (SAYCODE_AGENT_ENV).
 
@@ -6857,6 +6979,147 @@ function decryptJsonWithCandidates(blob, keys) {
   decryptCacheSet(blob, keys, null);
   return null;
 }
+function bounded(value2, maxLength) {
+  if (typeof value2 !== "string" || value2.length === 0 || value2.length > maxLength) return void 0;
+  return value2;
+}
+function parseCloudLoginResult(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("CLOUD_LOGIN_RESPONSE_INVALID");
+  }
+  const value2 = raw;
+  const required = (field, maxLength) => {
+    const entry = bounded(value2[field], maxLength);
+    if (entry === void 0) throw new Error("CLOUD_LOGIN_RESPONSE_INVALID");
+    return entry;
+  };
+  const accountPublicKey = bounded(value2.accountPublicKey, 128);
+  const accountKeySalt = bounded(value2.accountKeySalt, 128);
+  return {
+    userId: required("userId", 256),
+    username: required("username", 256),
+    token: required("token", 8192),
+    secret: required("secret", 8192),
+    ...accountPublicKey ? { accountPublicKey } : {},
+    ...accountKeySalt ? { accountKeySalt } : {}
+  };
+}
+const ENVELOPE_VERSION = 0;
+const EPHEMERAL_PUBLIC_KEY_LENGTH = 32;
+const ENVELOPE_NONCE_LENGTH = 24;
+const ENVELOPE_HEADER_LENGTH = 1 + EPHEMERAL_PUBLIC_KEY_LENGTH + ENVELOPE_NONCE_LENGTH;
+const GCM_VERSION = 0;
+const GCM_NONCE_LENGTH = 12;
+const GCM_TAG_LENGTH = 16;
+function unwrapDataEncryptionKey(envelopeBase64, recipientPrivateKey) {
+  let envelope;
+  try {
+    envelope = decodeBase64(envelopeBase64);
+  } catch {
+    return null;
+  }
+  if (envelope.length <= ENVELOPE_HEADER_LENGTH) return null;
+  if (envelope[0] !== ENVELOPE_VERSION) return null;
+  const ephemeralPublicKey = envelope.subarray(1, 1 + EPHEMERAL_PUBLIC_KEY_LENGTH);
+  const nonce = envelope.subarray(1 + EPHEMERAL_PUBLIC_KEY_LENGTH, ENVELOPE_HEADER_LENGTH);
+  const ciphertext = envelope.subarray(ENVELOPE_HEADER_LENGTH);
+  const opened = nacl.box.open(ciphertext, nonce, ephemeralPublicKey, recipientPrivateKey);
+  return opened ? new Uint8Array(opened) : null;
+}
+async function importGcmKey(dataEncryptionKey) {
+  return crypto.subtle.importKey("raw", new Uint8Array(dataEncryptionKey), "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+async function decryptDataKeyToString(dataEncryptionKey, bundleBase64) {
+  let bundle;
+  try {
+    bundle = decodeBase64(bundleBase64);
+  } catch {
+    return null;
+  }
+  if (bundle.length < 1 + GCM_NONCE_LENGTH + GCM_TAG_LENGTH) return null;
+  if (bundle[0] !== GCM_VERSION) return null;
+  const nonce = bundle.subarray(1, 1 + GCM_NONCE_LENGTH);
+  const ciphertextWithTag = bundle.subarray(1 + GCM_NONCE_LENGTH);
+  try {
+    const key = await importGcmKey(dataEncryptionKey);
+    const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: new Uint8Array(nonce) }, key, new Uint8Array(ciphertextWithTag));
+    return new TextDecoder().decode(plaintext);
+  } catch {
+    return null;
+  }
+}
+async function encryptDataKeyContent(dataEncryptionKey, value2) {
+  const nonce = nacl.randomBytes(GCM_NONCE_LENGTH);
+  const key = await importGcmKey(dataEncryptionKey);
+  const plaintext = new TextEncoder().encode(JSON.stringify(value2));
+  const ciphertextWithTag = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: new Uint8Array(nonce) }, key, plaintext));
+  const bundle = new Uint8Array(1 + GCM_NONCE_LENGTH + ciphertextWithTag.length);
+  bundle[0] = GCM_VERSION;
+  bundle.set(nonce, 1);
+  bundle.set(ciphertextWithTag, 1 + GCM_NONCE_LENGTH);
+  return encodeBase64(bundle);
+}
+const dekBySessionId = /* @__PURE__ */ new Map();
+const lockedSessionIds = /* @__PURE__ */ new Set();
+const fingerprints = /* @__PURE__ */ new Map();
+function registerSessionDek(session, accountPrivateKey) {
+  const envelope = session.dataEncryptionKey ?? null;
+  if (!envelope) {
+    dekBySessionId.delete(session.id);
+    lockedSessionIds.delete(session.id);
+    fingerprints.delete(session.id);
+    return;
+  }
+  const fingerprint = `${envelope}|${accountPrivateKey ? "1" : "0"}`;
+  if (fingerprints.get(session.id) === fingerprint) return;
+  fingerprints.set(session.id, fingerprint);
+  const dek = accountPrivateKey ? unwrapDataEncryptionKey(envelope, accountPrivateKey) : null;
+  if (dek) {
+    dekBySessionId.set(session.id, dek);
+    lockedSessionIds.delete(session.id);
+  } else {
+    dekBySessionId.delete(session.id);
+    lockedSessionIds.add(session.id);
+  }
+}
+function getSessionDek(sessionId) {
+  return dekBySessionId.get(sessionId) ?? null;
+}
+const MAX_ENTRIES = 3e3;
+const headerCache = /* @__PURE__ */ new Map();
+function cacheGet(store, sessionId, ciphertext) {
+  return store.get(sessionId)?.get(ciphertext) ?? null;
+}
+function cacheSet(store, sessionId, ciphertext, plaintext) {
+  let perSession = store.get(sessionId);
+  if (!perSession) {
+    perSession = /* @__PURE__ */ new Map();
+    store.set(sessionId, perSession);
+  }
+  perSession.set(ciphertext, plaintext);
+  if (perSession.size > MAX_ENTRIES) {
+    const oldest = perSession.keys().next().value;
+    if (oldest !== void 0) perSession.delete(oldest);
+  }
+}
+function getCachedDataKeyMetadataJson(sessionId, ciphertext) {
+  return cacheGet(headerCache, sessionId, ciphertext);
+}
+async function preDecryptSessionHeaders(sessions, accountPrivateKey) {
+  await Promise.all(sessions.map(async (session) => {
+    registerSessionDek(session, accountPrivateKey);
+    const dek = getSessionDek(session.id);
+    if (!dek) return;
+    if (session.metadata && getCachedDataKeyMetadataJson(session.id, session.metadata) === null) {
+      const json = await decryptDataKeyToString(dek, session.metadata);
+      if (json !== null) cacheSet(headerCache, session.id, session.metadata, json);
+    }
+    if (session.agentState && getCachedDataKeyMetadataJson(session.id, session.agentState) === null) {
+      const json = await decryptDataKeyToString(dek, session.agentState);
+      if (json !== null) cacheSet(headerCache, session.id, session.agentState, json);
+    }
+  }));
+}
 function buildUserTextMessageContent(input) {
   return {
     role: "user",
@@ -6872,6 +7135,58 @@ function buildUserTextMessageContent(input) {
     }
   };
 }
+function sanitizedString(value2) {
+  return typeof value2 === "string" && value2.trim() ? value2.trim() : null;
+}
+function sanitizedCompanyId(value2) {
+  if (typeof value2 === "string") return value2.trim() ? value2.trim() : null;
+  if (value2 === null) return null;
+  return void 0;
+}
+function buildStoredNotice(sessionId, value2, receivedAt) {
+  const companyId = sanitizedCompanyId(value2.companyId);
+  return {
+    sessionId,
+    projectId: sanitizedString(value2.projectId),
+    ...sanitizedString(value2.personalChatId) ? { personalChatId: sanitizedString(value2.personalChatId) } : {},
+    projectName: sanitizedString(value2.projectName),
+    sessionTitle: sanitizedString(value2.sessionTitle),
+    status: value2.status === "completed" || value2.status === "failed" || value2.status === "cancelled" ? value2.status : "completed",
+    receivedAt,
+    ...companyId !== void 0 ? { companyId } : {},
+    // Only non-chat kinds are stored; absence means chat so legacy snapshots round-trip.
+    ...value2.kind === "deploy" || value2.kind === "automation" || value2.kind === "platform_notice" ? { kind: value2.kind } : {},
+    // title/body are platform_notice-only (server-authoritative admin message). Other
+    // kinds never legitimately carry them, so they are dropped rather than stored blank.
+    ...value2.kind === "platform_notice" ? { title: sanitizedString(value2.title), body: sanitizedString(value2.body) } : {}
+  };
+}
+function parseServerCompletionNotifications(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const { notifications } = payload;
+  if (!Array.isArray(notifications)) return [];
+  const result = [];
+  for (const raw of notifications) {
+    if (!raw || typeof raw !== "object") continue;
+    const value2 = raw;
+    if (value2.kind !== "platform_notice") continue;
+    const sessionId = sanitizedString(value2.sessionId);
+    if (!sessionId) continue;
+    result.push({
+      ...buildStoredNotice(
+        sessionId,
+        value2,
+        typeof value2.receivedAt === "number" && Number.isFinite(value2.receivedAt) ? value2.receivedAt : 0
+      ),
+      // 서버 목록은 읽은 행도 함께 돌려주고(`listCompletionNotifications` 는 unread 로
+      // 필터하지 않는다) 읽음 여부를 `unread` 에 담는다. `buildStoredNotice` 는 이 필드를
+      // 모르므로 여기서 직접 얹지 않으면, 조회할 때마다 `recordCompletionNotice` 의
+      // 기본값(미확인)으로 되살아난다.
+      ...typeof value2.unread === "boolean" ? { unread: value2.unread } : {}
+    });
+  }
+  return result;
+}
 const CONNECTOR_PROVIDER_IDS = [
   "notion",
   "slack",
@@ -6923,7 +7238,7 @@ function personalMachinesPath(companyId) {
 function myMachinesPath(companyId) {
   return `/api/admin/companies/${encodeURIComponent(companyId)}/my-machines`;
 }
-function record$1(value2) {
+function record$2(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 }
 function array(value2) {
@@ -6942,7 +7257,7 @@ function provider(value2) {
   return PROVIDERS.includes(str(value2)) ? str(value2) : null;
 }
 function parseBundle(value2) {
-  const row2 = record$1(value2);
+  const row2 = record$2(value2);
   const id = str(row2.id);
   const bundleProvider = provider(row2.provider);
   if (!id || !bundleProvider) return null;
@@ -6961,7 +7276,7 @@ function parseBundle(value2) {
   };
 }
 function parseDeployment(value2) {
-  const row2 = record$1(value2);
+  const row2 = record$2(value2);
   const machineId = str(row2.machineId);
   const bundleId = str(row2.bundleId);
   if (!machineId || !bundleId) return null;
@@ -6981,10 +7296,10 @@ function parseDeployment(value2) {
   };
 }
 function parseStatus(value2) {
-  const row2 = record$1(value2);
+  const row2 = record$2(value2);
   const statusProvider = provider(row2.provider);
   if (!statusProvider) return void 0;
-  const rotationRow = record$1(row2.rotation);
+  const rotationRow = record$2(row2.rotation);
   const state = str(rotationRow.state);
   const rotation = ROTATION_STATES.includes(state) ? {
     state,
@@ -7005,7 +7320,7 @@ function parseStatus(value2) {
   };
 }
 function parseMachineResult(value2) {
-  const row2 = record$1(value2);
+  const row2 = record$2(value2);
   const machineId = str(row2.machineId);
   if (!machineId) return null;
   if (row2.ok !== true) {
@@ -7020,28 +7335,28 @@ function parseMachineResult(value2) {
   };
 }
 function parseAiCredentialVaultSnapshot(value2) {
-  const body = record$1(value2);
+  const body = record$2(value2);
   return {
     bundles: array(body.bundles).map(parseBundle).filter((bundle) => bundle !== null),
     deployments: array(body.deployments).map(parseDeployment).filter((deployment) => deployment !== null)
   };
 }
 function parseAiCredentialCaptureResponse(value2) {
-  const body = record$1(value2);
+  const body = record$2(value2);
   const bundle = parseBundle(body.bundle);
   if (!bundle) throw new Error("AI credential capture response did not contain a bundle");
   return { bundle, warnings: array(body.warnings).filter((warning) => typeof warning === "string") };
 }
 function parseAiCredentialBatchResult(value2) {
-  const body = record$1(value2);
+  const body = record$2(value2);
   return {
     results: array(body.results).map(parseMachineResult).filter((result) => result !== null),
     warnings: array(body.warnings).filter((warning) => typeof warning === "string")
   };
 }
 function parseSelfServiceMachines(value2) {
-  return array(record$1(value2).machines).map((entry) => {
-    const row2 = record$1(entry);
+  return array(record$2(value2).machines).map((entry) => {
+    const row2 = record$2(entry);
     return {
       machineId: str(row2.machineId),
       type: row2.type === "shared" ? "shared" : "personal",
@@ -7054,8 +7369,8 @@ function parseSelfServiceMachines(value2) {
   }).filter((machine) => machine.machineId !== "");
 }
 function parsePersonalMachines(value2) {
-  return array(record$1(value2).machines).map((entry) => {
-    const row2 = record$1(entry);
+  return array(record$2(value2).machines).map((entry) => {
+    const row2 = record$2(entry);
     const type = row2.type === "shared" ? "shared" : "personal";
     return {
       machineId: str(row2.machineId),
@@ -7425,6 +7740,123 @@ function parseProjectListV2Page(body) {
     total: page.total
   };
 }
+const PUBLIC_ID_PATTERN = /^[A-Za-z0-9_-]{32}$/;
+const CHECKSUM_PATTERN = /^[a-f\d]{64}$/i;
+const MAX_ID_LENGTH = 256;
+const MAX_TITLE_LENGTH = 255;
+const MAX_WARNINGS = 32;
+const MAX_WARNING_LENGTH = 500;
+const PUBLICATION_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "publicId",
+  "sourceType",
+  "sourceIdentity",
+  "sourceChecksumSha256",
+  "title",
+  "contentType",
+  "sizeBytes",
+  "checksumSha256",
+  "status",
+  "createdAt",
+  "revokedAt",
+  "publicUrl"
+]);
+function fail(detail) {
+  throw new Error(`artifact publication response is invalid: ${detail}`);
+}
+function record$1(value2, label) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) fail(`${label} must be an object`);
+  return value2;
+}
+function exactKeys(value2, keys) {
+  const expected = new Set(keys);
+  if (Object.keys(value2).some((key) => !expected.has(key)) || keys.some((key) => !(key in value2))) fail("response fields do not match the contract");
+}
+function nonEmptyString$1(value2, label, maxLength = MAX_ID_LENGTH) {
+  if (typeof value2 !== "string" || !value2 || value2.trim() !== value2 || value2.length > maxLength) fail(`${label} is invalid`);
+  return value2;
+}
+function checksum(value2, label) {
+  if (typeof value2 !== "string" || !CHECKSUM_PATTERN.test(value2)) fail(`${label} is invalid`);
+}
+function safeInteger(value2, label) {
+  if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 0) fail(`${label} is invalid`);
+}
+function warnings(value2) {
+  if (!Array.isArray(value2) || value2.length > MAX_WARNINGS || value2.some((warning) => typeof warning !== "string" || warning.length > MAX_WARNING_LENGTH)) fail("warnings are invalid");
+  return [...value2];
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function parseTrustedPublicUrl(value2, apiBaseUrl, publicId) {
+  if (typeof value2 !== "string") fail("publicUrl is invalid");
+  let publicUrl;
+  let apiUrl;
+  try {
+    publicUrl = new URL(value2);
+    apiUrl = new URL(apiBaseUrl);
+  } catch {
+    fail("publicUrl is invalid");
+  }
+  if (publicUrl.protocol !== "https:" && !(publicUrl.protocol === "http:" && isLoopbackHostname(publicUrl.hostname)) || publicUrl.origin !== apiUrl.origin || publicUrl.protocol !== apiUrl.protocol || publicUrl.username || publicUrl.password || publicUrl.search || publicUrl.hash || publicUrl.pathname !== `/artifacts/${publicId}`) fail("publicUrl is not trusted");
+  return publicUrl.toString();
+}
+function sourceIdentity(source) {
+  return source.type === "project-file" ? JSON.stringify([
+    source.projectId,
+    ...source.worktreeId ? [source.worktreeId] : [],
+    source.path
+  ]) : JSON.stringify([source.chatId, source.path]);
+}
+function validatePublication(value2, apiBaseUrl, operation, expectedSource) {
+  const publication = record$1(value2, "publication");
+  if (Object.keys(publication).some((key) => !PUBLICATION_KEYS.has(key))) {
+    fail("publication contains an unexpected field");
+  }
+  if ([...PUBLICATION_KEYS].some((key) => !(key in publication))) {
+    fail("publication is missing a field");
+  }
+  const publicationId = nonEmptyString$1(publication.id, "publication id");
+  const publicId = nonEmptyString$1(publication.publicId, "public id");
+  if (!PUBLIC_ID_PATTERN.test(publicId)) fail("public id is invalid");
+  if (!["project-file", "personal-chat-file", "personal-chat-artifact"].includes(String(publication.sourceType))) {
+    fail("source type is invalid");
+  }
+  const parsedSourceIdentity = nonEmptyString$1(publication.sourceIdentity, "source identity", 4096);
+  if (expectedSource && (publication.sourceType !== expectedSource.type || parsedSourceIdentity !== sourceIdentity(expectedSource))) fail("source does not match the request");
+  checksum(publication.sourceChecksumSha256, "source checksum");
+  const title = nonEmptyString$1(publication.title, "title", MAX_TITLE_LENGTH);
+  nonEmptyString$1(publication.contentType, "content type");
+  safeInteger(publication.sizeBytes, "size");
+  checksum(publication.checksumSha256, "checksum");
+  safeInteger(publication.createdAt, "created time");
+  const expectedStatus = operation === "publish" ? "active" : "revoked";
+  if (publication.status !== expectedStatus) fail("status does not match the operation");
+  if (publication.revokedAt !== null && typeof publication.revokedAt !== "number" || typeof publication.revokedAt === "number" && (!Number.isSafeInteger(publication.revokedAt) || publication.revokedAt < 0) || expectedStatus === "active" && publication.revokedAt !== null || expectedStatus === "revoked" && publication.revokedAt === null) fail("revoked time is invalid");
+  return {
+    publicationId,
+    publicId,
+    publicUrl: parseTrustedPublicUrl(publication.publicUrl, apiBaseUrl, publicId),
+    title,
+    status: expectedStatus
+  };
+}
+function parseStaticArtifactPublicationResult(value2, options) {
+  const response = record$1(value2, "response");
+  if (options.operation === "publish") {
+    exactKeys(response, ["publication", "publicUrl", "reused"]);
+    if (typeof response.reused !== "boolean") fail("reused is invalid");
+    const publication2 = validatePublication(response.publication, options.apiBaseUrl, options.operation, options.source);
+    const publicUrl = parseTrustedPublicUrl(response.publicUrl, options.apiBaseUrl, publication2.publicId);
+    if (publication2.publicUrl !== publicUrl) fail("public URLs do not match");
+    return { version: 1, ...publication2, reused: response.reused, warnings: [] };
+  }
+  exactKeys(response, ["publication", "warnings"]);
+  const parsedWarnings = warnings(response.warnings);
+  const publication = validatePublication(response.publication, options.apiBaseUrl, options.operation);
+  return { version: 1, ...publication, reused: false, warnings: parsedWarnings };
+}
 function asRecord(value2) {
   return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
 }
@@ -16001,6 +16433,31 @@ function coercePromptSuggestion(value2) {
   if (!text2 || !provider2 || updatedAt === void 0) return void 0;
   return { text: text2, provider: provider2, updatedAt };
 }
+const MCP_RUNTIME_STATUSES = /* @__PURE__ */ new Set([
+  "connected",
+  "reconnecting",
+  "failed",
+  "needs-auth",
+  "config-fetch-failed",
+  "mcp-config-missing",
+  "connector-config-missing",
+  "connector-runtime-failed",
+  "connector-needs-auth"
+]);
+function coerceMcpServerStatuses(value2) {
+  if (!Array.isArray(value2)) return void 0;
+  const entries = [];
+  for (const raw of value2) {
+    if (!isRecord$1(raw)) continue;
+    const name = nonEmptyString(raw.name);
+    const status = typeof raw.status === "string" && MCP_RUNTIME_STATUSES.has(raw.status) ? raw.status : void 0;
+    const checkedAt = optionalTimestamp(raw.checkedAt);
+    if (!name || !status || checkedAt === void 0) continue;
+    const error = nonEmptyString(raw.error);
+    entries.push({ name, status, checkedAt, ...error ? { error } : {} });
+  }
+  return entries.length > 0 ? entries : void 0;
+}
 function coerceCreatedBy(value2) {
   if (!isRecord$1(value2)) return void 0;
   const accountId = nonEmptyString(value2.accountId);
@@ -16008,6 +16465,18 @@ function coerceCreatedBy(value2) {
   const displayName = nonEmptyString(value2.displayName);
   return displayName ? { accountId, displayName } : { accountId };
 }
+function decryptSessionJsonSync(sessionId, blob, candidateKeys) {
+  if (!blob) return null;
+  const cached = getCachedDataKeyMetadataJson(sessionId, blob);
+  if (cached !== null) {
+    try {
+      return JSON.parse(cached);
+    } catch {
+      return null;
+    }
+  }
+  return decryptJsonWithCandidates(blob, candidateKeys);
+}
 function apiSessionToSession(api, candidateKeys, existing) {
   const updatedAt = mergeUpdatedAt(api.updatedAt);
   const summaryText = decryptSummaryText(api.metadata, candidateKeys) ?? existing?.summaryText;
@@ -16017,8 +16486,8 @@ function apiSessionToSession(api, candidateKeys, existing) {
   const pendingExitPlanMode = apiSessionAgentStatePendingExitPlanMode(api.agentState, candidateKeys);
   const pendingPermissionRequests = apiSessionAgentStatePendingPermissions(api.agentState, candidateKeys);
   const agentControlledByUser = apiSessionAgentStateControlledByUser(api.agentState, candidateKeys);
-  const agentState = api.agentState ? decryptJsonWithCandidates(api.agentState, candidateKeys) : null;
-  const metadata = decryptJsonWithCandidates(api.metadata, candidateKeys);
+  const agentState = api.agentState ? decryptSessionJsonSync(api.id, api.agentState, candidateKeys) : null;
+  const metadata = decryptSessionJsonSync(api.id, api.metadata, candidateKeys);
   const agent = agentFromFlavor(typeof metadata?.flavor === "string" ? metadata.flavor : void 0) ?? existing?.agent;
   const models = coerceSessionModels(metadata?.models) ?? existing?.models;
   const worktree = coerceSessionWorktree(metadata?.worktree) ?? coerceSessionWorktree(metadata) ?? existing?.worktree;
@@ -16035,6 +16504,7 @@ function apiSessionToSession(api, candidateKeys, existing) {
   const branchSlug = branchSlugFromMetadata(metadata) ?? existing?.branchSlug;
   const path = nonEmptyString(metadata?.path) ?? existing?.path;
   const promptSuggestion2 = metadata && Object.prototype.hasOwnProperty.call(metadata, "promptSuggestion") ? coercePromptSuggestion(metadata.promptSuggestion) : existing?.promptSuggestion;
+  const mcpServers = coerceMcpServerStatuses(metadata?.mcpServers) ?? existing?.mcpServers;
   return {
     ...existing,
     id: api.id,
@@ -16061,6 +16531,7 @@ function apiSessionToSession(api, candidateKeys, existing) {
     ...currentModelCode ? { currentModelCode } : {},
     ...tokenUsage ? { tokenUsage } : {},
     ...slashCommands ? { slashCommands } : {},
+    ...mcpServers ? { mcpServers } : {},
     ...claudeSessionId ? { claudeSessionId } : {},
     ...codexThreadId ? { codexThreadId } : {},
     ...lifecycleState ? { lifecycleState } : {},
@@ -16103,9 +16574,10 @@ function readMcpCallerGrantPublicKey(daemonState) {
   const value2 = daemonState.mcpCallerGrantPublicKey;
   return typeof value2 === "string" && value2 ? value2 : void 0;
 }
+const CLEARABLE_STRING_KEYS = /* @__PURE__ */ new Set(["branch", "baseBranch"]);
 function buildWorktreeMutationBody(input, options = {}) {
   return JSON.stringify(Object.fromEntries(
-    Object.entries(input).filter(([key, value2]) => (key !== "machinePlatform" || options.includeMachinePlatform) && (typeof value2 === "string" && (value2.length > 0 || key === "branch") || key === "branch" && value2 === null))
+    Object.entries(input).filter(([key, value2]) => (key !== "machinePlatform" || options.includeMachinePlatform) && (typeof value2 === "string" && (value2.length > 0 || CLEARABLE_STRING_KEYS.has(key)) || value2 === null && CLEARABLE_STRING_KEYS.has(key)))
   ));
 }
 const STANDALONE_USER_ID = "standalone-local";
@@ -16359,18 +16831,18 @@ function readCloudMobileLoginPairingErrorCode(body) {
 const PAIRING_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const CODE_PATTERN = /^[A-Za-z0-9_-]{43}$/;
 const STATUSES = /* @__PURE__ */ new Set(["pending", "consumed", "revoked", "expired"]);
-function invalidResponse() {
+function invalidResponse$1() {
   throw new Error("PAIRING_RESPONSE_INVALID");
 }
 function parseCloudMobileLoginPairing(raw, options = {}) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) invalidResponse();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) invalidResponse$1();
   const value2 = raw;
-  if (typeof value2.pairingId !== "string" || !PAIRING_ID_PATTERN.test(value2.pairingId)) invalidResponse();
-  if (!Number.isSafeInteger(value2.expiresAt) || value2.expiresAt <= 0) invalidResponse();
-  if (!Number.isSafeInteger(value2.serverTime) || value2.serverTime <= 0) invalidResponse();
-  if (typeof value2.status !== "string" || !STATUSES.has(value2.status)) invalidResponse();
-  if (options.requireCode && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse();
-  if (value2.code !== void 0 && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse();
+  if (typeof value2.pairingId !== "string" || !PAIRING_ID_PATTERN.test(value2.pairingId)) invalidResponse$1();
+  if (!Number.isSafeInteger(value2.expiresAt) || value2.expiresAt <= 0) invalidResponse$1();
+  if (!Number.isSafeInteger(value2.serverTime) || value2.serverTime <= 0) invalidResponse$1();
+  if (typeof value2.status !== "string" || !STATUSES.has(value2.status)) invalidResponse$1();
+  if (options.requireCode && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse$1();
+  if (value2.code !== void 0 && (typeof value2.code !== "string" || !CODE_PATTERN.test(value2.code))) invalidResponse$1();
   return {
     pairingId: value2.pairingId,
     expiresAt: value2.expiresAt,
@@ -16379,6 +16851,43 @@ function parseCloudMobileLoginPairing(raw, options = {}) {
     ...typeof value2.code === "string" ? { code: value2.code } : {}
   };
 }
+const BROWSER_VIEWER_OPEN_TIMEOUT_MS = 13e4;
+const BROWSER_VIEWER_INSTALL_TIMEOUT_MS = 31e4;
+function invalidResponse() {
+  throw new Error("BROWSER_VIEWER_RESPONSE_INVALID");
+}
+function responseRecord(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) invalidResponse();
+  return value2;
+}
+function parseBrowserViewerOpenResponse(value2) {
+  const response = responseRecord(value2);
+  if (typeof response.token !== "string" || response.token.length === 0 || typeof response.relayUrl !== "string" && response.relayUrl !== null || response.routingVersion !== 1 || typeof response.previewDomain !== "string" && response.previewDomain !== null || !Number.isInteger(response.webPort) || response.webPort < 1 || response.webPort > 65535 || typeof response.bridgeReady !== "boolean") invalidResponse();
+  return {
+    token: response.token,
+    relayUrl: response.relayUrl,
+    routingVersion: 1,
+    previewDomain: response.previewDomain,
+    webPort: response.webPort,
+    bridgeReady: response.bridgeReady
+  };
+}
+function parseBrowserViewerInstallResponse(value2) {
+  const response = responseRecord(value2);
+  if (response.action === "already-installed") return { kind: "already-installed" };
+  if (response.action === "run") {
+    if (response.ok !== true) invalidResponse();
+    return { kind: "installed" };
+  }
+  if (response.action === "manual") {
+    if (typeof response.command !== "string" || typeof response.reason !== "string") invalidResponse();
+    return {
+      kind: "manual-required",
+      reason: response.command.length === 0 ? "unsupported-platform" : "admin-required"
+    };
+  }
+  return invalidResponse();
+}
 const FIXED_API_BASE_URL = "https://saycode.ai";
 const FIXED_SYNC_BASE_URL = "https://saycode.ai";
 const machineRegistryCache = /* @__PURE__ */ new Map();
@@ -16559,6 +17068,7 @@ function normalizeMachine(row2, candidateKeys) {
     mcpCallerGrantPublicKey: readMcpCallerGrantPublicKey(daemonState),
     automationSupport,
     filesystemScope: decrypted.filesystemScope,
+    additionalDirectories: decrypted.additionalDirectories,
     registry
   };
 }
@@ -16586,7 +17096,7 @@ class ApiClient {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input)
     }, DEFAULT_REQUEST_TIMEOUT_MS);
-    return this.handleResponse(response);
+    return parseCloudLoginResult(await this.handleResponse(response));
   }
   async getMe() {
     return this.request("/api/auth/me", { boundary: "api" });
@@ -16642,6 +17152,117 @@ class ApiClient {
     });
     return data.items ?? [];
   }
+  /**
+   * 관리자가 보낸 플랫폼 공지(`kind: 'platform_notice'`)만 골라 돌려준다. 다른 kind
+   * (`chat_completion`)는 데스크탑이 이미 스스로 만들고 있어 동기화 대상이 아니다.
+   * specs/desktop-platform-notice-inbox
+   */
+  async listServerNotifications() {
+    const data = await this.request("/api/me/completion-notifications", { boundary: "api" });
+    return parseServerCompletionNotifications(data);
+  }
+  /**
+   * 서버 알림함에 읽음을 반영한다. `kind` 를 반드시 넘긴다 — 서버 유니크 키가
+   * (userId, kind, sessionId) 라 kind 없이는 같은 세션의 어느 kind를 읽음 처리할지
+   * 서버가 구분하지 못한다. 실패해도 로컬 상태는 이미 반영됐으므로 호출부가 삼킨다.
+   * specs/desktop-platform-notice-inbox R4
+   */
+  async markServerNotificationRead(sessionId, kind) {
+    await this.request(`/api/me/completion-notifications/${encodeURIComponent(sessionId)}/read?kind=${encodeURIComponent(kind)}`, {
+      method: "PATCH",
+      boundary: "api"
+    });
+  }
+  /**
+   * 관련 프로젝트 등록 목록. 서버가 양방향으로 조회해 준다(대상으로 등록한 쪽도
+   * 나온다). specs/desktop-related-project-handoff
+   */
+  async listProjectLinks(projectId) {
+    const data = await this.request(
+      `/api/projects/${encodeURIComponent(projectId)}/links`,
+      { boundary: "api" }
+    );
+    return data.links ?? [];
+  }
+  async addProjectLink(projectId, targetProjectId, role) {
+    const data = await this.request(
+      `/api/projects/${encodeURIComponent(projectId)}/links`,
+      { method: "POST", boundary: "api", body: JSON.stringify({ targetProjectId, role }) }
+    );
+    return data.link;
+  }
+  async removeProjectLink(projectId, targetProjectId) {
+    await this.request(`/api/projects/${encodeURIComponent(projectId)}/links`, {
+      method: "DELETE",
+      boundary: "api",
+      body: JSON.stringify({ targetProjectId })
+    });
+  }
+  /** 진행 중(queued/running/blocked) 핸드오프 전체 — 전역 인디케이터용. */
+  async listActiveProjectHandoffs() {
+    const data = await this.request("/api/handoffs", { boundary: "api" });
+    return data.handoffs ?? [];
+  }
+  /** 이 프로젝트에서 내보낸 핸드오프 전체 — 프로젝트 설정 화면용. */
+  async listProjectHandoffsForProject(projectId) {
+    const data = await this.request(
+      `/api/projects/${encodeURIComponent(projectId)}/handoffs`,
+      { boundary: "api" }
+    );
+    return data.handoffs ?? [];
+  }
+  /**
+   * 승인. `sourceSessionId` 는 승인 카드가 렌더된 대화 — 서버가 딥링크 조립에 쓴다.
+   * 이미 승인된(queued 이상) 핸드오프를 다시 승인하면 서버가 409 를 던진다(멱등은
+   * 호출부가 그 에러를 흡수하는 방식으로 구현한다). specs/desktop-related-project-handoff R7
+   */
+  async approveProjectHandoff(handoffId, sourceSessionId) {
+    const data = await this.request(
+      `/api/handoffs/${encodeURIComponent(handoffId)}/approve`,
+      { method: "POST", boundary: "api", body: JSON.stringify({ sourceSessionId }) }
+    );
+    return data.handoff;
+  }
+  async rejectProjectHandoff(handoffId) {
+    const data = await this.request(
+      `/api/handoffs/${encodeURIComponent(handoffId)}/reject`,
+      { method: "POST", boundary: "api" }
+    );
+    return data.handoff;
+  }
+  /** 대상 프로젝트에 실제 세션을 만든 뒤 보고한다. 서버가 targetSessionId 기준으로
+   * 멱등을 보장한다 — 이미 있으면 새 매핑을 만들지 않고 그대로 돌려준다. */
+  async reportProjectHandoffStarted(handoffId, targetSessionId) {
+    const data = await this.request(
+      `/api/handoffs/${encodeURIComponent(handoffId)}/started`,
+      { method: "POST", boundary: "api", body: JSON.stringify({ targetSessionId }) }
+    );
+    return data.handoff;
+  }
+  /** 대상 프로젝트에 온라인 머신이 없는 등, 세션 생성 자체를 시작하지 못했을 때. */
+  async reportProjectHandoffBlocked(handoffId, reason) {
+    const data = await this.request(
+      `/api/handoffs/${encodeURIComponent(handoffId)}/blocked`,
+      { method: "POST", boundary: "api", body: JSON.stringify({ reason }) }
+    );
+    return data.handoff;
+  }
+  /** 세션 생성 시도가 던졌을 때. */
+  async reportProjectHandoffFailed(handoffId, reason) {
+    const data = await this.request(
+      `/api/handoffs/${encodeURIComponent(handoffId)}/failed`,
+      { method: "POST", boundary: "api", body: JSON.stringify({ reason }) }
+    );
+    return data.handoff;
+  }
+  /** 기본 꺼짐 — request_project_handoff MCP 도구 노출 토글(spec R9). */
+  async setProjectHandoffMcpEnabled(projectId, enabled) {
+    return this.request(`/api/projects/${encodeURIComponent(projectId)}/handoff-mcp-enabled`, {
+      method: "PATCH",
+      boundary: "api",
+      body: JSON.stringify({ enabled })
+    });
+  }
   async addProjectFavorite(projectId) {
     return this.request(`/api/projects/${encodeURIComponent(projectId)}/favorite`, {
       method: "PUT",
@@ -16657,6 +17278,7 @@ class ApiClient {
   // --- 개인 Chat (specs/personal-chats) ---
   async listPersonalChats(input = {}) {
     const params = new URLSearchParams();
+    params.set("context", input.companyId ? `company:${input.companyId}` : "personal");
     if (input.limit !== void 0) params.set("limit", String(input.limit));
     if (input.offset !== void 0) params.set("offset", String(input.offset));
     if (input.query) params.set("query", input.query);
@@ -16672,12 +17294,22 @@ class ApiClient {
     const data = await this.request("/api/personal-chats", {
       method: "POST",
       boundary: "api",
-      body: JSON.stringify(
-        input.title === void 0 ? { machineId: input.machineId } : { machineId: input.machineId, title: input.title }
-      )
+      body: JSON.stringify({
+        machineId: input.machineId,
+        ...input.title === void 0 ? {} : { title: input.title },
+        ..."companyId" in input ? { companyId: input.companyId } : {}
+      })
     });
     return data.chat;
   }
+  async getPersonalChatRuntimeConfig(chatId, machineId) {
+    const params = new URLSearchParams({ machineId });
+    const data = await this.request(
+      `/api/personal-chats/${encodeURIComponent(chatId)}/runtime-config?${params.toString()}`,
+      { boundary: "api", headers: { "Cache-Control": "no-cache" } }
+    );
+    return data.environmentVariables ?? {};
+  }
   async getPersonalChat(chatId) {
     const data = await this.request(
       `/api/personal-chats/${encodeURIComponent(chatId)}`,
@@ -17003,19 +17635,23 @@ class ApiClient {
   }
   /**
    * Mint the signed caller grant that proves *this* user is the connector
-   * subject of a session spawned on a shared machine. The server binds it to
-   * userId/machineId/projectId/expiry and rejects a caller who cannot access
-   * the machine or project (web-ui server/mcpCallerGrantRoute.ts). `projectId`
-   * is required by the route — send an explicit null, not an omitted field,
-   * because the grant's project scope must match the spawn's.
+   * subject of a session spawned on a grant-capable machine. The server binds it to
+   * userId/machineId/projectId-or-personalChatId/expiry and rejects a caller
+   * who cannot access that runtime scope (web-ui server/mcpCallerGrantRoute.ts).
+   * `projectId` is required by the route — Personal Chat grants send an explicit
+   * null plus `personalChatId` so the signed scope matches the spawn.
    */
-  async mintMcpCallerGrant(machineId, projectId) {
+  async mintMcpCallerGrant(machineId, projectId, personalChatId) {
     const data = await this.request(
       "/api/me/mcp-caller-grant",
       {
         method: "POST",
         boundary: "api",
-        body: JSON.stringify({ machineId, projectId })
+        body: JSON.stringify({
+          machineId,
+          projectId,
+          ...personalChatId ? { personalChatId } : {}
+        })
       }
     );
     if (typeof data.grant !== "string" || !data.grant) throw new Error("mcp caller grant is missing");
@@ -17699,23 +18335,26 @@ class ApiClient {
       boundary: "api"
     });
   }
-  async fetchSessions(candidateKeys = [], tokenOverride) {
+  async fetchSessions(candidateKeys = [], tokenOverride, accountPrivateKey = null) {
     const data = await this.request("/v1/sessions", {
       boundary: "sync",
       tokenOverride
     });
     const rows = Array.isArray(data) ? data : data.sessions ?? [];
+    await preDecryptSessionHeaders(rows, accountPrivateKey);
     return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
-  async fetchSessionsPage(candidateKeys = [], cursor, limit = 200, tokenOverride) {
+  async fetchSessionsPage(candidateKeys = [], cursor, limit = 200, tokenOverride, accountPrivateKey = null) {
     const params = new URLSearchParams({ limit: String(limit) });
     if (cursor) params.set("cursor", cursor);
     const data = await this.request(
       `/v2/sessions?${params.toString()}`,
       { boundary: "sync", tokenOverride }
     );
+    const rows = data.sessions ?? [];
+    await preDecryptSessionHeaders(rows, accountPrivateKey);
     return {
-      sessions: (data.sessions ?? []).map((row2) => apiSessionToSession(row2, candidateKeys)),
+      sessions: rows.map((row2) => apiSessionToSession(row2, candidateKeys)),
       nextCursor: data.nextCursor ?? null,
       hasNext: data.hasNext === true
     };
@@ -17730,8 +18369,10 @@ class ApiClient {
     });
     return data.sessions ?? [];
   }
-  async lookupSessions(candidateKeys, ids, tokenOverride) {
-    return (await this.lookupApiSessions(ids, tokenOverride)).map((row2) => apiSessionToSession(row2, candidateKeys));
+  async lookupSessions(candidateKeys, ids, tokenOverride, accountPrivateKey = null) {
+    const rows = await this.lookupApiSessions(ids, tokenOverride);
+    await preDecryptSessionHeaders(rows, accountPrivateKey);
+    return rows.map((row2) => apiSessionToSession(row2, candidateKeys));
   }
   async deleteSession(sessionId, tokenOverride) {
     await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
@@ -17916,9 +18557,8 @@ class ApiClient {
   }
   async sendUserTextMessage(input) {
     const localId = input.localId || `desktop-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const key = input.secretBase64 ? decodeBase64(input.secretBase64) : null;
     const content = buildUserTextMessageContent(input);
-    const encoded = encodeMessageContent(content, key);
+    const encoded = input.dataEncryptionKey ? await encryptDataKeyContent(input.dataEncryptionKey, content) : encodeMessageContent(content, input.secretBase64 ? decodeBase64(input.secretBase64) : null);
     const result = await this.sendMessages(input.sessionId, [{ localId, content: encoded }], input.tokenOverride);
     return { localId, sentSeq: result.messages?.[0]?.seq };
   }
@@ -17990,6 +18630,34 @@ class ApiClient {
     }
     return resolvedProjectPreviewRelayUrl({ ...input, response: { ...response, token: response.token }, syncBaseUrl: this.config.syncBaseUrl });
   }
+  async openBrowserViewer(machineId, signal) {
+    return parseBrowserViewerOpenResponse(await this.request(
+      `/api/machines/${encodeURIComponent(machineId)}/browser-viewer/open`,
+      {
+        method: "POST",
+        boundary: "api",
+        signal,
+        timeoutMs: BROWSER_VIEWER_OPEN_TIMEOUT_MS
+      }
+    ));
+  }
+  async installBrowserViewer(machineId, signal) {
+    return this.installBrowserViewerComponent(machineId, "install", signal);
+  }
+  async installBrowserViewerChrome(machineId, signal) {
+    return this.installBrowserViewerComponent(machineId, "install-chrome", signal);
+  }
+  async installBrowserViewerComponent(machineId, action, signal) {
+    return parseBrowserViewerInstallResponse(await this.request(
+      `/api/machines/${encodeURIComponent(machineId)}/browser-viewer/${action}`,
+      {
+        method: "POST",
+        boundary: "api",
+        signal,
+        timeoutMs: BROWSER_VIEWER_INSTALL_TIMEOUT_MS
+      }
+    ));
+  }
   // --- Project deploy & share (specs/desktop-project-deploy-share) ---
   async moveProject(projectId, input) {
     return this.request(`/api/projects/${encodeURIComponent(projectId)}/move`, {
@@ -18111,6 +18779,30 @@ class ApiClient {
       timeoutMs: LONG_REQUEST_TIMEOUT_MS
     });
   }
+  async publishStaticArtifact(source, signal) {
+    const { version: _version, ...serverSource } = source;
+    const response = await this.request("/api/artifact-publications", {
+      method: "POST",
+      boundary: "api",
+      body: JSON.stringify({ source: serverSource }),
+      signal
+    });
+    return parseStaticArtifactPublicationResult(response, {
+      apiBaseUrl: this.config.apiBaseUrl,
+      operation: "publish",
+      source
+    });
+  }
+  async revokeStaticArtifactPublication(publicationId, signal) {
+    const response = await this.request(
+      `/api/artifact-publications/${encodeURIComponent(publicationId)}`,
+      { method: "DELETE", boundary: "api", signal }
+    );
+    return parseStaticArtifactPublicationResult(response, {
+      apiBaseUrl: this.config.apiBaseUrl,
+      operation: "revoke"
+    });
+  }
   async getDeployGitHubFiles(projectId, branch = "main") {
     const data = await this.request("/deploy/github-files", {
       method: "POST",
@@ -19531,11 +20223,11 @@ function reduceSessionReadState(state, change, merge, fingerprintLimit = DEFAULT
   const { item } = change;
   if (state.fingerprints.includes(item.fingerprint)) return state;
   if (change.kind === "event" && item.cursor !== null && state.cursor !== null && item.cursor < state.cursor) return state;
-  const fingerprints = [...state.fingerprints, item.fingerprint].slice(-Math.max(1, fingerprintLimit));
+  const fingerprints2 = [...state.fingerprints, item.fingerprint].slice(-Math.max(1, fingerprintLimit));
   return {
     value: merge(state.value, item.value),
     cursor: item.cursor === null ? state.cursor : Math.max(state.cursor ?? item.cursor, item.cursor),
-    fingerprints
+    fingerprints: fingerprints2
   };
 }
 function record(value2) {
@@ -20488,7 +21180,7 @@ function chatUploadRelPath(file, id) {
   if (file.type.startsWith("image/")) return `.aplus/uploads/${id}.${extensionFor(file)}`;
   return `.aplus/uploads/${id}-${safeFileName(file)}`;
 }
-async function uploadChatFileToMachineCore(file, workspaceRoot, deps) {
+async function uploadChatFileToMachineCore(file, workspaceRoot, deps, relativePath) {
   const root = workspaceRoot.trim().replace(/\/+$/, "");
   if (!root) throw new Error(translateCurrent("upload.noWorkspaceRoot"));
   const id = (deps.now?.() ?? Date.now()).toString(36) + (deps.random?.() ?? Math.random()).toString(36).slice(2, 8);
@@ -20937,6 +21629,7 @@ const USAGE_SETTINGS_NAVIGATION_DESTINATIONS = [
   "settings_shortcuts",
   "settings_machines",
   "settings_mobile",
+  "settings_network",
   "settings_env",
   "settings_security",
   "settings_memory",
@@ -23394,7 +24087,7 @@ ${text2}` : text2);
   return sections.join("\n\n");
 }
 const HANDOFF_READ_MESSAGES = 400;
-async function handoffToSibling(runtime, scope, env, handoff, agent) {
+async function handoffToSibling(runtime, scope, env, handoff, agent, modelOptions = {}) {
   const from = handoff.from ?? env.sessionId;
   if (!from) {
     return agentFail(
@@ -23433,6 +24126,7 @@ async function handoffToSibling(runtime, scope, env, handoff, agent) {
     sessionId = (await runtime.spawnSession({
       directory: env.root,
       agent,
+      ...modelOptions,
       initialPrompt: prompt,
       environmentVariables: childAgentEnv(env, childId)
     })).sessionId;
@@ -23538,7 +24232,7 @@ function resolveSubagentControlPermission(records, parentSessionId, childSession
   return valid ? isDescendant(valid, parentSessionId, childSessionId, 2) : false;
 }
 function canControlSpawnedDescendant(records, parentSessionId, childSessionId) {
-  const lineage = records.flatMap((record2) => record2.outcome === "spawned" && record2.parentSessionId && record2.childSessionId ? [{
+  const lineage = records.flatMap((record2) => record2.outcome === "spawned" && record2.parentSessionId && record2.childSessionId && record2.parentSessionId !== record2.childSessionId && Number.isFinite(record2.ts) && record2.ts >= 0 ? [{
     parentSessionId: record2.parentSessionId,
     childSessionId: record2.childSessionId,
     spawnedAt: record2.ts,
@@ -23579,24 +24273,27 @@ async function stopOwnedTarget(runtime, env, target) {
   const refused = ownershipFailure(runtime, env, target);
   if (refused) return refused;
   if (!runtime.stopSession) return agentFail("stop_rejected", "stop transport is unavailable");
-  let stream2 = null;
-  try {
-    stream2 = await runtime.openStream(target.session.id);
-    if (stream2.current().thinking !== true) {
-      return agentFail("stop_not_responding", `${target.session.id} has no active response`);
-    }
-  } catch (error) {
-    return agentFail("stop_rejected", error instanceof Error ? error.message : String(error));
-  } finally {
-    stream2?.close();
-  }
   try {
     const result = await runtime.stopSession(target.session.machineId, target.session.id);
-    return result.stopped ? agentOk({ sessionId: target.session.id, stopped: true }) : agentFail("stop_rejected", result.error);
+    if (result.stopped) return agentOk({ sessionId: target.session.id, stopped: true });
+    return result.reason === "not-responding" ? agentFail("stop_not_responding", result.error) : agentFail("stop_rejected", result.error);
   } catch (error) {
     return agentFail("stop_rejected", error instanceof Error ? error.message : String(error));
   }
 }
+const CLI_CONFIGURABLE_AGENTS = [.../* @__PURE__ */ new Set([
+  ...newSessionAgents.map(({ id }) => id),
+  "gemini"
+])];
+function cliSpawnModelOptions() {
+  return CLI_CONFIGURABLE_AGENTS.map((agent) => ({
+    agent,
+    models: modelChoices(agent).map(({ key: id }) => ({
+      id,
+      efforts: effortChoices(agent, id).map(({ key }) => key)
+    }))
+  }));
+}
 const DEFAULT_READ_LIMIT = 20;
 const STATE_WINDOW_MESSAGES = 50;
 function scopeOf(runtime) {
@@ -23650,7 +24347,7 @@ async function readSession(runtime, target, last) {
   });
 }
 const DEFAULT_SPAWN_AGENT = "claude";
-async function spawnSibling(runtime, env, text2, agent, contextFiles = []) {
+async function spawnSibling(runtime, env, text2, agent, contextFiles = [], modelOptions = {}) {
   if (env.depth >= AGENT_MAX_DEPTH) {
     return agentFail("spawn_depth_exceeded", `depth ${env.depth} is already at the ceiling of ${AGENT_MAX_DEPTH}`);
   }
@@ -23678,6 +24375,7 @@ async function spawnSibling(runtime, env, text2, agent, contextFiles = []) {
     sessionId = (await runtime.spawnSession({
       directory: env.root,
       agent,
+      ...modelOptions,
       initialPrompt: composeSpawnPrompt(text2, context.paths),
       environmentVariables: childAgentEnv(env, childId)
     })).sessionId;
@@ -23727,7 +24425,8 @@ async function runAgentCommand(runtime, args) {
       maxSpawn: env.maxSpawn,
       spawned,
       spawnsRemaining: spawned === null ? null : Math.max(0, env.maxSpawn - spawned),
-      canSpawn: env.depth < AGENT_MAX_DEPTH && (spawned === null || spawned < env.maxSpawn)
+      canSpawn: env.depth < AGENT_MAX_DEPTH && spawned !== null && spawned < env.maxSpawn,
+      spawnModelOptions: cliSpawnModelOptions()
     });
   }
   if (args.verb === "ls") {
@@ -23735,10 +24434,13 @@ async function runAgentCommand(runtime, args) {
     return agentOk({ sessions: sessions.filter((session) => isInScope(session, scope)).map(sessionSummary) });
   }
   if (args.verb === "spawn") {
+    const agent = args.agent ?? DEFAULT_SPAWN_AGENT;
+    const modelOptions = args.model !== void 0 || args.effort !== void 0 ? await validateSpawnModelOptions(agent, args.model, args.effort) : {};
+    if (isFailure(modelOptions)) return modelOptions;
     if (args.handoff) {
-      return handoffToSibling(runtime, scope, env, args.handoff, args.agent ?? DEFAULT_SPAWN_AGENT);
+      return handoffToSibling(runtime, scope, env, args.handoff, agent, modelOptions);
     }
-    return spawnSibling(runtime, env, args.text ?? "", args.agent ?? DEFAULT_SPAWN_AGENT, args.files ?? []);
+    return spawnSibling(runtime, env, args.text ?? "", agent, args.files ?? [], modelOptions);
   }
   if (!args.sessionId) return agentFail("session_not_found", "no session id given");
   const target = await resolveTarget(runtime, scope, args.sessionId);
@@ -23763,6 +24465,17 @@ async function runAgentCommand(runtime, args) {
       return agentFail("session_not_found", `unsupported verb "${args.verb}"`);
   }
 }
+async function validateSpawnModelOptions(agent, model, effort) {
+  try {
+    await resolveCliNewConversationOptions({ agent, model, effort });
+    return {
+      ...model !== void 0 && model !== "default" ? { model } : {},
+      ...effort !== void 0 ? { effort } : {}
+    };
+  } catch (error) {
+    return agentFail("invalid_spawn_options", error instanceof Error ? error.message : String(error));
+  }
+}
 function parseSpawnRecord(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return null;
   const record2 = value2;
@@ -23770,13 +24483,16 @@ function parseSpawnRecord(value2) {
 }
 const LEDGER_FILE_MODE = 384;
 const PREVIEW_MAX_LENGTH = 200;
-function agentLineagePath(homeDir) {
+function agentLineagePath(rootDir) {
+  return join(rootDir, ".aplus", "agent-lineage.jsonl");
+}
+function legacyAgentLineagePath(homeDir) {
   return join(homeDir, ".saycode", "agent-lineage.jsonl");
 }
-function readSpawnRecords(homeDir) {
+function readLedger(path) {
   let raw;
   try {
-    raw = readFileSync(agentLineagePath(homeDir), "utf8");
+    raw = readFileSync(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -23794,12 +24510,38 @@ function readSpawnRecords(homeDir) {
   }
   return records;
 }
-function countSpawnsFor(homeDir, agentKey) {
-  return readSpawnRecords(homeDir).filter((record2) => record2.agentKey === agentKey).length;
+function recordIdentity(record2) {
+  return JSON.stringify([
+    record2.ts,
+    record2.agentKey,
+    record2.root,
+    record2.depth,
+    record2.childSessionId,
+    record2.parentSessionId ?? null,
+    record2.agent,
+    record2.promptPreview,
+    record2.outcome
+  ]);
 }
-function appendSpawnRecord(homeDir, record2) {
-  const path = agentLineagePath(homeDir);
-  mkdirSync(join(homeDir, ".saycode"), { recursive: true, mode: 448 });
+function readSpawnRecords(homeDir, rootDir) {
+  const records = [
+    ...readLedger(legacyAgentLineagePath(homeDir)),
+    ...readLedger(agentLineagePath(rootDir))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return records.filter((record2) => {
+    const identity = recordIdentity(record2);
+    if (seen.has(identity)) return false;
+    seen.add(identity);
+    return true;
+  });
+}
+function countSpawnsFor(homeDir, rootDir, agentKey) {
+  return readSpawnRecords(homeDir, rootDir).filter((record2) => record2.agentKey === agentKey).length;
+}
+function appendSpawnRecord(rootDir, record2) {
+  const path = agentLineagePath(rootDir);
+  mkdirSync(join(rootDir, ".aplus"), { recursive: true, mode: 448 });
   const entry = { ...record2, promptPreview: record2.promptPreview.slice(0, PREVIEW_MAX_LENGTH) };
   appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: LEDGER_FILE_MODE });
@@ -23857,25 +24599,33 @@ async function fileSessionUnderProject(context, env, input) {
   if (!viaWorktree) return;
   await context.rest.assignSessionToProject(viaWorktree.projectId, input.sessionId, viaWorktree.worktreeId);
 }
-function rejectedSteer(error) {
-  return {
-    accepted: false,
-    reason: /\bin[- ]flight\b/i.test(error) ? "in-flight" : "rejected",
-    error
-  };
-}
-async function steerAgentSession(transport, sessionId, text2) {
-  try {
-    const result = await transport.rpc(sessionId, "steer", { text: text2 });
-    if (result?.success === true) return { accepted: true };
-    const error = typeof result?.error === "string" ? result.error : "Session returned an invalid steer acknowledgement.";
-    return rejectedSteer(error);
-  } catch (error) {
-    return rejectedSteer(error instanceof Error ? error.message : String(error));
-  }
+const ACTIVITY_WAIT_TIMEOUT_MS = 5e3;
+function waitForResponseActivity(transport, sessionId) {
+  return new Promise((resolve) => {
+    let unsubscribe = () => {
+    };
+    const finish = (thinking) => {
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(thinking);
+    };
+    const timer = setTimeout(() => finish(null), ACTIVITY_WAIT_TIMEOUT_MS);
+    unsubscribe = transport.onEphemeral((event) => {
+      if (!event || typeof event !== "object") return;
+      const activity = event;
+      if (activity.type !== "activity" || activity.id !== sessionId || typeof activity.thinking !== "boolean") return;
+      finish(activity.thinking);
+    });
+  });
 }
 async function stopAgentSession(transport, machineId, sessionId) {
   try {
+    const thinking = await waitForResponseActivity(transport, sessionId);
+    if (thinking !== true) return {
+      stopped: false,
+      reason: thinking === false ? "not-responding" : "rejected",
+      error: thinking === false ? "Session has no active response." : "Could not confirm the session response state."
+    };
     const result = await transport.rpc(machineId, "stop-session", {
       sessionId,
       source: "saycode-agent-stop",
@@ -23883,17 +24633,37 @@ async function stopAgentSession(transport, machineId, sessionId) {
       mode: "force"
     });
     if (result?.stopped === true) return { stopped: true };
-    return {
+    if (result?.stopped === false) return {
       stopped: false,
-      error: typeof result?.reason === "string" ? result.reason : "Machine returned an invalid stop acknowledgement."
+      reason: "not-responding",
+      error: typeof result.reason === "string" ? result.reason : "Session has no active response."
     };
+    return { stopped: false, reason: "rejected", error: "Machine returned an invalid stop acknowledgement." };
   } catch (error) {
     return {
       stopped: false,
+      reason: "rejected",
       error: error instanceof Error ? error.message : String(error)
     };
   }
 }
+function rejectedSteer(error) {
+  return {
+    accepted: false,
+    reason: /\bin[- ]flight\b/i.test(error) ? "in-flight" : "rejected",
+    error
+  };
+}
+async function steerAgentSession(transport, sessionId, text2) {
+  try {
+    const result = await transport.rpc(sessionId, "steer", { text: text2 });
+    if (result?.success === true) return { accepted: true };
+    const error = typeof result?.error === "string" ? result.error : "Session returned an invalid steer acknowledgement.";
+    return rejectedSteer(error);
+  } catch (error) {
+    return rejectedSteer(error instanceof Error ? error.message : String(error));
+  }
+}
 const STREAM_HISTORY_LIMIT = 50;
 const SPAWN_RPC_TIMEOUT_MS = 6e4;
 function isReadableFileSync(path) {
@@ -23975,7 +24745,7 @@ async function openStream(context, transport, sessionId) {
 }
 function createAgentRuntime(context, transport, env = process.env) {
   const keys = [decodeBase64(context.syncCredential.secret)];
-  const homeDir = context.homeDir;
+  const homeDir = context.homeDir, lineageRoot = readAgentEnv(env)?.root ?? context.homeDir;
   const credentialHome = context.credential.source === "saycode" ? null : dirname(context.credential.path);
   return {
     env,
@@ -24005,6 +24775,8 @@ function createAgentRuntime(context, transport, env = process.env) {
         {
           directory: input.directory,
           agent: input.agent,
+          ...input.model ? { model: input.model } : {},
+          ...input.effort ? { effort: input.effort } : {},
           initialPrompt: input.initialPrompt,
           environmentVariables: input.environmentVariables
         },
@@ -24014,9 +24786,9 @@ function createAgentRuntime(context, transport, env = process.env) {
       return { sessionId: result.sessionId };
     },
     newAgentId: () => randomBytes(8).toString("hex"),
-    countSpawns: (agentKey) => countSpawnsFor(homeDir, agentKey),
-    recordSpawn: (record2) => appendSpawnRecord(homeDir, record2),
-    readLineage: () => readSpawnRecords(homeDir),
+    countSpawns: (agentKey) => countSpawnsFor(homeDir, lineageRoot, agentKey),
+    recordSpawn: (record2) => appendSpawnRecord(lineageRoot, record2),
+    readLineage: () => readSpawnRecords(homeDir, lineageRoot),
     steerSession: (sessionId, text2) => steerAgentSession(transport, sessionId, text2),
     stopSession: (machineId, sessionId) => stopAgentSession(transport, machineId, sessionId),
     // Omitted entirely without API access: a Happy `access.key` is sync-only, so