appback-remoteagent 0.13.11 → 0.13.13

package/dist/bot.js

@@ -886,6 +886,14 @@ ${bridge.formatStatus(mapping)}`);
         if (!text) {
             return;
         }
+        if (mapping) {
+            const localStatus = await memoryService.formatLocalStatusQuestion(mapping.session, text);
+            if (localStatus) {
+                await bridge.logSystem(botId, chatId, "Answered local session status without provider execution.");
+                await reply(ctx, localStatus);
+                return;
+            }
+        }
         if (isRemoteShellMessage(text)) {
             const shellRequest = parseRemoteShellRequest(text);
             if (!shellRequest) {

package/dist/services/agent-memory-service.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-const MAX_CONTEXT_CHARS = 2500;
+const MAX_CONTEXT_CHARS = 1200;
 export class AgentMemoryService {
     dataDir;
     rootDir;
@@ -71,6 +71,53 @@ export class AgentMemoryService {
             history.length > 0 ? ["Recent history:", ...history.map((entry) => `- ${entry}`)].join("\n") : undefined,
         ].filter(Boolean).join("\n");
     }
+    async formatLocalStatusQuestion(session, question) {
+        if (!this.looksLikeLocalStatusQuestion(question)) {
+            return undefined;
+        }
+        const current = await this.currentTaskText(session);
+        const todo = await this.readTodo(session);
+        const active = this.activeTodoItems(todo);
+        const history = await this.readRecentHistory(session, 8);
+        const workHistory = await this.readRecentWorkHistory(session, 6);
+        const latestInstruction = this.extractLatestInstructionFromCurrent(current);
+        const currentIsStatusOnly = latestInstruction ? this.looksLikeLocalStatusQuestion(latestInstruction) : false;
+        const hasCurrentWork = Boolean(current.trim()) && !currentIsStatusOnly;
+        const lines = [
+            `Session ${session.publicId} local state`,
+            "",
+            `workspace: ${session.workspace}`,
+            `memory: ${this.sessionDir(session)}`,
+            "",
+        ];
+        if (!hasCurrentWork && active.length === 0 && workHistory.length === 0) {
+            lines.push("현재 하네스 기준으로 진행 중이거나 완료된 작업 기록이 없습니다.", "이 세션은 깨끗한 상태로 보입니다.");
+        }
+        else {
+            if (hasCurrentWork) {
+                lines.push("Current note:", this.summarizeCurrentTask(current), "");
+            }
+            else {
+                lines.push("Current note: none", "");
+            }
+            if (active.length > 0) {
+                lines.push("Active TODO:", this.formatTodoSummary(todo, false), "");
+            }
+            else {
+                lines.push("Active TODO: none", "");
+            }
+            if (workHistory.length > 0) {
+                lines.push("Recent work history:", ...workHistory.map((entry) => `- ${entry}`));
+            }
+            else {
+                lines.push("Recent work history: none");
+            }
+        }
+        if (history.length > 0) {
+            lines.push("", "Recent raw history:", ...history.map((entry) => `- ${entry}`));
+        }
+        return lines.join("\n");
+    }
     async clearSessionState(session, summary) {
         const dir = this.sessionDir(session);
         const currentPath = path.join(dir, "current.md");
@@ -303,56 +350,27 @@ export class AgentMemoryService {
         ].join("\n");
     }
     async formatProviderContext(session) {
-        const current = await fs.readFile(path.join(this.sessionDir(session), "current.md"), "utf8").catch(() => "");
-        const todo = await this.readTodo(session);
-        const history = await this.readRecentHistory(session, 5);
-        const docs = Object.values(await this.readDocs()).slice(0, 30);
-        const secrets = Object.keys(await this.readSecrets()).sort();
-        const artifacts = (await this.readJson(this.artifactsPath, []))
-            .filter((artifact) => artifact.sessionId === session.sessionId || artifact.sessionPublicId === session.publicId)
-            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-            .slice(0, 8);
+        const docs = Object.values(await this.readDocs()).slice(0, 8);
         const lines = [
             "RemoteAgent managed context:",
             [
                 "Session work locations:",
                 `- workspace: ${session.workspace}`,
                 `- memory: ${this.sessionDir(session)}`,
-                "- docs: use managed document pins first, then inspect docs/ under the workspace when relevant.",
+                "- docs: use document pins only when relevant.",
             ].join("\n"),
             [
                 "Harness execution rules:",
                 "- Treat the user message as the active instruction unless the user explicitly says otherwise.",
-                "- RemoteAgent state is guidance only; never refuse work because a TODO is missing.",
-                "- Use the workspace/memory/docs pointers before searching broadly.",
+                "- RemoteAgent state is not authority. Prefer current files and the current user message.",
+                "- Do not revive stale TODOs, old notes, or previous work unless the user explicitly asks.",
                 "- Do not claim external delivery, dashboard access, deployment, or file transfer without concrete evidence.",
                 "- RemoteAgent sends normal provider text and TELEGRAM_FILE attachments to the current incoming chat.",
-                "- Product/service Telegram notifications belong to product code and should use the project's secret/config path. Never print tokens.",
-                "- If the same action or progress repeats 3 times, stop, mark the blocker, and report the exact blocker.",
-                "- A final report must include concrete evidence: changed files, relevant line references, git diff/status, command output, or log path.",
+                "- Use `node \"$REMOTEAGENT_SECRET_BIN\" get <KEY>` only when the current task needs a named secret. Never print secret values.",
             ].join("\n"),
-            todo.items.length > 0
-                ? ["Legacy task notes:", this.formatTodoSummary(todo, true, true)].join("\n")
-                : undefined,
-            current.trim() ? ["Current task note:", this.truncate(current.trim(), 700)].join("\n") : undefined,
-            history.length > 0 ? ["Recent session history:", ...history.map((entry) => `- ${entry}`)].join("\n") : undefined,
             docs.length > 0
                 ? ["Document index:", ...docs.map((doc) => `- ${doc.keyword}: ${doc.targetPath}${doc.note ? ` (${doc.note})` : ""}`)].join("\n")
                 : undefined,
-            secrets.length > 0
-                ? [
-                    "Secret keys available through `node \"$REMOTEAGENT_SECRET_BIN\" get <KEY>`:",
-                    ...secrets.map((key) => `- ${key}`),
-                    "If you generate a new secret value such as an OAuth refresh token, store it without printing it:",
-                    "`printf '%s' \"$VALUE\" | node \"$REMOTEAGENT_SECRET_BIN\" set <KEY>`",
-                ].join("\n")
-                : [
-                    "Secrets can be stored without printing values:",
-                    "`printf '%s' \"$VALUE\" | node \"$REMOTEAGENT_SECRET_BIN\" set <KEY>`",
-                ].join("\n"),
-            artifacts.length > 0
-                ? ["Recent session artifacts:", ...artifacts.map((artifact) => `- ${artifact.id} ${artifact.kind}: ${artifact.path}`)].join("\n")
-                : undefined,
         ].filter(Boolean).join("\n\n");
         return this.truncate(lines, MAX_CONTEXT_CHARS);
     }
@@ -360,6 +378,17 @@ export class AgentMemoryService {
         return fs.readFile(path.join(this.sessionDir(session), "current.md"), "utf8").catch(() => "");
     }
     async readRecentHistory(session, limit) {
+        return (await this.readHistoryEntries(session, limit))
+            .slice(-limit)
+            .map((entry) => this.formatHistoryEntry(entry));
+    }
+    async readRecentWorkHistory(session, limit) {
+        return (await this.readHistoryEntries(session, 80))
+            .filter((entry) => ["progress", "completed", "archived", "note"].includes(String(entry.type ?? "")))
+            .slice(-limit)
+            .map((entry) => this.formatHistoryEntry(entry));
+    }
+    async readHistoryEntries(session, limit) {
         const historyPath = path.join(this.sessionDir(session), "history.ndjson");
         const raw = await fs.readFile(historyPath, "utf8").catch(() => "");
         return raw
@@ -369,16 +398,24 @@ export class AgentMemoryService {
             .slice(-limit)
             .map((line) => {
             try {
-                const entry = JSON.parse(line);
-                const kind = entry.mode ? `${entry.type ?? "event"}:${entry.mode}` : entry.type ?? "event";
-                const body = entry.summary ?? entry.text ?? entry.reason ?? "";
-                return `${entry.at ?? "unknown"} ${kind}: ${this.truncate(body.replace(/\s+/g, " ").trim(), 220)}`;
+                return JSON.parse(line);
             }
             catch {
-                return this.truncate(line.replace(/\s+/g, " ").trim(), 220);
+                return { type: "raw", text: line };
             }
         });
     }
+    formatHistoryEntry(entry) {
+        const type = typeof entry.type === "string" ? entry.type : "event";
+        const mode = typeof entry.mode === "string" ? entry.mode : undefined;
+        const at = typeof entry.at === "string" ? entry.at : "unknown";
+        const text = typeof entry.text === "string" ? entry.text : "";
+        const summary = typeof entry.summary === "string" ? entry.summary : "";
+        const reason = typeof entry.reason === "string" ? entry.reason : "";
+        const kind = mode ? `${type}:${mode}` : type;
+        const body = summary || text || reason || "";
+        return `${at} ${kind}: ${this.truncate(body.replace(/\s+/g, " ").trim(), 220)}`;
+    }
     todoPath(session) {
         return path.join(this.sessionDir(session), "todo.json");
     }
@@ -576,12 +613,35 @@ export class AgentMemoryService {
         return /^(새로|새\s*작업|다른\s*작업|이제\s*부터|다음\s*작업|전환|바꿔서|new task)/i.test(text.trim());
     }
     summarizeCurrentTask(current) {
+        const latestInstruction = this.extractLatestInstructionFromCurrent(current);
+        if (latestInstruction) {
+            return this.truncate(latestInstruction, 700);
+        }
         const instructionIndex = current.indexOf("## Instruction");
         const body = instructionIndex >= 0 ? current.slice(instructionIndex + "## Instruction".length) : current;
         const immediateRuleIndex = body.indexOf("## Immediate Rule");
         const instruction = (immediateRuleIndex >= 0 ? body.slice(0, immediateRuleIndex) : body).trim();
         return this.truncate(instruction || current.trim(), 700);
     }
+    extractLatestInstructionFromCurrent(current) {
+        const match = /## Latest User Instruction\s*\n([\s\S]*?)(?:\n## |\s*$)/.exec(current);
+        return match?.[1]?.trim() || undefined;
+    }
+    looksLikeLocalStatusQuestion(text) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return false;
+        }
+        return [
+            /최근\s*(작업|진행|히스토리|기록)/,
+            /현재\s*(작업|진행|상태|세션)/,
+            /(뭐|무엇)\s*(하고|하는)\s*(있어|중|거야)?/,
+            /작업\s*(상태|히스토리|기록|있어|없어)/,
+            /세션\s*(상태|히스토리|기록)/,
+            /진행\s*(상태|중인\s*작업)/,
+            /\b(status|current work|recent work|what are you doing|session state)\b/i,
+        ].some((pattern) => pattern.test(normalized));
+    }
     formatTodoSummary(todo, includeDone = false, detailed = false) {
         const items = includeDone ? todo.items : todo.items.filter((item) => item.status !== "done");
         if (items.length === 0) {

package/package.json

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