appback-remoteagent 0.23.4 → 0.23.6

package/README.md

@@ -111,7 +111,7 @@ Current command surface implemented in `src/bot.ts`:
 | `/sandbox [codex <mode>]` | Lists Codex sandbox choices or changes the current session sandbox |
 | `/option retry <count>` | Sets the automatic continuation turn limit and persists it to `~/.remoteagent/.env` |
 | `/option timeout <seconds>` | Sets the provider execution timeout and persists it to `~/.remoteagent/.env` |
-| `/option intent <count>` | Sets retries for untagged intent-only provider replies and persists it to `~/.remoteagent/.env` |
+| `/option intent <count>` | Retired compatibility command; explains that untagged replies are delivered without content-based retries. |
 | `/state` | Shows the session ledger that is injected as provider context |
 | `/state clear` | Clears the current session ledger without deleting the session |
 | `/state note <text>` | Adds an operator note to the session ledger |
@@ -122,8 +122,8 @@ Current command surface implemented in `src/bot.ts`:
 | `/bot remove <username\|id>` | Removes a configured Telegram bot, restarts the runtime, and confirms the result after restart |
 | `/bot reload` | Restarts the runtime and confirms the result after restart |
 | `/install codex\|claude` | Runs the configured provider install or update command for the bot owner |
-| `/login codex` | Starts the Codex device-auth login flow and returns a browser URL when available |
-| `/login claude [token]` | Starts or finishes the configured Claude Code login flow for the bot owner |
+| `/login` | Owner-only GitHub / Codex / Claude selection buttons; returns authentication URL and any device code, then reports completion |
+| `/login github\|codex\|claude` | Starts the selected login directly; `git` is an alias for `github` |
 | `/reset` | Clears the current chat binding |
 | `/batch start` | Starts manual batching of multiple text messages |
 | `/batch send` | Sends the collected batch |
@@ -186,7 +186,7 @@ Current Claude behavior:
 - fresh pairing from Telegram
 - attach to existing `session_id`
 - continue the same Claude Code session across turns
-- optional owner-only install/login flow through `/install claude` and `/login claude [token]`
+- owner-only installation through `/install claude` and browser authentication through `/login` → Claude
 
 ### 5. Telegram attachments
 
@@ -302,8 +302,7 @@ Recommended Linux hooks in this repo:
 - `CLAUDE_COMMAND`
 - `CLAUDE_PERMISSION_MODE`
 - `CLAUDE_INSTALL_COMMAND`
-- `CLAUDE_LOGIN_START_COMMAND`
-- `CLAUDE_LOGIN_FINISH_COMMAND`
+- `CLAUDE_LOGIN_FINISH_COMMAND` (legacy `/login claude <token>` compatibility only)
 - `REMOTEAGENT_SERVICE_NAME`
 - `BOT_RESTART_HELPER_PATH`
 - `LOCAL_UI_ENABLED`
@@ -387,15 +386,20 @@ Then open Telegram and start with one of these common flows. `/start` without a
 /start claude
 /install codex
 /install claude
+/login
+/login github
 /login codex
 /login claude
-/login claude <token>
 /attach codex <thread_id>
 /attach claude <session_id>
 ```
 
 Once a chat is bound, ordinary text messages continue the active session. Supported attachments can also be sent directly as normal Telegram messages.
 
+`/login` authenticates the server's RemoteAgent OS account without creating a new
+session or changing its model. Already authenticated accounts offer a **Log in
+again** button. See [Login guide](docs/LOGIN.md) for prerequisites and expiry.
+
 ## Architecture and operations
 
 High-level architecture: [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)

package/dist/adapters/codex-adapter.js

@@ -194,16 +194,28 @@ export class CodexAdapter {
     formatProcessError(stdout, stderr, timedOut = false, code) {
         const structured = this.extractStructuredError(stdout, stderr);
         if (structured) {
-            return structured;
+            return this.addUpgradeGuidance(structured);
         }
         const text = this.extractPlainTextError(stdout, stderr);
         if (text) {
-            return text;
+            return this.addUpgradeGuidance(text);
         }
         return timedOut
             ? this.formatTimeoutError()
             : `Codex process exited with code ${code ?? "unknown"} without stdout/stderr.`;
     }
+    addUpgradeGuidance(message) {
+        if (!/requires a newer version of Codex/i.test(message)) {
+            return message;
+        }
+        return [
+            message,
+            "",
+            "현재 Codex 버전이 선택한 모델을 지원하지 않습니다.",
+            "Telegram에서 /install codex 를 실행하면 최신 버전으로 업데이트됩니다.",
+            "업데이트가 완료되면 같은 세션에서 요청을 다시 보내 주세요.",
+        ].join("\n");
+    }
     extractStructuredError(stdout, stderr) {
         const messages = [];
         for (const line of stdout.split(/\r?\n/)) {

package/dist/bot.js

@@ -9,6 +9,7 @@ import { promisify } from "node:util";
 import { Bot, GrammyError, HttpError } from "grammy";
 import { config } from "./config.js";
 import { ProviderSetupService } from "./services/provider-setup-service.js";
+import { LoginService } from "./services/login-service.js";
 import { RemoteShellService } from "./services/remote-shell-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
 import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
@@ -32,7 +33,7 @@ const HELP_TEXT = [
     "/stop",
     "/sandbox codex <read-only|workspace-write|danger-full-access>",
     "/status",
-    "/option [retry <count>|timeout <seconds>|intent <count>|reasoning <low|medium|high|xhigh|max>|command-menu <on|off|refresh>]",
+    "/option [retry <count>|timeout <seconds>|reasoning <low|medium|high|xhigh|max>|command-menu <on|off|refresh>]",
     "/state [clear|note <text>]",
     "/artifacts list|cleanup <days>",
     "/cleanup",
@@ -47,8 +48,7 @@ const HELP_TEXT = [
     "/bot remove <username|id>",
     "/bot reload",
     "/install codex|claude",
-    "/login codex",
-    "/login claude [token]",
+    "/login - choose GitHub, Codex or Claude",
     "/reset",
     "/! <command>",
     "/!cmd <command>",
@@ -649,7 +649,6 @@ ${bridge.formatStatus(mapping)}`);
                     actionButton(ctx, "Timeout", { kind: "option.show", option: "timeout" }),
                 ],
                 [
-                    actionButton(ctx, "Intent", { kind: "option.show", option: "intent" }),
                     actionButton(ctx, "Reasoning", { kind: "option.show", option: "reasoning" }),
                     actionButton(ctx, "Command menu", { kind: "option.show", option: "command-menu" }),
                 ],
@@ -657,9 +656,11 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         if (option !== "retry" && option !== "timeout" && option !== "intent" && option !== "reasoning" && option !== "command-menu") {
-            await reply(ctx, "Usage: `/option retry <count>`, `/option timeout <seconds>`, `/option intent <count>`, or `/option command-menu <on|off|refresh>`\n\n`retry` controls automatic continuation turns. `timeout` controls one provider execution limit. `intent` controls retries for untagged intent-only provider replies. `command-menu` controls Telegram slash-command autocomplete for all configured bots.", {
-                parse_mode: "Markdown",
-            });
+            await reply(ctx, formatRuntimeOptions());
+            return;
+        }
+        if (option === "intent") {
+            await reply(ctx, "The intent option has been retired. Untagged replies are delivered without content-based retries.");
             return;
         }
         if (!value) {
@@ -708,9 +709,7 @@ ${bridge.formatStatus(mapping)}`);
         if (!Number.isInteger(parsed) || parsed < 0 || String(parsed) !== value.trim()) {
             await reply(ctx, option === "retry"
                 ? "Invalid retry count. Use `0` or a positive integer, for example `/option retry 6`."
-                : option === "intent"
-                    ? "Invalid intent retry count. Use `0` or a positive integer, for example `/option intent 4`."
-                    : "Invalid timeout. Use seconds as a positive integer, for example `/option timeout 600`.", {
+                : "Invalid timeout. Use seconds as a positive integer, for example `/option timeout 600`.", {
                 parse_mode: "Markdown",
             });
             return;
@@ -722,13 +721,6 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, `Set automatic continuation retry limit to ${formatRetryLimit(parsed)}.\n\nSaved: TELEGRAM_AUTO_PROGRESS_MAX_TURNS=${parsed}`);
             return;
         }
-        if (option === "intent") {
-            config.telegramUntaggedIntentRetries = parsed;
-            await upsertInstalledEnvValue("TELEGRAM_UNTAGGED_INTENT_RETRIES", String(parsed));
-            await bridge.logSystem(botId, chatId, `Runtime option TELEGRAM_UNTAGGED_INTENT_RETRIES set to ${parsed}.`);
-            await reply(ctx, `Set untagged intent retry limit to ${formatRetryLimit(parsed)}.\n\nSaved: TELEGRAM_UNTAGGED_INTENT_RETRIES=${parsed}`);
-            return;
-        }
         if (parsed < 10) {
             await reply(ctx, "Invalid timeout. Use at least 10 seconds, for example `/option timeout 600`.", {
                 parse_mode: "Markdown",
@@ -1042,29 +1034,38 @@ ${bridge.formatStatus(mapping)}`);
             return { chunks: flattenChunks([result.output], 3900) };
         });
     });
+    const loginService = new LoginService(15 * 60_000, { codex: config.codexBin, claude: config.claudeBin });
+    const startLogin = async (ctx, target, force = false) => {
+        await ensureOwnerControlAccess(ctx);
+        if (!ctx.chat)
+            throw new Error("Telegram chat context is missing.");
+        const result = await loginService.start(target, force, async (text) => { await reply(ctx, text); });
+        await reply(ctx, result.text, result.alreadyLoggedIn ? keyboardOptions([[
+                actionButton(ctx, "Log in again", { kind: "login.start", target, force: true }),
+            ]]) : undefined);
+    };
     bot.command("login", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const { args, rest } = parseCommand(ctx.message?.text, 1);
         const provider = args[0]?.toLowerCase();
-        if (provider === "codex") {
-            await runWithPendingAnimation(token, ctx.chat.id, async () => {
-                const output = await setupService.startCodexLogin();
-                await bridge.rememberDefaultStartMode("codex");
-                return { chunks: flattenChunks([output], 3900) };
-            });
+        if (!provider) {
+            await reply(ctx, "Choose an account to authenticate on this server. Authentication belongs to the OS account, not an individual session.", keyboardOptions([
+                [actionButton(ctx, "GitHub", { kind: "login.start", target: "github" })],
+                [actionButton(ctx, "Codex", { kind: "login.start", target: "codex" })],
+                [actionButton(ctx, "Claude", { kind: "login.start", target: "claude" })],
+            ]));
             return;
         }
-        if (provider !== "claude") {
-            await reply(ctx, "Usage: `/login codex` or `/login claude` or `/login claude <token>`", { parse_mode: "Markdown" });
+        if (provider === "claude" && rest?.trim()) {
+            await reply(ctx, await setupService.finishClaudeLogin(rest));
             return;
         }
-        await runWithPendingAnimation(token, ctx.chat.id, async () => {
-            const output = rest?.trim()
-                ? await setupService.finishClaudeLogin(rest)
-                : await setupService.startClaudeLogin();
-            await bridge.rememberDefaultStartMode("claude");
-            return { chunks: flattenChunks([output], 3900) };
-        });
+        const target = provider === "git" ? "github" : provider;
+        if (target !== "github" && target !== "codex" && target !== "claude") {
+            await reply(ctx, "Use /login to choose GitHub, Codex or Claude. Direct commands: /login github, /login codex, /login claude. /login git is a GitHub alias.");
+            return;
+        }
+        await startLogin(ctx, target);
     });
     const setChatSandbox = async (ctx, sandboxMode) => {
         if (!ctx.chat) {
@@ -1145,6 +1146,10 @@ ${bridge.formatStatus(mapping)}`);
             text: action.kind === "macro.run" ? "Macro selected." : "Applying...",
         });
         try {
+            if (action.kind === "login.start") {
+                await startLogin(ctx, action.target, action.force);
+                return;
+            }
             if (action.kind === "session.switch") {
                 await reply(ctx, await switchChatSession(ctx, action.selector));
                 return;
@@ -1639,11 +1644,8 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     const emptyResponseRetries = config.telegramEmptyResponseRetries;
     const retryableErrorRetries = config.telegramRetryableErrorRetries;
     const retryableErrorDelayMs = config.telegramRetryableErrorDelayMs;
-    const untaggedIntentRetries = config.telegramUntaggedIntentRetries;
     let emptyResponseRetryCount = 0;
     let retryableErrorCount = 0;
-    let untaggedIntentRetryCount = 0;
-    let missingEvidenceRetryCount = 0;
     let deliveredProgressCount = 0;
     let providerCompleted = false;
     const streamedProgressKeys = new Set();
@@ -1705,23 +1707,12 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
                 emptyResponseRetryCount = 0;
                 retryableErrorCount = 0;
                 if (parsed.kind === "progress") {
-                    untaggedIntentRetryCount = 0;
-                    missingEvidenceRetryCount = 0;
                     const key = progressDeliveryKey(parsed.chunks);
                     if (!streamedProgressKeys.has(key)) {
                         streamedProgressKeys.add(key);
                         deliveredProgressCount += 1;
                         if (currentSession) {
-                            const progress = await memoryService.recordProgress(currentSession.session, parsed.chunks.join("\n"));
-                            if (progress.repeated) {
-                                const repeatedMessage = [
-                                    "Repeated progress detected. The same work pattern has appeared 3 or more times.",
-                                    "Automatic continuation stopped so the task can be inspected instead of looping.",
-                                ].join("\n");
-                                await bridge.logSystem(botId, chatId, repeatedMessage);
-                                autoContinue.clear(botId, chatId, sessionId);
-                                return [repeatedMessage];
-                            }
+                            await memoryService.recordProgress(currentSession.session, parsed.chunks.join("\n"));
                         }
                         await ensureStillBound(`${turnLabel} progress delivery`);
                         await helpers.reportProgress(parsed.chunks);
@@ -1736,26 +1727,6 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
                     continue;
                 }
                 if (parsed.kind === "result") {
-                    untaggedIntentRetryCount = 0;
-                    const resultText = parsed.chunks.join("\n");
-                    const evidenceIssue = classifyMissingResultEvidence(resultText);
-                    if (evidenceIssue && missingEvidenceRetryCount < 1) {
-                        missingEvidenceRetryCount += 1;
-                        const retryMessage = `${turnLabel} returned a result without required evidence: ${evidenceIssue}`;
-                        await bridge.logSystem(botId, chatId, retryMessage);
-                        prompt = appendManagedContext(formatMissingEvidenceRetryPrompt(resultText, evidenceIssue), managedContext);
-                        continue;
-                    }
-                    if (evidenceIssue) {
-                        const blockedMessage = [
-                            "Provider reported a completed result without concrete evidence after a retry.",
-                            `Reason: ${evidenceIssue}`,
-                            "Automatic continuation stopped so the work is not accepted on an unsupported claim.",
-                        ].join("\n");
-                        await bridge.logSystem(botId, chatId, blockedMessage);
-                        autoContinue.clear(botId, chatId, sessionId);
-                        return [blockedMessage];
-                    }
                     await ensureStillBound(`${turnLabel} final delivery`);
                     if (currentSession) {
                         await memoryService.completeTask(currentSession.session, parsed.chunks.join("\n"));
@@ -1765,19 +1736,10 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
                     return parsed.chunks;
                 }
                 if (parsed.kind === "blocked") {
-                    untaggedIntentRetryCount = 0;
-                    missingEvidenceRetryCount = 0;
                     await ensureStillBound(`${turnLabel} final delivery`);
                     autoContinue.clear(botId, chatId, sessionId);
                     return parsed.chunks;
                 }
-                if (looksLikeUntaggedIntentOnlyResponse(parsed.chunks.join("\n")) && untaggedIntentRetryCount < untaggedIntentRetries) {
-                    untaggedIntentRetryCount += 1;
-                    const retryMessage = `${turnLabel} returned an untagged intent-only response; asking provider to do concrete work before replying.`;
-                    await bridge.logSystem(botId, chatId, retryMessage);
-                    prompt = appendManagedContext(formatUntaggedIntentRetryPrompt(parsed.chunks.join("\n")), managedContext);
-                    continue;
-                }
                 await bridge.logSystem(botId, chatId, `${turnLabel} returned an untagged response; treating it as final output.`);
                 autoContinue.clear(botId, chatId, sessionId);
                 return parsed.chunks;
@@ -1966,11 +1928,8 @@ function parseReportResponses(formattedBlocks, transform) {
         const header = lines.slice(0, reportLineIndex).join("\n").trim();
         const reportLine = lines[reportLineIndex].trim();
         const match = /^REPORT:(progress|result|blocked)$/i.exec(reportLine);
-        let kind = match?.[1]?.toLowerCase() ?? "unknown";
+        const kind = match?.[1]?.toLowerCase() ?? "unknown";
         const body = lines.slice(reportLineIndex + 1).join("\n").trim();
-        if ((kind === "progress" || kind === "result") && looksLikeBlockedBody(body)) {
-            kind = "blocked";
-        }
         return {
             kind,
             text: body ? [header, body].filter(Boolean).join("\n") : "",
@@ -2066,107 +2025,9 @@ function escapeTelegramHtml(value) {
 function escapeTelegramHtmlAttribute(value) {
     return escapeTelegramHtml(value).replace(/"/g, "&quot;");
 }
-function looksLikeUntaggedIntentOnlyResponse(text) {
-    const normalized = text.trim();
-    if (!normalized) {
-        return false;
-    }
-    const hasConcreteEvidence = [
-        /REPORT:/i,
-        /(완료|통과|실패|확인 결과|검증 결과|원인|근거|수정했습니다|배포했습니다|커밋|푸시)/,
-        /\b(git status|git diff|npm run|node --check|docker|journalctl|grep|rg)\b/i,
-        /`[^`]+`/,
-        /:\d{1,5}\b/,
-    ].some((pattern) => pattern.test(normalized));
-    if (hasConcreteEvidence) {
-        return false;
-    }
-    return [
-        /(하겠습니다|진행하겠습니다|확인하겠습니다|수정하겠습니다|검증하겠습니다|대조하겠습니다|보겠습니다)/,
-        /(진행해서|확인해서|수정해서|검증해서).*(하겠습니다|진행하겠습니다)/,
-        /\b(I will|I'll|I am going to|going to|will continue|will check|will verify)\b/i,
-    ].some((pattern) => pattern.test(normalized));
-}
-function formatUntaggedIntentRetryPrompt(lastResponse) {
-    return [
-        "The previous response did not follow the REPORT protocol and only stated intent without concrete evidence.",
-        "Do not repeat the plan or say what you will do.",
-        "Do concrete work now before replying again.",
-        "Reply with exactly one first line: REPORT:progress, REPORT:result, or REPORT:blocked.",
-        "If you cannot continue, use REPORT:blocked and state the exact blocker.",
-        "",
-        "Previous invalid response:",
-        lastResponse.trim(),
-    ].join("\n");
-}
-function classifyMissingResultEvidence(text) {
-    const normalized = text.trim();
-    if (!normalized) {
-        return undefined;
-    }
-    if (!looksLikeCompletedWorkClaim(normalized)) {
-        return undefined;
-    }
-    if (hasConcreteResultEvidence(normalized)) {
-        return undefined;
-    }
-    return "REPORT:result claims completed work but does not include concrete evidence.";
-}
-function looksLikeCompletedWorkClaim(text) {
-    return [
-        /(수정|반영|배포|커밋|푸시|전송|생성|삭제|추가|적용|구현|저장|업데이트|등록|제거|정리|마이그레이션|검증|테스트|빌드).{0,24}(완료|했습니다|됐습니다|성공|통과)/,
-        /(완료했습니다|완료됐습니다|끝났습니다|처리했습니다)/,
-        /\b(fixed|implemented|deployed|committed|pushed|sent|created|deleted|updated|added|removed|migrated|verified|passed|completed|built)\b/i,
-    ].some((pattern) => pattern.test(text));
-}
-function hasConcreteResultEvidence(text) {
-    return [
-        /```/,
-        /`[^`]+`/,
-        /\b[0-9a-f]{7,40}\b/i,
-        /sha256:[0-9a-f]{20,}/i,
-        /\b(HTTP\s+\d{3}|exit\s+\d+|active|passed|failed)\b/i,
-        /\b(npm run|git status|git diff|node --check|docker|journalctl|curl|psql|grep|rg|bash)\b/i,
-        /\/[A-Za-z0-9._/-]{3,}/,
-        /\b[A-Za-z0-9._/-]+\.(?:js|ts|tsx|jsx|sql|md|json|yml|yaml|sh|py|css|html|txt|log)\b/,
-        /:\d{1,5}\b/,
-        /(근거|검증|변경 파일|커밋|푸시|배포|로그|명령|출력|파일|라인|경로|상태)\s*:/,
-    ].some((pattern) => pattern.test(text));
-}
-function formatMissingEvidenceRetryPrompt(lastResponse, issue) {
-    return [
-        "The previous REPORT:result was not accepted by RemoteAgent.",
-        issue,
-        "RemoteAgent does not inspect code or decide whether the work is correct.",
-        "You, the provider, must either provide concrete evidence for the completed work or change the reply to REPORT:progress or REPORT:blocked.",
-        "Do not repeat a bare completion claim.",
-        "Reply with exactly one first line: REPORT:progress, REPORT:result, or REPORT:blocked.",
-        "",
-        "Accepted evidence examples: file paths, line references, commands and outputs, log paths, commit IDs, image digests, deployment status, or explicit verification output.",
-        "",
-        "Previous unsupported result:",
-        lastResponse.trim(),
-    ].join("\n");
-}
 function isEmptyResponseError(message) {
     return /empty response|failed without any output|without stdout\/stderr/i.test(message);
 }
-function looksLikeBlockedBody(text) {
-    if (!text.trim()) {
-        return false;
-    }
-    const blockedPatterns = [
-        /\b(sudo|usermod|setfacl|chmod|chown|relogin|re-login|new login session)\b/i,
-        /\b(waiting on|need you to|you need to|please run|please do|manual step|admin step|external fix)\b/i,
-        /\b(permission denied|permission change|ssh access|api key|login required|authentication required)\b/i,
-        /적용되면.*(다시|이어서|계속)/i,
-        /해주시면.*(다시|이어서|계속)/i,
-        /권한.*(필요|없)/i,
-        /로그인 세션.*필요/i,
-        /관리자.*조치/i,
-    ];
-    return blockedPatterns.some((pattern) => pattern.test(text));
-}
 function classifyRetryableProviderIssue(message, retryAfterMs) {
     if (/selected model is at capacity/i.test(message)) {
         return { kind: "capacity", retryAfterMs };
@@ -2531,19 +2392,16 @@ function formatRuntimeOptions() {
         "Runtime options",
         `- retry: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)} (TELEGRAM_AUTO_PROGRESS_MAX_TURNS)`,
         `- timeout: ${formatTimeoutSeconds(config.commandTimeoutMs)} (COMMAND_TIMEOUT_MS)`,
-        `- intent: ${formatRetryLimit(config.telegramUntaggedIntentRetries)} (TELEGRAM_UNTAGGED_INTENT_RETRIES)`,
         `- reasoning: ${getAstraReasoning()} (Astra, server-wide, CODEX_REASONING_EFFORT)`,
         `- command-menu: ${config.telegramCommandMenuEnabled ? "on" : "off"} (TELEGRAM_COMMAND_MENU_ENABLED)`,
         "",
         "Usage:",
         "/option retry <count>",
         "/option timeout <seconds>",
-        "/option intent <count>",
         "/option reasoning <low|medium|high|xhigh|max>",
         "/option command-menu <on|off|refresh>",
         "",
         "`retry 0` disables the automatic continuation limit.",
-        "`intent 0` disables untagged intent-only response retries.",
         "`command-menu refresh` reapplies Telegram slash-command autocomplete without changing the saved option.",
     ].join("\n");
 }
@@ -2555,7 +2413,7 @@ function formatRuntimeOptionDetail(option) {
         return `Current automatic continuation retry limit: ${formatRetryLimit(config.telegramAutoProgressMaxTurns)}\n\nUsage: \`/option retry <count>\``;
     }
     if (option === "intent") {
-        return `Current untagged intent retry limit: ${formatRetryLimit(config.telegramUntaggedIntentRetries)}\n\nUsage: \`/option intent <count>\``;
+        return "The intent option has been retired. Untagged replies are delivered without content-based retries.";
     }
     if (option === "command-menu") {
         return `Current Telegram command menu: ${config.telegramCommandMenuEnabled ? "on" : "off"}\n\nUsage: \`/option command-menu on\`, \`/option command-menu off\`, or \`/option command-menu refresh\``;

package/dist/services/login-service.js

@@ -0,0 +1,129 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import { buildProviderEnv } from "../adapters/runtime-env.js";
+const commands = {
+    github: { bin: "gh", status: ["auth", "status", "--hostname", "github.com"], login: ["auth", "login", "--hostname", "github.com", "--git-protocol", "https", "--web"] },
+    codex: { bin: "codex", status: ["login", "status"], login: ["login", "--device-auth"] },
+    claude: { bin: "claude", status: ["auth", "status"], login: ["auth", "login"] },
+};
+// Shared across Telegram bots: authentication belongs to the OS account, not a chat.
+const active = new Set();
+export function loginHints(raw) {
+    const text = raw.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+    const urls = [...new Set(text.match(/https?:\/\/[^\s<>"\x1b]+/g) ?? [])];
+    if (!urls.length)
+        return undefined;
+    const code = text.match(/(?:one[- ]time|device) code[^\n]*?\b([A-Z0-9]{4}-[A-Z0-9]{4,5})\b/i)?.[1]
+        ?? text.match(/\b([A-Z0-9]{4}-[A-Z0-9]{4,5})\b/)?.[1];
+    return [...urls, ...(code ? [`One-time code: ${code}`] : [])].join("\n");
+}
+export class LoginService {
+    lifetimeMs;
+    binaries;
+    constructor(lifetimeMs = 15 * 60_000, binaries = {}) {
+        this.lifetimeMs = lifetimeMs;
+        this.binaries = binaries;
+    }
+    unavailable(target) {
+        const guidance = target === "github" ? "Install GitHub CLI (gh) on this server."
+            : `Run /install ${target} first.`;
+        return `${commands[target].bin} could not start. ${guidance} If installed, check execution permissions.`;
+    }
+    async status(target) {
+        const command = commands[target];
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.binaries[target] ?? command.bin, command.status, { cwd: os.homedir(), env: buildProviderEnv({}) });
+            let output = "";
+            const timer = setTimeout(() => child.kill("SIGKILL"), 10_000);
+            child.stdout.on("data", chunk => { output = (output + chunk).slice(-16_384); });
+            child.stderr.resume();
+            child.stdin.end();
+            child.on("error", () => { clearTimeout(timer); reject(new Error(this.unavailable(target))); });
+            child.on("close", code => {
+                clearTimeout(timer);
+                if (target === "claude") {
+                    try {
+                        resolve(code === 0 && JSON.parse(output).loggedIn === true);
+                    }
+                    catch {
+                        resolve(false);
+                    }
+                }
+                else
+                    resolve(code === 0);
+            });
+        });
+    }
+    async start(target, force, notify) {
+        if (active.has(target))
+            return { alreadyLoggedIn: false, text: `${target} login is already in progress on this machine.` };
+        active.add(target);
+        try {
+            if (!force && await this.status(target)) {
+                active.delete(target);
+                return { alreadyLoggedIn: true, text: `${target} is already authenticated for OS account ${os.userInfo().username}.` };
+            }
+        }
+        catch (error) {
+            active.delete(target);
+            throw error;
+        }
+        const command = commands[target];
+        return new Promise(resolve => {
+            const child = spawn(this.binaries[target] ?? command.bin, command.login, {
+                cwd: os.homedir(), env: buildProviderEnv({ BROWSER: "echo", GH_BROWSER: "echo" }),
+            });
+            const stopOnExit = () => { child.kill("SIGKILL"); };
+            process.once("exit", stopOnExit);
+            let raw = "";
+            let delivered = "";
+            let settled = false;
+            let expired = false;
+            let notifications = Promise.resolve();
+            const send = (text) => { notifications = notifications.then(() => notify(text)).catch(() => undefined); };
+            const finishStart = (text) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(initialTimer);
+                resolve({ alreadyLoggedIn: false, text });
+            };
+            const initialTimer = setTimeout(() => finishStart(`${target} login is waiting for an authentication URL. Completion or expiry will be reported here.`), 20_000);
+            const expiryTimer = setTimeout(() => { expired = true; child.kill("SIGKILL"); }, this.lifetimeMs);
+            const consume = (chunk) => {
+                raw = (raw + chunk.toString()).slice(-32_768);
+                const hints = loginHints(raw);
+                if (hints && hints !== delivered) {
+                    delivered = hints;
+                    const message = `${target} login (${os.userInfo().username}@${os.hostname()})\n${hints}\nComplete authentication in your browser. Existing sessions remain unchanged.`;
+                    if (settled)
+                        send(message);
+                    else
+                        finishStart(message);
+                }
+            };
+            child.stdout.on("data", consume);
+            child.stderr.on("data", consume);
+            child.stdin.on("error", () => undefined);
+            child.stdin.end("\n");
+            child.on("error", () => finishStart(this.unavailable(target)));
+            child.on("close", async (code) => {
+                process.removeListener("exit", stopOnExit);
+                clearTimeout(expiryTimer);
+                try {
+                    const authenticated = !expired && code === 0 && await this.status(target).catch(() => false);
+                    const message = authenticated ? `${target} login completed and authentication verified.`
+                        : expired ? `${target} login expired after ${Math.round(this.lifetimeMs / 60_000)} minutes. Run /login to retry.`
+                            : `${target} login did not complete (exit=${code}). Authentication was not confirmed. Run /login to retry.`;
+                    if (settled)
+                        send(message);
+                    else
+                        finishStart(message);
+                }
+                finally {
+                    active.delete(target);
+                }
+            });
+        });
+    }
+}

package/dist/services/provider-setup-service.js

@@ -141,13 +141,13 @@ export class ProviderSetupService {
                 if (/not logged in/i.test(statusText)) {
                     return [
                         "Codex is installed but not logged in yet.",
-                        "Next step: run `/login codex` in this chat.",
+                        "Next step: run /login and select Codex.",
                         "If you prefer machine-side auth, you can use `codex login --device-auth` and complete the login in your browser.",
                     ].join("\n");
                 }
             }
             catch {
-                return "Codex is installed. If this machine is not authenticated yet, run `/login codex` or use `codex login --device-auth` on the machine.";
+                return "Codex is installed. To authenticate this server account, run /login and select Codex.";
             }
         }
         if (provider === "claude") {
@@ -157,12 +157,12 @@ export class ProviderSetupService {
                 if (/not logged in|loggedIn:\s*false/i.test(statusText)) {
                     return [
                         "Claude Code is installed but not logged in yet.",
-                        "Next step: run `/login claude` or complete the configured Claude login flow on this machine.",
+                        "Next step: run /login and select Claude.",
                     ].join("\n");
                 }
             }
             catch {
-                return "Claude Code is installed. If this machine is not authenticated yet, run `/login claude` or complete the configured login flow.";
+                return "Claude Code is installed. To authenticate this server account, run /login and select Claude.";
             }
         }
         return undefined;

package/dist/telegram-command-menu.js

@@ -24,7 +24,7 @@ export const TELEGRAM_COMMAND_MENU = [
     { command: "bots", description: "List configured Telegram bots" },
     { command: "bot", description: "Manage Telegram bots" },
     { command: "install", description: "Install or update Codex or Claude" },
-    { command: "login", description: "Run provider login flow" },
+    { command: "login", description: "Choose GitHub, Codex or Claude login" },
     { command: "reset", description: "Clear this chat binding" },
     { command: "help", description: "Show command help" },
 ];

package/docs/LOGIN.md

@@ -0,0 +1,62 @@
+# Server Account Login
+
+Send `/login` in Telegram and select GitHub, Codex, or Claude.
+`/help` lists this entry once. Telegram's slash-command menu offers `/login`;
+provider names are chosen with buttons, not subcommand autocomplete.
+The login applies to the RemoteAgent OS account on that server. Existing
+Telegram sessions and their selected models remain unchanged.
+
+Direct commands:
+
+```text
+/login github
+/login git
+/login codex
+/login claude
+```
+
+GitHub uses `gh auth login --hostname github.com --git-protocol https --web`.
+Codex uses `codex login --device-auth`.
+Claude uses `claude auth login`.
+Install the selected CLI on the server first. For providers, use
+`/install codex` or `/install claude`; GitHub requires the GitHub CLI (`gh`).
+
+An authenticated account gets a "Log in again" button. A new flow reports
+URLs and one-time device codes emitted by the CLI, then checks authentication
+after a successful process exit. Complete the browser flow from your PC.
+One login per provider can run across all bots in the same RemoteAgent process.
+Flows expire after 15 minutes. Restarting RemoteAgent interrupts the flow;
+start `/login` again after a restart. Telegram delivery failure is not an
+authentication failure: `/login` checks the account again.
+
+Raw CLI output is not forwarded. Only authentication URLs, device codes, and
+status messages are delivered. The legacy `/login claude <token>` command
+continues to use its configured finish hook. The button flow uses the native
+Claude CLI, not the old 15-second start hook.
+
+Local regression tests:
+
+```sh
+npm run build
+node scripts/selftest-login.mjs
+npm run selftest:telegram
+```
+
+CLI references: https://cli.github.com/manual/gh_auth_login and
+https://code.claude.com/docs/en/cli-reference.
+
+## Deploy to Server 50
+
+After committing changes, bump the version with `npm run release:version -- patch`,
+commit the version files, and push. Publish and deploy the exact version:
+
+```sh
+npm run release:publish
+npm run release:deploy -- 0.23.6 50
+```
+
+The 50 target uses root SSH to run npm and RemoteAgent as `daone`. It checks
+for active work, stops the runtime, updates the npm package, and restarts it
+from the account home directory. Existing configuration, secrets, and sessions
+remain in place. The existing npm launchers do not require installer regeneration.
+The historical `all` target remains 30/40/26; select 50 explicitly.

package/docs/RESPONSE_ROUTING.md

@@ -0,0 +1,20 @@
+# Provider response routing
+
+RemoteAgent uses the explicit first-line REPORT marker to route provider replies.
+
+- `REPORT:progress`: forward progress and continue within the configured automatic continuation limit.
+- `REPORT:result`: forward the final reply and end the turn.
+- `REPORT:blocked`: forward the reply and end the turn.
+- Missing marker: forward the reply as final output.
+
+The response body is not used to decide whether work happened, whether evidence is adequate, or whether the provider needs permission. Evidence remains a provider reporting instruction, not a delivery gate. Recording a final reply does not certify project completion.
+
+Repeated progress text is deduplicated for delivery. It does not override the explicit status. The configured continuation limit, user stop requests, and session binding checks control further executions.
+
+The retired `/option intent` command returns a compatibility notice. Existing `TELEGRAM_UNTAGGED_INTENT_RETRIES` values no longer trigger executions.
+
+## Verification
+
+Run `npm run selftest:telegram` to exercise S091 requirement corrections and negations, final replies without evidence, untagged replies, explicit progress and blocked states, queued instruction removal, timeout handling, and stopping an active progress turn.
+
+The S091 incident was caused by body regexes matching both "정리했습니다" and "완료 보고가 아닙니다" as completion claims. Those classifiers and their corrective retry prompts have been removed rather than expanded with word exceptions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.23.4",
+  "version": "0.23.6",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",

package/scripts/release-deploy.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 usage() {
-  echo "Usage: npm run release:deploy -- <version> <30|40|26|all>" >&2
+  echo "Usage: npm run release:deploy -- <version> <30|40|26|50|all>" >&2
   echo "Example: npm run release:deploy -- 0.15.5 all" >&2
 }
 
@@ -20,7 +20,7 @@ if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
 fi
 
 case "$TARGET" in
-  30|40|26|all)
+  30|40|26|50|all)
     ;;
   *)
     usage
@@ -192,6 +192,31 @@ fi
 REMOTE
 }
 
+deploy_50() {
+  ssh root@192.168.33.50 "runuser -u daone -- env VERSION=$VERSION PATH=/home/daone/.nvm/versions/node/v22.23.2/bin:/usr/local/bin:/usr/bin:/bin bash -s" <<'REMOTE'
+set -euo pipefail
+cd "$HOME"
+node --input-type=module - <<'NODE'
+import fs from 'node:fs';
+const state = JSON.parse(fs.readFileSync(`${process.env.HOME}/.remoteagent/bot-polling-state.json`, 'utf8'));
+if (Object.values(state.bots || {}).some(bot => bot.runningSessionIds?.length)) {
+  throw new Error('Active provider work; deployment aborted.');
+}
+NODE
+remoteagent-stop
+trap 'remoteagent-start' EXIT
+npm install -g "appback-remoteagent@$VERSION"
+test "$(node -p 'require(process.env.HOME + "/.nvm/versions/node/v22.23.2/lib/node_modules/appback-remoteagent/package.json").version')" = "$VERSION"
+# Existing npm installation keeps the same launcher and configuration paths.
+remoteagent-start
+trap - EXIT
+sleep 5
+kill -0 "$(cat "$HOME/.remoteagent/remoteagent.pid")"
+npm list -g appback-remoteagent --depth=0
+tail -n 12 "$HOME/.remoteagent/logs/agent.log"
+REMOTE
+}
+
 case "$TARGET" in
   30)
     deploy_30
@@ -202,6 +227,9 @@ case "$TARGET" in
   26)
     deploy_26
     ;;
+  50)
+    deploy_50
+    ;;
   all)
     deploy_30
     deploy_40

package/scripts/selftest-codex-stream.mjs

@@ -34,6 +34,13 @@ await fs.chmod(fakeCodex, 0o755);
 
 const { CodexAdapter } = await import(path.join(root, "dist", "adapters", "codex-adapter.js"));
 const adapter = new CodexAdapter(fakeCodex, 5000, "read-only");
+const upgradeError = "The 'gpt-6-astra' model requires a newer version of Codex. Please upgrade to the latest app or CLI and try again.";
+for (const raw of [upgradeError, JSON.stringify({type: "error", status: 400, error: {type: "invalid_request_error", message: upgradeError}})]) {
+  const formatted = adapter.formatProcessError(raw, "", false, 1);
+  if (!formatted.includes(upgradeError) || !formatted.includes("/install codex")) throw new Error("Missing Codex upgrade guidance");
+}
+const unrelatedError = "This request was blocked by our safety systems. Reason: Potentially unintended activity.";
+if (adapter.formatProcessError(unrelatedError, "", false, 1) !== unrelatedError) throw new Error("Unrelated error was changed");
 for (const method of ["buildExecArgs", "buildResumeArgs"]) {
   for (const reasoningEffort of ["low", "medium", "high", "xhigh", "max"]) {
     const args = adapter[method]({model: "gpt-6-astra", reasoningEffort, cwd: tmp, sessionId: "stream-thread"}, path.join(tmp, "output"), "read-only");

package/scripts/selftest-login.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { LoginService, loginHints } from '../dist/services/login-service.js';
+
+const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'ra-login-test-'));
+const bin = path.join(dir, 'fake-cli');
+const state = path.join(dir, 'authenticated');
+const notices = [];
+const waitFor = async predicate => {
+  for (let i = 0; i < 100; i++) {
+    if (predicate()) return;
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+  throw new Error('Timed out waiting for test condition');
+};
+try {
+  await fs.writeFile(bin, `#!${process.execPath}
+const fs = require('node:fs');
+if (process.argv.includes('status')) {
+  console.log(JSON.stringify({loggedIn:fs.existsSync(${JSON.stringify(state)})}));
+  process.exit(fs.existsSync(${JSON.stringify(state)}) ? 0 : 1);
+}
+console.log('First copy your one-time code: ABCD-EFGH');
+console.log('https://github.com/login/device');
+console.log('ACCESS_TOKEN_MUST_NOT_LEAK');
+setTimeout(() => {fs.writeFileSync(${JSON.stringify(state)}, 'ok'); process.exit(0);}, 400);
+`, { mode: 0o700 });
+  const binaries = { github: bin, codex: bin, claude: bin };
+  const service = new LoginService(4000, binaries);
+  const notify = async text => { notices.push(text); };
+  const first = service.start('github', false, notify);
+  assert.match((await new LoginService(4000, binaries).start('github', false, notify)).text, /already in progress/);
+  assert.match((await first).text, /ABCD-EFGH/);
+  await waitFor(() => notices.some(text => text.includes('verified')));
+  assert.equal((await service.start('github', false, notify)).alreadyLoggedIn, true);
+  notices.length = 0;
+  assert.match((await service.start('github', true, notify)).text, /login\/device/);
+  await waitFor(() => notices.some(text => text.includes('verified')));
+  assert.ok(notices.every(text => !text.includes('ACCESS_TOKEN_MUST_NOT_LEAK')));
+  await fs.unlink(state);
+  notices.length = 0;
+  await new LoginService(100, binaries).start('claude', false, notify);
+  await waitFor(() => notices.some(text => text.includes('expired')));
+  await assert.rejects(new LoginService(100, { codex: path.join(dir, 'missing') }).start('codex', false, notify), /could not start/);
+  assert.equal(loginHints('secret token only'), undefined);
+  assert.match(loginHints('https://auth.openai.com/codex/device\nABCD-EFGHI'), /ABCD-EFGHI/);
+  console.log('PASS login: URL/code, status, cross-bot lock, reauthentication, completion, expiry, missing CLI, output filtering');
+} finally {
+  await fs.rm(dir, { recursive: true, force: true });
+}

package/scripts/selftest-telegram-update.mjs

@@ -109,6 +109,8 @@ if (persistedBotIdentity.username !== "appbackadmin_bot") {
 
 const providerCalls = [];
 let providerMode = "success";
+let literalResponse = "";
+let explicitResponses = [];
 let untaggedIntentCalls = 0;
 let missingEvidenceCalls = 0;
 let streamingFinalProgressCalls = 0;
@@ -136,6 +138,9 @@ const provider = {
         output: "REPORT:result\nusage fallback completed with evidence: `fallback-test.log`",
       };
     }
+    if (providerMode === "literal-result") {
+      return {provider: "codex", sessionId: request.sessionId || "mock-thread", cwd: request.cwd, output: literalResponse};
+    }
     if (providerMode === "untagged-intent") {
       untaggedIntentCalls += 1;
       return {
@@ -160,7 +165,10 @@ const provider = {
           : "REPORT:result\n수정 완료했습니다.\n\n근거:\n- 변경 파일: `src/example.ts`\n- 검증: `npm run check` 통과",
       };
     }
-    if (providerMode === "queue-hold") {
+    if (providerMode === "explicit-status") {
+      return {provider: "codex", sessionId: request.sessionId || "mock-thread", cwd: request.cwd, output: explicitResponses.shift() ?? "REPORT:result\nunexpected extra call"};
+    }
+    if (providerMode === "queue-hold" || providerMode === "stop-hold") {
       queueHoldStartedResolve?.();
       await queueHoldReleasePromise;
       return {
@@ -168,7 +176,7 @@ const provider = {
         sessionId: request.sessionId || "mock-thread",
         publicSessionId: request.publicSessionId,
         cwd: request.cwd,
-        output: "REPORT:result\nactive queue test completed",
+        output: providerMode === "stop-hold" ? "REPORT:progress\nstop regression progress" : "REPORT:result\nactive queue test completed",
       };
     }
     if (providerMode === "streaming-progress") {
@@ -359,8 +367,8 @@ if (!/^TELEGRAM_AUTO_PROGRESS_MAX_TURNS=6$/m.test(envText)) {
 if (!/^COMMAND_TIMEOUT_MS=600000$/m.test(envText)) {
   throw new Error(`Option command did not persist command timeout to .env: ${envText}`);
 }
-if (!/^TELEGRAM_UNTAGGED_INTENT_RETRIES=4$/m.test(envText)) {
-  throw new Error(`Option command did not persist untagged intent retry limit to .env: ${envText}`);
+if (/^TELEGRAM_UNTAGGED_INTENT_RETRIES=/m.test(envText)) {
+  throw new Error("Retired intent option should not persist configuration");
 }
 
 const importedSecretDataDir = path.join(tmp, "imported-secret-data");
@@ -509,7 +517,7 @@ if (!calls.some((call) => call.method === "sendMessage" && /Set automatic contin
 if (!calls.some((call) => call.method === "sendMessage" && /Set provider execution timeout to 600s/.test(call.text))) {
   throw new Error(`Did not see option timeout acknowledgement. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
-if (!calls.some((call) => call.method === "sendMessage" && /Set untagged intent retry limit to 4/.test(call.text))) {
+if (!calls.some((call) => call.method === "sendMessage" && /intent option has been retired/.test(call.text))) {
   throw new Error(`Did not see option intent acknowledgement. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
 if (!calls.some((call) => call.method === "sendMessage" && /Workspace cleanup finished for S001/.test(call.text))) {
@@ -519,6 +527,14 @@ if (calls.some((call) => /미완료 TODO|\/task|새 작업으로 접수/.test(ca
   throw new Error(`Task gate language leaked to Telegram replies. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
 
+await send("/login");
+const loginMenu = await waitForTelegramCall(call => call.text.includes("Choose an account to authenticate"));
+for (const label of ["GitHub", "Codex", "Claude"]) {
+  if (!findInlineButton(loginMenu, label)?.callback_data?.startsWith("remoteagent:action:")) {
+    throw new Error(`Missing login button: ${label}`);
+  }
+}
+
 await send("/new");
 await send("/list");
 const sessionListCall = await waitForTelegramCall((call) => call.text.includes("Sessions (2/2)"));
@@ -725,14 +741,8 @@ const untaggedCalls = (await fs.readFile(telegramCalls, "utf8"))
       text: Buffer.from(textB64, "base64").toString("utf8"),
     };
   });
-if (untaggedIntentCalls !== 2) {
-  throw new Error(`Expected untagged intent response to be retried once, got ${untaggedIntentCalls}`);
-}
-if (!untaggedCalls.some((call) => /untagged intent recovered/.test(call.text))) {
-  throw new Error(`Did not see recovered result after untagged intent retry. Calls: ${JSON.stringify(untaggedCalls, null, 2)}`);
-}
-if (untaggedCalls.some((call) => call.method === "sendMessage" && /^계속 진행해서 확인하겠습니다\.$/.test(call.text.trim()))) {
-  throw new Error(`Untagged intent-only response leaked as final Telegram message. Calls: ${JSON.stringify(untaggedCalls, null, 2)}`);
+if (untaggedIntentCalls !== 1 || !untaggedCalls.some(call => call.text.includes("계속 진행해서 확인하겠습니다."))) {
+  throw new Error("Untagged response was not delivered in one execution");
 }
 
 providerMode = "missing-evidence";
@@ -752,17 +762,23 @@ const evidenceCalls = (await fs.readFile(telegramCalls, "utf8"))
       text: Buffer.from(textB64, "base64").toString("utf8"),
     };
   });
-if (missingEvidenceCalls !== 2) {
-  throw new Error(`Expected missing evidence result to be retried once, got ${missingEvidenceCalls}`);
-}
-if (!evidenceCalls.some((call) =>
-  /변경 파일: (?:`|<code>)src\/example\.ts(?:`|<\/code>)/.test(call.text)
-  && /(?:`|<code>)npm run check(?:`|<\/code>) 통과/.test(call.text)
-)) {
-  throw new Error(`Did not see recovered result with concrete evidence. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
-}
-if (evidenceCalls.some((call) => call.method === "sendMessage" && /^수정 완료했습니다\.$/.test(call.text.trim()))) {
-  throw new Error(`Evidence-free completion leaked as final Telegram message. Calls: ${JSON.stringify(evidenceCalls, null, 2)}`);
+if (missingEvidenceCalls !== 1 || !evidenceCalls.some(call => call.text.includes("수정 완료했습니다."))) {
+  throw new Error("Final response was not delivered in one execution");
+}
+for (const body of [
+  "플레이스미션을 누락했고, 표시 방식도 잘못 정리했습니다.\n‘더보기 목록’이 아니라 기존 넘기기 UI를 재사용하는 요구로 정정합니다.",
+  "앞선 답변은 요구사항 정정이며, 코드 수정·검증·병합 완료 보고가 아닙니다. 이번 정정으로 변경한 파일이나 커밋은 없습니다.",
+  "sudo 권한이 필요하지 않습니다. API key 변경도 없습니다.",
+]) {
+  providerMode = "literal-result";
+  literalResponse = "REPORT:result\n" + body;
+  const countBefore = providerCalls.length;
+  await send("/batch start");
+  await send("S091 regression");
+  await send("/batch send");
+  if (providerCalls.length !== countBefore + 1) throw new Error("Result triggered extra provider execution");
+  const delivered = await readTelegramCalls();
+  if (!delivered.some(call => call.text.includes(body))) throw new Error("Result body not delivered");
 }
 
 providerMode = "streaming-progress";
@@ -859,6 +875,33 @@ if (providerCalls.length !== queueProviderCallsBefore + 1) {
   throw new Error(`Removed queued instructions reached the provider: ${providerCalls.length - queueProviderCallsBefore} calls`);
 }
 
+providerMode = "explicit-status";
+explicitResponses = ["REPORT:progress\nsudo 권한 변경은 필요 없습니다. 다음 단계를 진행합니다.", "REPORT:result\nexplicit continuation finished"];
+const explicitBefore = providerCalls.length;
+await send("/batch start");
+await send("explicit status regression");
+await send("/batch send");
+if (providerCalls.length !== explicitBefore + 2) throw new Error("Explicit progress was overridden by body words");
+explicitResponses = ["REPORT:blocked\n명시적으로 중단합니다."];
+const blockedBefore = providerCalls.length;
+await send("/batch start");
+await send("explicit blocked regression");
+await send("/batch send");
+if (providerCalls.length !== blockedBefore + 1) throw new Error("Explicit blocked response retried");
+
+providerMode = "stop-hold";
+queueHoldStartedPromise = new Promise(resolve => { queueHoldStartedResolve = resolve; });
+queueHoldReleasePromise = new Promise(resolve => { queueHoldReleaseResolve = resolve; });
+const stopBefore = providerCalls.length;
+await send("/batch start");
+await send("stop regression");
+const stoppedRun = send("/batch send");
+await queueHoldStartedPromise;
+await send("/stop");
+queueHoldReleaseResolve();
+await stoppedRun;
+if (providerCalls.length !== stopBefore + 1) throw new Error("Stop allowed automatic continuation");
+
 console.log(JSON.stringify({
   ok: true,
   dataDir,
@@ -867,7 +910,7 @@ console.log(JSON.stringify({
   recoveredTodoItems: recoveredActive.length,
   retryOption: 6,
   timeoutOptionMs: 600000,
-  intentRetryOption: 4,
+  intentOptionRetired: true,
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,