@buzzni/saycode-cli 0.3.0 → 0.3.2

package/README.md

@@ -124,7 +124,8 @@ happy agent stop <id>           # 사용자가 명시한 경우에만 현재 응
 
 `steer` 성공의 `accepted:true`는 세션 RPC가 요청을 받았다는 뜻이며 실제 transcript 전달 완료를
 뜻하지 않습니다(`delivered:false`). 끝난 턴의 후속 작업에는 `prompt`를 사용합니다. `steer`와
-`stop`은 원장으로 소유권이 증명된 최대 2단계 자식만 허용하며, `stop`은 보관·삭제를 하지 않습니다.
+`stop`은 원장에 기록된 최대 2단계 자식만 허용하며, `stop`은 보관·삭제를 하지 않습니다. 이 원장 검사는
+같은 OS 사용자 아래의 오조작을 줄이는 advisory 가드레일이며 보안 경계나 서버 측 권한 증명은 아닙니다.
 같은 worktree에는 동시에 둘 이상의 쓰기 자식을 만들지 말고 격리가 필요하면 Desktop의 관리형
 worktree 병렬 실행을 사용하세요.
 

package/index.mjs

@@ -40,20 +40,20 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version = "0.3.0";
+const version = "0.3.2";
 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;
 }
@@ -67,8 +67,9 @@ function parseAgentArgs(flags, positionals) {
     return fail(`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":
@@ -86,7 +87,7 @@ function parseAgentArgs(flags, positionals) {
     }
     case "prompt": {
       if (!target) return fail("agent prompt needs a session id (see `saycode agent ls`)");
-      const text2 = rest.slice(1).join(" ").trim();
+      const text2 = rest.slice(hasPositionalTarget ? 1 : 0).join(" ").trim();
       if (!text2) return fail("agent prompt needs the text to send");
       return {
         command: "agent",
@@ -118,7 +119,9 @@ function parseAgentArgs(flags, positionals) {
           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();
@@ -128,6 +131,8 @@ function parseAgentArgs(flags, positionals) {
         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 } : {}
       };
     }
@@ -296,7 +301,8 @@ const completionInboxKo = {
   "completionInbox.emptyReadDescription": "확인한 알림이 여기에 표시됩니다.",
   "completionInbox.unreadList": "미확인 알림 목록",
   "completionInbox.readList": "확인한 알림 목록",
-  "completionInbox.projectFallback": "프로젝트"
+  "completionInbox.projectFallback": "프로젝트",
+  "completionInbox.platformNoticeFallbackTitle": "알림"
 };
 const agentBoardKo = {
   "agentBoard.preparingResponse": "응답을 준비하는 중…",
@@ -622,8 +628,30 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.scheduleDaily": "매일 지정 시각",
   "scheduledAutomations.intervalMinutesLabel": "실행 주기(분, 최소 {min}분)",
   "scheduledAutomations.dailyTimeLabel": "실행 시각",
-  "scheduledAutomations.scriptLabel": "감시 스크립트 커맨드 (선택)",
+  "scheduledAutomations.monitorLabel": "변화 감지 커맨드 (선택)",
+  "scheduledAutomations.executionConditionLabel": "실행 조건",
+  "scheduledAutomations.executionEverySchedule": "예약마다 실행",
+  "scheduledAutomations.executionOnChange": "감시 결과가 바뀔 때만 실행",
+  "scheduledAutomations.advancedOptions": "고급 옵션 보기",
+  "scheduledAutomations.changeDetectionBadge": "변화 감지",
+  "scheduledAutomations.executionDetails": "실행 상세",
+  "scheduledAutomations.lastChange": "마지막 변화: {time}",
+  "scheduledAutomations.monitorOutputTitle": "최근 감시 출력",
+  "scheduledAutomations.monitorRequired": "변화 감지 명령을 입력하세요.",
+  "scheduledAutomations.templateLabel": "시작 템플릿",
+  "scheduledAutomations.templateNone": "직접 설정",
+  "scheduledAutomations.templateService": "서비스 상태 변화",
+  "scheduledAutomations.templateCommand": "명령 출력 변화",
+  "scheduledAutomations.templateHint": "템플릿은 폼만 채웁니다. 명령을 입력하고 확인한 뒤 직접 저장하세요.",
+  "scheduledAutomations.templateServiceName": "서비스 상태 감시",
+  "scheduledAutomations.templateCommandName": "명령 출력 감시",
+  "scheduledAutomations.templateServicePrompt": "서비스 상태가 어떻게 바뀌었는지 분석하고 필요한 조치를 제안해줘.",
+  "scheduledAutomations.templateCommandPrompt": "명령 출력의 변화를 분석하고 중요한 차이와 필요한 조치를 알려줘.",
+  "scheduledAutomations.monitorHint": "출력이 이전 성공 실행과 정확히 같으면 gate와 세션 실행을 생략합니다.",
+  "scheduledAutomations.notepadTitle": "자동화 메모장",
+  "scheduledAutomations.scriptLabel": "실행 gate 커맨드 (선택)",
   "scheduledAutomations.scriptHint": '마지막 줄이 {"wakeAgent": false} JSON이면 세션을 깨우지 않습니다.',
+  "scheduledAutomations.scriptHintFallback": '마지막 줄 JSON의 {"wakeAgent": false}는 세션을 깨우지 않고, {"notepad": {"key": "value"}}는 읽기 전용 메모장을 갱신합니다.',
   "scheduledAutomations.scriptWarning": "이 커맨드는 프로젝트 머신에서 사용자 권한으로 실행됩니다.",
   "scheduledAutomations.suppressSilentLabel": "응답이 [SILENT]면 알림 배지 생략",
   "scheduledAutomations.save": "저장",
@@ -637,6 +665,7 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.nextRun": "다음 실행: {time}",
   "scheduledAutomations.historyTitle": "최근 실행",
   "scheduledAutomations.outcomeWoke": "세션 실행",
+  "scheduledAutomations.outcomeNoChange": "모니터 변화 없음(스킵)",
   "scheduledAutomations.outcomeSkippedGate": "변화 없음(스킵)",
   "scheduledAutomations.outcomeSkippedOverlap": "이전 실행 진행 중(스킵)",
   "scheduledAutomations.outcomeSilent": "이상 없음([SILENT])",
@@ -656,6 +685,7 @@ const scheduledAutomationsKo = {
   "scheduledAutomations.errorViewerKeyInUse": "기존 DB 자동화가 다른 암호화 키를 사용하고 있어 자동으로 전환할 수 없습니다. 기존 DB 자동화를 삭제한 뒤 다시 시도하세요.",
   "scheduledAutomations.errorWorkspaceMissing": "프로젝트 작업 폴더를 찾을 수 없습니다.",
   "scheduledAutomations.errorMachineOffline": "프로젝트 머신이 오프라인입니다.",
+  "scheduledAutomations.errorMonitorUnsupported": "대상 daemon이 변화 감지 자동화를 지원하지 않습니다. 연결 상태를 확인한 뒤 다시 시도하세요.",
   "scheduledAutomations.errorUnavailable": "자동화 서비스를 현재 사용할 수 없습니다.",
   "scheduledAutomations.runNow": "바로 실행",
   "scheduledAutomations.runRequestedNotice": "자동화 실행을 요청했습니다."
@@ -1299,6 +1329,9 @@ const subagentKo = {
   "subagent.error.inFlight": "이전 제어 요청을 처리하는 중입니다.",
   "subagent.error.rejected": "요청이 거부됐습니다: {detail}"
 };
+const reviewNavigationKo = {
+  "review.action.openSourceSession": "원본 대화로 이동: {title}"
+};
 const aiCommitPrKo = {
   "aiCommitPr.stagedCount": "스테이지된 파일 {count}개",
   "aiCommitPr.noStaged": "스테이지된 변경이 없습니다.",
@@ -1339,7 +1372,39 @@ 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 catalogExtensionsKo = { ...taskNotificationKo, ...machineUsageKo, ...completionInboxKo, ...agentBoardKo, ...fanoutLifecycleKo, ...conversationSearchKo, ...browserCookieImportKo, ...orcaPortKo, ...usageAnalyticsKo, ...outboundWebhookKo, ...scheduledAutomationsKo, ...githubTriggersKo, ...memoryHubKo, ...extensionPanelKo, ...extensionInstallKo, ...personalChatsKo, ...newSessionStarterKo, ...browserConsoleCaptureKo, ...completionSignalKo, ...agentLoopDetectionKo, ...operationModelRetryKo, ...skillCatalogKo, ...ciAutoFixKo, ...collaborationKo, ...backgroundTaskKo, ...sessionTitleKo, ...accountSettingsKo, ...projectScopeKo, ...machineSettingsConsoleKo, ...sessionTokenUsageKo, ...worktreeSetupKo, ...connectionIndicatorKo, ...voiceDictationKo, ...newSessionProfileKo, ...agentBoardBroadcastKo, ...judgementEvidenceKo, ...releaseNoteKo, ...notificationSoundKo, ...officeViewerKo, ...additionalDirectoriesKo, ...agentHandoffKo, ...sidebarUpdateKo, ...autopilotSelfReviewRoundsKo, ...aiCommitPrKo, ...externalWorktreeInboxKo, ...externalSessionVaultKo, ...terminalFontKo, ...globalPauseKo, ...subagentKo, ...reviewNavigationKo, ...projectLinksKo, ...projectHandoffKo };
 const onboardingKo = {
   "onboarding.dialogAria": "시작 설정",
   "onboarding.eyebrow": "처음 시작하기",
@@ -2000,6 +2065,10 @@ const ko = {
   "worktreePathCopy.copy": "worktree 경로 복사",
   "worktreePathCopy.copied": "worktree 경로 복사됨",
   "worktreePathCopy.failed": "worktree 경로 복사 실패",
+  "sessionWorktree.worktree": "워크트리: {name}",
+  "sessionWorktree.branch": "브랜치: {branch}",
+  "sessionWorktree.path": "경로: {path}",
+  "sessionWorktree.merged": "병합됨",
   // Project git controls
   "gitControls.branchLoading": "Git branch 확인 중",
   "gitControls.noRemote": "origin remote 또는 branch를 찾을 수 없습니다.",
@@ -2008,9 +2077,9 @@ const ko = {
   "gitControls.manageBranchAria": "{branch} branch 관리",
   "gitControls.manageBranchTitle": "Branch 변경 및 생성",
   "gitControls.manageBranchTitleWithDesc": "Branch 변경 및 생성 · {description}",
-  "gitControls.pullAria": "{branch} branch pull",
+  "gitControls.pullAria": "{branch} 브랜치 pull",
   "gitControls.pullTitle": "{branch} pull",
-  "gitControls.pushAria": "{branch} branch push",
+  "gitControls.pushAria": "{branch} 브랜치 push",
   "gitControls.pushTitle": "{branch} push",
   "gitControls.manageWorktreeAria": "{name} worktree 관리",
   "gitControls.manageWorktreeTitle": "Worktree 관리",
@@ -2278,6 +2347,7 @@ const ko = {
   "projectSettings.tabRepository": "코드 저장소",
   "projectSettings.tabDeploy": "배포 저장소",
   "projectSettings.tabCollaboration": "협업",
+  "projectSettings.tabLinks": "관련 프로젝트",
   "projectSettings.tabMachine": "머신 및 경로",
   "projectSettings.tabRun": "실행",
   "projectSettings.tabMcp": "MCP 서버/스킬",
@@ -2733,6 +2803,8 @@ const ko = {
   "standaloneImport.doneSummary": "프로젝트 {projects}개, 세션 {sessions}개를 가져왔어요.",
   "standaloneImport.doneSkipped": "이미 가져온 세션 {count}개는 건너뛰었어요.",
   "standaloneImport.undecryptable": "복호화할 수 없어 건너뛴 메시지가 {count}개 있어요.",
+  "standaloneImport.undecryptableMetadata": "세션 {count}개의 메타데이터 또는 에이전트 상태를 복호화하지 못해 일부 상태 없이 가져왔어요.",
+  "standaloneImport.failedProjects": "프로젝트 {count}개를 가져오지 못했어요. 가능한 세션은 프로젝트 연결 없이 가져왔어요.",
   "standaloneImport.failedSessions": "세션 {count}개를 가져오지 못했어요. 다시 실행하면 이어서 시도해요.",
   "standaloneImport.fatalError": "가져오기를 시작하지 못했어요: {error}",
   "standaloneImport.settingsBody": "이 컴퓨터의 로컬 전용 모드 데이터를 현재 계정으로 복사해요.",
@@ -2905,6 +2977,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}",
@@ -3211,6 +3284,8 @@ const ko = {
   "sessionsTab.searchFailed": "사용자 프롬프트를 검색하지 못했습니다. 제목 검색 결과만 표시합니다.",
   "sessionsTab.noSearchResults": "“{query}”와 일치하는 대화가 없습니다.",
   "sessionsTab.clearSearch": "검색 지우기",
+  "sessionsTab.noVisibleMessage": "표시할 메시지가 아직 없습니다",
+  "sessionsTab.updated": "업데이트",
   // Planning / preview sidecar / preview tab
   "previewSidecar.closeAria": "Preview 닫기",
   "preview.serverStarting": "서버 시작 중...",
@@ -3268,6 +3343,7 @@ const ko = {
   "saycodePromptPreference.eyebrow": "에이전트 지시 선택",
   "saycodePromptPreference.title": "Saycode 기본 지시를 사용할까요?",
   "saycodePromptPreference.body": "내가 만든 Claude/Codex 스킬과 하네스를 그대로 쓰려면 꺼진 상태를 유지하세요. 나중에 환경설정에서 언제든 바꿀 수 있습니다.",
+  "saycodePromptPreference.defaultOnNotice": "자식 Agent 호출, 내부 작업 위임, 결과물 인라인 미리보기는 기본으로 계속 켜집니다. 이 기능도 끄려면 환경설정 → 시스템 프롬프트에서 각각 해제하세요.",
   "saycodePromptPreference.keepOff": "꺼진 상태 유지",
   "saycodePromptPreference.enable": "Saycode 지시 켜기",
   "saycodePromptPreference.saving": "저장 중…",
@@ -3276,14 +3352,18 @@ 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 워크플로우의 기본 지시를 사용합니다.",
   "saycodePromptPreference.block.coAuthoredCredit.label": "커밋 크레딧",
   "saycodePromptPreference.block.coAuthoredCredit.description": "커밋 메시지에 Claude와 Happy 공동 작성자 표시를 추가합니다.",
+  "saycodePromptPreference.block.inlinePreview.label": "결과물 인라인 미리보기",
+  "saycodePromptPreference.block.inlinePreview.description": "HTML 결과물을 만들면 답변 안에 미리보기를 띄우도록 지시합니다.",
   "saycodePromptPreference.loading": "계정 설정을 불러오는 중…",
   "standalone.zrokStatus": "zrok 상태",
   "standalone.zrokNeeded": "zrok2 설정이 필요합니다",
@@ -3834,6 +3914,7 @@ const ko = {
   "review.self.loopStop": "반복 중지",
   "review.self.loopDismiss": "기록 지우기",
   "review.self.loopDone": "반복 리뷰 종료 ({rounds}회) — {reason}",
+  "review.self.startCancelled": "다른 창의 작업으로 반복 리뷰 시작이 취소됐어요.",
   "review.self.loopReason.clean": "지적 없음",
   "review.self.loopReason.belowThreshold": "low·nit만 남아 조기 종료",
   "review.self.loopReason.roundsExhausted": "지정한 횟수를 모두 사용",
@@ -4415,7 +4496,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
@@ -4438,7 +4519,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).
 
@@ -6837,6 +6919,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",
@@ -15966,6 +16100,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);
@@ -16000,6 +16159,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,
@@ -16026,6 +16186,7 @@ function apiSessionToSession(api, candidateKeys, existing) {
     ...currentModelCode ? { currentModelCode } : {},
     ...tokenUsage ? { tokenUsage } : {},
     ...slashCommands ? { slashCommands } : {},
+    ...mcpServers ? { mcpServers } : {},
     ...claudeSessionId ? { claudeSessionId } : {},
     ...codexThreadId ? { codexThreadId } : {},
     ...lifecycleState ? { lifecycleState } : {},
@@ -16068,11 +16229,16 @@ function readMcpCallerGrantPublicKey(daemonState) {
   const value2 = daemonState.mcpCallerGrantPublicKey;
   return typeof value2 === "string" && value2 ? value2 : void 0;
 }
-function buildWorktreeMutationBody(input) {
+const CLEARABLE_STRING_KEYS = /* @__PURE__ */ new Set(["branch", "baseBranch"]);
+function buildWorktreeMutationBody(input, options = {}) {
   return JSON.stringify(Object.fromEntries(
-    Object.entries(input).filter(([, value2]) => typeof value2 === "string" && value2.length > 0)
+    Object.entries(input).filter(([key, value2]) => (key !== "machinePlatform" || options.includeMachinePlatform) && (typeof value2 === "string" && (value2.length > 0 || CLEARABLE_STRING_KEYS.has(key)) || value2 === null && CLEARABLE_STRING_KEYS.has(key)))
   ));
 }
+const STANDALONE_USER_ID = "standalone-local";
+function isStandaloneAuthSession(session) {
+  return session?.userId === STANDALONE_USER_ID;
+}
 function indexMachineRegistry(entries) {
   const byId = {};
   for (const entry of entries) {
@@ -16137,6 +16303,17 @@ function resolvedProjectPreviewRelayUrl(input) {
   }
   return `${input.syncBaseUrl}/v1/preview/${encodeURIComponent(input.machineId)}/${input.port}/?ptoken=${encodeURIComponent(response.token)}`;
 }
+const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function versionedAutomationBase64(value2, maxBytes, exactBytes) {
+  if (typeof value2 !== "string" || !value2 || value2.length > Math.ceil(maxBytes / 3) * 4 || !BASE64_PATTERN.test(value2)) {
+    throw new Error("automation-response-invalid");
+  }
+  const decoded = Buffer$1.from(value2, "base64");
+  if (decoded.length < 41 || decoded.length > maxBytes || exactBytes !== void 0 && decoded.length !== exactBytes || decoded[0] !== 1) {
+    throw new Error("automation-response-invalid");
+  }
+  return value2;
+}
 function row(value2) {
   if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("automation-response-invalid");
   return value2;
@@ -16158,10 +16335,23 @@ function nullableInteger(value2) {
 function optionalNullableInteger(value2) {
   return value2 === void 0 ? null : nullableInteger(value2);
 }
-function parseServerAutomationPublic(value2) {
+function parseRuntimeState(value2) {
   const item = row(value2);
-  if (item.payloadVersion !== 1 || typeof item.paused !== "boolean") throw new Error("automation-response-invalid");
   return {
+    automationId: stringValue(item.automationId),
+    generation: integer(item.generation, 1),
+    stateVersion: integer(item.stateVersion, 1),
+    stateCiphertext: versionedAutomationBase64(item.stateCiphertext, 96 * 1024),
+    viewerKeyVersion: integer(item.viewerKeyVersion, 1),
+    viewerKeyEnvelope: versionedAutomationBase64(item.viewerKeyEnvelope, 105, 105),
+    machineKeyVersion: integer(item.machineKeyVersion, 1),
+    updatedAt: integer(item.updatedAt)
+  };
+}
+function parseServerAutomationPublic(value2) {
+  const item = row(value2);
+  if (item.payloadVersion !== 1 && item.payloadVersion !== 2 || typeof item.paused !== "boolean") throw new Error("automation-response-invalid");
+  const parsed = {
     id: stringValue(item.id),
     projectId: stringValue(item.projectId),
     ownerAccountId: stringValue(item.ownerAccountId),
@@ -16169,7 +16359,7 @@ function parseServerAutomationPublic(value2) {
     machineId: nullableString(item.machineId),
     revision: integer(item.revision, 1),
     generation: integer(item.generation, 1),
-    payloadVersion: 1,
+    payloadVersion: item.payloadVersion,
     payloadCiphertext: stringValue(item.payloadCiphertext),
     viewerKeyId: stringValue(item.viewerKeyId),
     viewerKeyVersion: integer(item.viewerKeyVersion, 1),
@@ -16181,8 +16371,13 @@ function parseServerAutomationPublic(value2) {
     appliedRevision: integer(item.appliedRevision),
     appliedAt: nullableInteger(item.appliedAt),
     createdAt: integer(item.createdAt),
-    updatedAt: integer(item.updatedAt)
+    updatedAt: integer(item.updatedAt),
+    runtimeState: item.runtimeState === void 0 || item.runtimeState === null ? null : parseRuntimeState(item.runtimeState)
   };
+  if (parsed.payloadVersion === 2 !== (parsed.runtimeState !== null) || parsed.runtimeState && (parsed.runtimeState.automationId !== parsed.id || parsed.runtimeState.generation !== parsed.generation || parsed.runtimeState.viewerKeyVersion !== parsed.viewerKeyVersion || parsed.runtimeState.machineKeyVersion !== parsed.machineKeyVersion)) {
+    throw new Error("automation-response-invalid");
+  }
+  return parsed;
 }
 function parseServerAutomationAdoption(value2) {
   const item = row(value2);
@@ -16203,11 +16398,12 @@ function parseServerAutomationTarget(value2) {
     machinePublicKey: stringValue(item.machinePublicKey),
     machineKeyVersion: integer(item.machineKeyVersion, 1),
     viewerPublicKey: nullableString(item.viewerPublicKey),
-    viewerKeyVersion: integer(item.viewerKeyVersion)
+    viewerKeyVersion: integer(item.viewerKeyVersion),
+    automationProtocolVersion: item.automationProtocolVersion === void 0 ? 1 : integer(item.automationProtocolVersion, 1)
   };
 }
 const RUN_STATUSES = /* @__PURE__ */ new Set(["CLAIMED", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED", "ABANDONED"]);
-const RUN_OUTCOMES = /* @__PURE__ */ new Set(["WOKE", "SILENT", "SKIPPED_GATE", "ERROR"]);
+const RUN_OUTCOMES = /* @__PURE__ */ new Set(["WOKE", "SILENT", "SKIPPED_GATE", "NO_CHANGE", "ERROR"]);
 function parseServerAutomationRun(value2) {
   const item = row(value2);
   if (!RUN_STATUSES.has(item.status) || item.outcome !== null && !RUN_OUTCOMES.has(item.outcome) || typeof item.lateReport !== "boolean") throw new Error("automation-response-invalid");
@@ -16463,6 +16659,7 @@ function normalizeAutomationSupport(value2) {
   return {
     rpcAvailable: capability.rpcAvailable,
     serverBacked: capability.serverBacked === true,
+    ...typeof capability.monitorMode === "boolean" ? { monitorMode: capability.monitorMode } : {},
     ...Number.isSafeInteger(capability.keyVersion) && capability.keyVersion > 0 ? { keyVersion: capability.keyVersion } : {}
   };
 }
@@ -16506,7 +16703,8 @@ class ApiClient {
       apiBaseUrl: session.apiBaseUrl,
       syncBaseUrl: session.happyBaseUrl,
       apiToken: session.token,
-      syncToken: session.syncToken || session.token
+      syncToken: session.syncToken || session.token,
+      standalone: isStandaloneAuthSession(session)
     });
   }
   async login(input) {
@@ -16571,6 +16769,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",
@@ -16586,6 +16895,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);
@@ -16601,12 +16911,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)}`,
@@ -16932,19 +17252,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");
@@ -17585,7 +17909,7 @@ class ApiClient {
       {
         method: "POST",
         boundary: "api",
-        body: buildWorktreeMutationBody(input)
+        body: buildWorktreeMutationBody(input, { includeMachinePlatform: this.config.standalone })
       }
     );
     return data.worktree;
@@ -20216,6 +20540,22 @@ class ChatInputController {
     this.readline.off("close", this.handleClose);
   }
 }
+const MACOS_FIRMLINK_ALIASES = [
+  ["/tmp", "/private/tmp"],
+  ["/var", "/private/var"],
+  ["/etc", "/private/etc"]
+];
+function canonicalizeMacOsFirmlinkAlias(path) {
+  for (const [logical, physical] of MACOS_FIRMLINK_ALIASES) {
+    if (path === logical) return physical;
+    if (path.startsWith(`${logical}/`)) return physical + path.slice(logical.length);
+  }
+  return path;
+}
+function canonicalizeRemotePathForComparison(value2, platform2) {
+  const normalized = value2.trim().replace(/\/+$/, "");
+  return platform2 === "darwin" ? canonicalizeMacOsFirmlinkAlias(normalized) : normalized;
+}
 function worktreeTargetMismatch(record2, expected) {
   if (record2.projectId !== expected.projectId) return "project";
   if (record2.machineId !== expected.machineId) return "machine";
@@ -20273,32 +20613,15 @@ function resolveWorktreeName(input) {
 }
 const MANAGED_WORKTREE_SEGMENT = "/.aplus/worktrees/";
 const MAX_MANAGED_WORKTREE_DEPTH = 2;
-function isWorktreePathWithinProjectRoot(projectRoot, worktreePath) {
-  const root = projectRoot.trim().replace(/\/+$/, "");
-  const path = worktreePath.trim().replace(/\/+$/, "");
+function isWorktreePathWithinProjectRoot(projectRoot, worktreePath, platform2) {
+  const root = canonicalizeRemotePathForComparison(projectRoot, platform2);
+  const path = canonicalizeRemotePathForComparison(worktreePath, platform2);
   if (!root || !path) return false;
   if (!path.startsWith(`${root}${MANAGED_WORKTREE_SEGMENT}`)) return false;
   const segments = path.slice(root.length + MANAGED_WORKTREE_SEGMENT.length).split("/");
   if (segments.length < 1 || segments.length > MAX_MANAGED_WORKTREE_DEPTH) return false;
   return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
-async function createWorktreeOnMachine(input) {
-  const record2 = await input.client.createProjectWorktree(input.projectId, {
-    name: input.name,
-    baseRef: input.baseRef,
-    machineId: input.machineId,
-    ...input.confirmRepoRoot ? { confirmRepoRoot: input.confirmRepoRoot } : {}
-  });
-  const targetMismatch = worktreeTargetMismatch(record2, {
-    projectId: input.projectId,
-    machineId: input.machineId
-  });
-  const allowedRoot = input.confirmRepoRoot ?? input.repoCwd;
-  const pathMatches = isWorktreePathWithinProjectRoot(allowedRoot, record2.path);
-  if (!targetMismatch && pathMatches) return record2;
-  await input.client.deleteProjectWorktree(input.projectId, record2.id, true).catch(() => void 0);
-  throw new Error(!pathMatches && input.pathMismatchMessage ? input.pathMismatchMessage(record2.path) : input.targetMismatchMessage);
-}
 const WORKTREE_SUBDIR_CONFIRM_CODE = "worktree-subdir-confirm-required";
 function trimmedString(value2) {
   if (typeof value2 !== "string") return null;
@@ -20338,6 +20661,23 @@ function parseWorktreeSubdirConfirmRequest(status, body, projectRoot) {
   if (!isSafeRelativeDir(repoRelativeDir)) return null;
   return { repoRoot, workspaceDir, repoRelativeDir };
 }
+async function createWorktreeOnMachine(input) {
+  const record2 = await input.client.createProjectWorktree(input.projectId, {
+    name: input.name,
+    baseRef: input.baseRef,
+    machineId: input.machineId,
+    ...input.confirmRepoRoot ? { confirmRepoRoot: input.confirmRepoRoot } : {}
+  });
+  const targetMismatch = worktreeTargetMismatch(record2, {
+    projectId: input.projectId,
+    machineId: input.machineId
+  });
+  const allowedRoot = input.confirmRepoRoot ?? input.repoCwd;
+  const pathMatches = isWorktreePathWithinProjectRoot(allowedRoot, record2.path, input.machinePlatform);
+  if (!targetMismatch && pathMatches) return record2;
+  await input.client.deleteProjectWorktree(input.projectId, record2.id, true).catch(() => void 0);
+  throw new Error(!pathMatches && input.pathMismatchMessage ? input.pathMismatchMessage(record2.path) : input.targetMismatchMessage);
+}
 async function createCliProjectWorktree(input, deps) {
   const createInput = {
     client: {
@@ -23307,7 +23647,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(
@@ -23346,6 +23686,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;
@@ -23451,7 +23792,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,
@@ -23492,24 +23833,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) {
@@ -23563,7 +23907,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}`);
   }
@@ -23591,6 +23935,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;
@@ -23640,7 +23985,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") {
@@ -23648,10 +23994,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);
@@ -23676,6 +24025,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,25 +24130,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",
@@ -23796,17 +24164,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) {
@@ -23827,7 +24215,7 @@ function readFileOrNull(path) {
 async function recentContents(context, transport, sessionId, limit) {
   const messages = await context.rest.recentMessages(sessionId, limit);
   const contents = [];
-  for (const message of messages) {
+  for (const message of [...messages].sort((left, right) => left.seq - right.seq)) {
     const ciphertext = unwrapEncryptedField(message.content);
     if (!ciphertext) continue;
     const content = decodeContent(transport, ciphertext);
@@ -23918,6 +24306,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
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buzzni/saycode-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Drive Saycode sessions across your machines from the terminal.",
   "type": "module",
   "bin": {