appback-remoteagent 0.15.1 → 0.15.3

package/dist/bot.js

@@ -105,24 +105,18 @@ class AutoContinueController {
     stopInProgress = new Set();
     stopDedupUntil = new Map();
     stopDedupMs = 10_000;
-    suppressUntil = new Map();
-    suppressMs = 60_000;
     constructor(stopGatePath) {
         this.stopGatePath = stopGatePath;
-        this.loadStopGates();
+        this.clearLegacyStopGates();
     }
     requestStop(botId, chatId, sessionId) {
         for (const key of this.keys(botId, chatId, sessionId)) {
             this.stops.add(key);
-            this.suppressUntil.set(key, Date.now() + this.suppressMs);
         }
-        this.persistStopGates();
     }
     requestSessionStop(sessionId) {
         const key = this.sessionKey(sessionId);
         this.stops.add(key);
-        this.suppressUntil.set(key, Date.now() + this.suppressMs);
-        this.persistStopGates();
     }
     beginStop(botId, chatId, sessionId) {
         const key = this.primaryKey(botId, chatId, sessionId);
@@ -153,26 +147,6 @@ class AutoContinueController {
     isStopRequested(botId, chatId, sessionId) {
         return this.keys(botId, chatId, sessionId).some((key) => this.stops.has(key));
     }
-    isSuppressingNewWork(botId, chatId, sessionId) {
-        for (const key of this.keys(botId, chatId, sessionId)) {
-            if (this.isSuppressingKey(key)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    isSuppressingKey(key) {
-        const until = this.suppressUntil.get(key);
-        if (!until) {
-            return false;
-        }
-        if (Date.now() > until) {
-            this.suppressUntil.delete(key);
-            this.persistStopGates();
-            return false;
-        }
-        return true;
-    }
     keys(botId, chatId, sessionId) {
         const keys = [this.chatKey(botId, chatId)];
         if (sessionId) {
@@ -189,31 +163,12 @@ class AutoContinueController {
     sessionKey(sessionId) {
         return `session:${sessionId}`;
     }
-    loadStopGates() {
-        try {
-            const raw = fsSync.readFileSync(this.stopGatePath, "utf8");
-            const parsed = JSON.parse(raw);
-            const now = Date.now();
-            for (const [key, until] of Object.entries(parsed)) {
-                if (Number.isFinite(until) && until > now) {
-                    this.suppressUntil.set(key, until);
-                }
-            }
-        }
-        catch {
-            // Missing or invalid gate files should not prevent the bot from starting.
-        }
-    }
-    persistStopGates() {
-        const entries = Object.fromEntries(this.suppressUntil.entries());
+    clearLegacyStopGates() {
         try {
-            fsSync.mkdirSync(path.dirname(this.stopGatePath), { recursive: true });
-            const tmpPath = `${this.stopGatePath}.tmp`;
-            fsSync.writeFileSync(tmpPath, JSON.stringify(entries, null, 2), "utf8");
-            fsSync.renameSync(tmpPath, this.stopGatePath);
+            fsSync.rmSync(this.stopGatePath, { force: true });
         }
         catch {
-            // Stop should still work in memory even if persisting the gate fails.
+            // Legacy stop gate cleanup must not prevent the bot from starting.
         }
     }
 }
@@ -267,10 +222,30 @@ export function createBot(token, bridge, botManagement, botInfo) {
         }
         const botId = getBotId();
         const chatId = String(ctx.chat.id);
-        await bridge.logSystem(botId, chatId, `Plan document reinforcement requested (${count} turns max).`);
+        await bridge.logSystem(botId, chatId, `Plan document reinforcement requested (${count} check/apply cycle max).`);
         await runWithPendingAnimation(token, ctx.chat.id, async (helpers) => {
+            for (let cycle = 1; cycle <= count; cycle += 1) {
+                const checkChunks = await routeTelegramWorkLoop(bridge, botId, chatId, formatPlanDocumentCheckPrompt(cycle, count), `Plan document check ${cycle}`, botManagement, helpers, autoContinue, memoryService, (blocks) => blocks, { maxTurns: 1 });
+                const decision = classifyPlanReinforcementDecision(checkChunks.join("\n"));
+                await helpers.reportProgress(formatPlanCycleProgress("확인 결과", cycle, count, stripPlanReinforcementMarkers(checkChunks)));
+                if (decision === "none") {
+                    return {
+                        chunks: [`보강할 내용이 없다고 판단되어 ${cycle}/${count}회차에서 종료했습니다.`],
+                    };
+                }
+                if (decision === "unknown") {
+                    return {
+                        chunks: [
+                            "보강 필요 여부를 명확히 판정할 수 없어 중단했습니다.",
+                            "계획문서 확인 응답에는 `PLAN_REINFORCE: needed` 또는 `PLAN_REINFORCE: none`이 포함되어야 합니다.",
+                        ],
+                    };
+                }
+                const applyChunks = await routeTelegramWorkLoop(bridge, botId, chatId, formatPlanDocumentApplyPrompt(cycle, count), `Plan document apply ${cycle}`, botManagement, helpers, autoContinue, memoryService, stripPlanReinforcementMarkers, { maxTurns: 1 });
+                await helpers.reportProgress(formatPlanCycleProgress("보강 결과", cycle, count, applyChunks));
+            }
             return {
-                chunks: await routeTelegramWorkLoop(bridge, botId, chatId, formatPlanDocumentReinforcementPrompt(count), "Plan document reinforcement", botManagement, helpers, autoContinue, memoryService, (blocks) => blocks, { maxTurns: count }),
+                chunks: [`최대 ${count}회 확인/보강 반복을 완료했습니다.`],
             };
         });
     };
@@ -858,11 +833,6 @@ ${bridge.formatStatus(mapping)}`);
             return;
         }
         const mapping = await bridge.status(botId, chatId).catch(() => undefined);
-        if (autoContinue.isSuppressingNewWork(botId, chatId, mapping?.session.sessionId)) {
-            await bridge.logSystem(botId, chatId, "Telegram message ignored during stop cooldown.");
-            await reply(ctx, "Stopped. Ignored this message so the previous work does not restart. Send a new message again in a moment to start fresh.");
-            return;
-        }
         if (photo) {
             const downloaded = await downloadTelegramFile(token, botId, chatId, photo.file_id, "telegram-photo.jpg");
             await memoryService.recordArtifact({
@@ -1774,24 +1744,56 @@ function parseKoreanPlanReinforcementCommand(text, botId) {
     const parsed = parsePlanReinforcementCount(maybeCount);
     return parsed.kind === "valid" ? { kind: "matched", count: parsed.count } : { kind: "invalid" };
 }
-function formatPlanDocumentReinforcementPrompt(count) {
+function formatPlanDocumentCheckPrompt(cycle, count) {
     return [
-        `계획문서를 처음부터 끝까지 확인하고, 최대 ${count}회까지만 보강 루프를 수행하세요.`,
+        "계획문서 처음부터 확인해서 보강해야할 내용 확인해",
         "",
-        "반복 절차:",
-        "1. 계획문서와 관련 문서를 실제로 읽고 보강할 내용이 있는지 판단하세요.",
-        "2. 보강할 내용이 있으면 직접 문서를 수정하세요.",
-        "3. 수정 후 같은 기준으로 다시 점검하세요.",
-        `4. 더 이상 보강할 내용이 없거나 ${count}회에 도달하면 종료하세요.`,
+        `현재 반복: ${cycle}/${count}`,
         "",
-        "중요 규칙:",
-        "- 추정하지 말고 실제 파일 경로와 확인 근거를 남기세요.",
-        "- 같은 보강을 반복하지 마세요.",
-        "- 보강할 내용이 없으면 없다고 보고하고 종료하세요.",
+        "응답 규칙:",
+        "- 첫 줄은 REPORT:result 또는 REPORT:blocked.",
+        "- REPORT:result 본문 첫 줄은 반드시 `PLAN_REINFORCE: needed` 또는 `PLAN_REINFORCE: none`.",
+        "- 보강할 내용이 있으면 `PLAN_REINFORCE: needed` 후 항목과 근거 파일을 답하세요.",
+        "- 보강할 내용이 없으면 `PLAN_REINFORCE: none` 후 확인 근거 파일을 답하세요.",
+        "- 이 단계에서는 문서를 수정하지 마세요. 확인과 답변만 하세요.",
         "- 권한, 정보, 파일 위치가 부족하면 REPORT:blocked로 정확한 blocker를 말하세요.",
-        "- 완료 시 확인한 문서, 변경한 문서, 남은 위험, 검증 결과를 짧게 보고하세요.",
     ].join("\n");
 }
+function formatPlanDocumentApplyPrompt(cycle, count) {
+    return [
+        "보강해",
+        "",
+        `현재 반복: ${cycle}/${count}`,
+        "",
+        "방금 확인 응답에서 보강 필요하다고 답한 항목만 실제 문서에 반영하세요.",
+        "",
+        "응답 규칙:",
+        "- 첫 줄은 REPORT:result 또는 REPORT:blocked.",
+        "- REPORT:result 본문에는 변경한 파일 경로와 검증/확인 근거를 포함하세요.",
+        "- 새 범위를 만들지 말고 방금 확인한 보강 항목만 처리하세요.",
+        "- 권한, 정보, 파일 위치가 부족하면 REPORT:blocked로 정확한 blocker를 말하세요.",
+    ].join("\n");
+}
+function classifyPlanReinforcementDecision(text) {
+    if (/PLAN_REINFORCE:\s*none/i.test(text)) {
+        return "none";
+    }
+    if (/PLAN_REINFORCE:\s*needed/i.test(text)) {
+        return "needed";
+    }
+    return "unknown";
+}
+function stripPlanReinforcementMarkers(blocks) {
+    return blocks.map((block) => block
+        .replace(/^PLAN_REINFORCE:\s*(needed|none)\s*\r?\n?/gim, "")
+        .trim());
+}
+function formatPlanCycleProgress(label, cycle, count, chunks) {
+    const prefix = `[보강 ${cycle}/${count}] ${label}`;
+    return chunks.length > 0
+        ? chunks.map((chunk, index) => index === 0 ? `${prefix}\n${chunk}` : chunk)
+        : [prefix];
+}
 function commandTarget(args, rest) {
     return (rest?.trim() || args.slice(1).join(" ").trim() || args[0]?.trim() || "");
 }

package/package.json

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