appback-remoteagent 0.23.3 → 0.23.5

package/README.md

@@ -106,11 +106,12 @@ Current command surface implemented in `src/bot.ts`:
 | `/switch <session>` | Rebinds this chat to an existing RemoteAgent session |
 | `/status` | Shows current session, workspace, provider, and sandbox state |
 | `/model [name]` | Lists selectable provider models or changes the current session model. New Codex sessions default to `gpt-6-astra`. Use `/model gpt-6-astra` for an existing session. |
+| `/model restore` | Clears temporary Codex fallback after a usage reset or credit purchase. Server-wide; next execution uses each session's configured model. Running work is preserved. Also available through the model menu's restore button. |
 | `/option reasoning [low\|medium\|high\|xhigh\|max]` | Shows or changes Astra reasoning for all bots on this server. Defaults to `medium`; persisted as `CODEX_REASONING_EFFORT`. Applies on the next execution without restarting. Running replies retain their actual execution effort in the header. |
 | `/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 |

package/dist/bot.js

@@ -27,12 +27,12 @@ const HELP_TEXT = [
     "/batch start|send|cancel|status",
     "/attach codex <thread_id>",
     "/attach claude <session_id>",
-    "/model [name]",
+    "/model [name|restore]",
     "/queue [remove <id>|del]",
     "/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",
@@ -547,16 +547,22 @@ ${bridge.formatStatus(mapping)}`);
         const { args, rest } = parseCommand(ctx.message?.text, 1);
         const model = args[0]?.trim();
         if (rest?.trim()) {
-            await reply(ctx, "Usage: `/model` or `/model <name|number>`", {
+            await reply(ctx, "Usage: `/model`, `/model <name|number>`, or `/model restore`", {
                 parse_mode: "Markdown",
             });
             return;
         }
+        if (model?.toLowerCase() === "restore") {
+            await ensureOwnerControlAccess(ctx);
+            await reply(ctx, await bridge.restoreCodexModel());
+            return;
+        }
         if (!model) {
             const selection = await bridge.getModelSelection(botId, chatId);
             const rows = selection.presets.map((preset) => [
                 actionButton(ctx, `${preset === selection.currentModel ? "✓ " : ""}${preset}`, { kind: "model.set", model: preset }),
             ]);
+            rows.push([actionButton(ctx, "원래 모델 복귀", { kind: "model.restore" })]);
             await reply(ctx, await bridge.formatModelSelection(botId, chatId), {
                 parse_mode: "Markdown",
                 ...(keyboardOptions(rows) ?? {}),
@@ -643,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" }),
                 ],
@@ -651,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) {
@@ -702,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;
@@ -716,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",
@@ -1151,6 +1149,11 @@ ${bridge.formatStatus(mapping)}`);
                 await reply(ctx, await setChatModel(ctx, action.model));
                 return;
             }
+            if (action.kind === "model.restore") {
+                await ensureOwnerControlAccess(ctx);
+                await reply(ctx, await bridge.restoreCodexModel());
+                return;
+            }
             if (action.kind === "macro.run") {
                 const result = await runMacro(ctx, action.alias);
                 if (result) {
@@ -1628,11 +1631,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();
@@ -1694,23 +1694,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);
@@ -1725,26 +1714,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"));
@@ -1754,19 +1723,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;
@@ -1955,11 +1915,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") : "",
@@ -2055,107 +2012,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 };
@@ -2520,19 +2379,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");
 }
@@ -2544,7 +2400,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/bridge-service.js

@@ -195,12 +195,17 @@ export class BridgeService {
             ...presets.map((item, index) => ` ${index + 1}. ${item}`),
             "",
             "Use `/model <name>` or `/model <number>` to change it.",
+            "Use `/model restore` to clear temporary Codex fallback for all bots on this server. The next execution uses each session's configured model.",
         ];
         if (presets.length === 0) {
             lines.splice(3, 1, "availablePresets: none");
         }
         return lines.join("\n");
     }
+    async restoreCodexModel() {
+        await this.codexUsageFallback.clear();
+        return "이 서버의 Codex 임시 전환 상태를 해제했습니다. 다음 실행부터 각 세션에 설정된 원래 모델을 사용합니다.\n진행 중인 작업과 세션의 모델 설정은 유지됩니다. 실제 사용 한도가 남아 있으면 다시 임시 전환될 수 있습니다.";
+    }
     async getModelSelection(botId, chatId) {
         const chatSession = await this.requireChat(botId, chatId);
         const provider = chatSession.session.mode;

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.3",
+  "version": "0.23.5",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",

package/scripts/selftest-model-fallback.mjs

@@ -121,6 +121,14 @@ try {
   );
   assert.deepEqual(calls.map((call) => call.model), [primaryModel, CODEX_USAGE_FALLBACK_MODEL]);
 
+  await bridge.restoreCodexModel();
+  await assert.rejects(fs.stat(fallbackStatePath), { code: "ENOENT" });
+  failPrimaryWithUsageLimit = false;
+  calls.length = 0;
+  await bridge.routeMessage("test-bot", "test-chat", "after coupon reset");
+  assert.deepEqual(calls.map(call => call.model), [primaryModel]);
+  assert.equal((await store.getChatSession("test-bot", "test-chat"))?.session.sessionId, originalSessionId);
+
   console.log(JSON.stringify({
     ok: true,
     detectedExactUsageError: true,
@@ -130,6 +138,7 @@ try {
     fallbackSharedAcrossSessions: true,
     primaryRestoredAfterSuccessfulProbe: true,
     fallbackAttemptLimit: 1,
+    manualRestoreUsesPrimary: true,
   }, null, 2));
 } finally {
   await fs.rm(root, { 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))) {
@@ -531,6 +539,20 @@ await waitForTelegramCall((call) => call.text.includes("Switched this chat to se
 
 await send("/model");
 const modelListCall = await waitForTelegramCall((call) => call.text.includes("availablePresets:"));
+const restoreButton = findInlineButton(modelListCall, "원래 모델 복귀");
+if (!restoreButton?.callback_data) throw new Error("Model restore button missing");
+const fallbackPath = path.join(dataDir, "codex-usage-fallback.json");
+const fallbackFixture = JSON.stringify({fallbackModel: "gpt-5.3-codex-spark", activatedAt: new Date().toISOString(), resetAt: "2099-01-01T00:00:00Z"});
+const beforeRestore = await fs.readFile(path.join(dataDir, "state.json"), "utf8");
+await fs.writeFile(fallbackPath, fallbackFixture);
+await click(restoreButton.callback_data);
+if (await pathExists(fallbackPath)) throw new Error("Restore button did not clear fallback");
+await fs.writeFile(fallbackPath, fallbackFixture);
+await send("/model restore");
+await send("/model restore");
+if (await pathExists(fallbackPath)) throw new Error("Restore command did not clear fallback");
+const afterRestore = await fs.readFile(path.join(dataDir, "state.json"), "utf8");
+if (JSON.stringify(JSON.parse(beforeRestore).sessions) !== JSON.stringify(JSON.parse(afterRestore).sessions)) throw new Error("Restore changed sessions");
 const modelButton = findInlineButton(modelListCall, "gpt-5.6-terra");
 if (!modelButton?.callback_data) {
   throw new Error(`Model selection button is missing: ${modelListCall.reply_markup}`);
@@ -711,14 +733,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";
@@ -738,17 +754,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";
@@ -845,6 +867,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,
@@ -853,7 +902,7 @@ console.log(JSON.stringify({
   recoveredTodoItems: recoveredActive.length,
   retryOption: 6,
   timeoutOptionMs: 600000,
-  intentRetryOption: 4,
+  intentOptionRetired: true,
   providerCalls: providerCalls.length,
   untaggedIntentCalls,
   missingEvidenceCalls,