appback-remoteagent 0.15.6 → 0.16.0

package/.env.example

@@ -18,6 +18,8 @@ TELEGRAM_RECOVERY_CHECK_INTERVAL_MS=60000
 ARTIFACT_CLEANUP_ENABLED=true
 ARTIFACT_RETENTION_DAYS=30
 ARTIFACT_CLEANUP_INTERVAL_MS=86400000
+WORKSPACE_CLEANUP_ENABLED=true
+WORKSPACE_CLEANUP_INTERVAL_MS=86400000
 REMOTEAGENT_WATCHDOG_ENABLED=true
 REMOTEAGENT_WATCHDOG_INTERVAL_MS=300000
 REMOTEAGENT_WATCHDOG_CPU_PERCENT=90

package/README.md

@@ -182,6 +182,8 @@ Telegram attachments are written into the local runtime under `~/.remoteagent/up
 
 Attachments can be inspected with `/artifacts list` and cleaned manually with `/artifacts cleanup <days>`. RemoteAgent also runs periodic artifact cleanup when `ARTIFACT_CLEANUP_ENABLED=true`; by default it keeps 30 days and also removes old unindexed files under `uploads/telegram`.
 
+Managed workspaces are cleaned separately. RemoteAgent periodically removes only orphan workspace directories that are no longer referenced by `state.json` when `WORKSPACE_CLEANUP_ENABLED=true`. Use `/cleanup` to clear the current session workspace; RemoteAgent keeps the session todo/state/history under `~/.remoteagent/managed/sessions/<session>` and refuses non-RemoteAgent-managed workspaces.
+
 Current supported attachment classes:
 
 - photos

package/dist/bot.js

@@ -9,6 +9,7 @@ import { config } from "./config.js";
 import { ProviderSetupService } from "./services/provider-setup-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";
 import { deleteTelegramCommandMenu, setTelegramCommandMenu } from "./telegram-command-menu.js";
 const execFileAsync = promisify(execFile);
 const HELP_TEXT = [
@@ -29,8 +30,11 @@ const HELP_TEXT = [
     "/option [retry <count>|timeout <seconds>|intent <count>|command-menu <on|off|refresh>]",
     "/state [clear|note <text>]",
     "/artifacts list|cleanup <days>",
+    "/cleanup",
     "/secret set|list|remove",
     "/docs pin|find|list|remove|reinforce",
+    "/macro set|list|remove|<alias|number>",
+    "/매크로 set|list|remove|<alias|number>",
     "/보강 <count>",
     "/bots",
     "/bot add <token>",
@@ -82,8 +86,10 @@ const RECOGNIZED_COMMANDS = new Set([
     "option",
     "state",
     "artifacts",
+    "cleanup",
     "secret",
     "docs",
+    "macro",
     "bots",
     "bot",
     "install",
@@ -92,7 +98,8 @@ const RECOGNIZED_COMMANDS = new Set([
 ]);
 const TELEGRAM_STALE_UPDATE_GRACE_SECONDS = 10;
 const TELEGRAM_PROCESS_STARTED_AT_SECONDS = Math.floor(Date.now() / 1000);
-const activeWorkLoopKeys = new Set();
+const workLoopTails = new Map();
+const workLoopGenerations = new Map();
 const REPORT_CONTINUE_PROMPT = [
     "Continue the same task now.",
     "Do more concrete work before replying again.",
@@ -177,6 +184,7 @@ export function createBot(token, bridge, botManagement, botInfo) {
     const autoContinue = new AutoContinueController(path.join(config.dataDir, "stop-gates.json"));
     const shellService = new RemoteShellService(config.commandTimeoutMs);
     const memoryService = new AgentMemoryService(config.dataDir);
+    const workspaceCleanupService = new WorkspaceCleanupService(config.dataDir, config.workspaceRoot);
     const sourceBotToken = token;
     const setupService = new ProviderSetupService(config.setupCommandTimeoutMs, (provider) => bridge.listAvailableProviders().includes(provider), {
         codex: config.codexInstallCommand,
@@ -196,6 +204,7 @@ export function createBot(token, bridge, botManagement, botInfo) {
         if (!previous) {
             return;
         }
+        cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
         autoContinue.requestSessionStop(previous.session.sessionId);
         messageBatcher.cancelPending(botId, chatId);
         messageBatcher.cancelManual(botId, chatId);
@@ -350,6 +359,7 @@ ${bridge.formatStatus(mapping)}`);
         const mapping = await bridge.switchSession(botId, chatId, sessionId);
         if (previous && previous.session.sessionId !== mapping.session.sessionId) {
             autoContinue.requestSessionStop(previous.session.sessionId);
+            cancelQueuedWorkLoops(botId, chatId, previous.session.sessionId);
             messageBatcher.cancelPending(botId, chatId);
             messageBatcher.cancelManual(botId, chatId);
             await bridge.stopSessionRun(previous.session.sessionId, botId, chatId, "Chat switched to another session; previous session execution was stopped.");
@@ -449,6 +459,7 @@ ${bridge.formatStatus(mapping)}`);
         const mapping = await bridge.status(botId, chatId);
         const sessionId = mapping?.session.sessionId;
         autoContinue.requestStop(botId, chatId, sessionId);
+        cancelQueuedWorkLoops(botId, chatId, sessionId);
         const pendingBatch = messageBatcher.cancelPending(botId, chatId);
         const manualBatch = messageBatcher.cancelManual(botId, chatId);
         if (!autoContinue.beginStop(botId, chatId, sessionId)) {
@@ -620,6 +631,19 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/artifacts list` or `/artifacts cleanup <days>`", { parse_mode: "Markdown" });
     });
+    bot.command("cleanup", async (ctx) => {
+        await ensureOwnerControlAccess(ctx);
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const mapping = await bridge.status(botId, chatId);
+        if (!mapping) {
+            await reply(ctx, "No paired session for this chat yet.");
+            return;
+        }
+        const result = await workspaceCleanupService.cleanupSessionWorkspace(mapping.session);
+        await bridge.logSystem(botId, chatId, `Workspace cleanup requested for ${mapping.session.publicId}.`);
+        await reply(ctx, result);
+    });
     bot.command("secret", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const { args, rest } = parseCommand(ctx.message?.text, 2);
@@ -700,6 +724,40 @@ ${bridge.formatStatus(mapping)}`);
         }
         await reply(ctx, "Usage: `/docs list`, `/docs find <keyword>`, `/docs pin <keyword> <path>`, `/docs remove <keyword>`, or `/docs reinforce <1-10>`", { parse_mode: "Markdown" });
     });
+    const handleMacroCommand = async (ctx, text) => {
+        if (!ctx.chat) {
+            throw new Error("Telegram chat context is missing.");
+        }
+        const botId = getBotId();
+        const chatId = String(ctx.chat.id);
+        const parsed = parseMacroCommandText(text, botId);
+        if (parsed.kind === "help") {
+            await reply(ctx, await formatMacroHelp(memoryService));
+            return;
+        }
+        if (parsed.kind === "set") {
+            await ensureOwnerControlAccess(ctx);
+            const macro = await memoryService.setMacro(parsed.alias, parsed.prompt);
+            await reply(ctx, `Saved macro '${macro.alias}'.`);
+            return;
+        }
+        if (parsed.kind === "remove") {
+            await ensureOwnerControlAccess(ctx);
+            const removed = await memoryService.removeMacro(parsed.alias);
+            await reply(ctx, removed ? `Removed macro '${parsed.alias}'.` : `Macro was not found: ${parsed.alias}`);
+            return;
+        }
+        const macro = await memoryService.getMacro(parsed.target);
+        if (!macro) {
+            await reply(ctx, `Macro was not found: ${parsed.target}\n\n${await memoryService.listMacros()}`);
+            return;
+        }
+        await bridge.logSystem(botId, chatId, `Macro executed: ${macro.alias}`);
+        await messageBatcher.enqueue({ botToken: token, telegramChatId: ctx.chat.id }, botId, chatId, macro.prompt);
+    };
+    bot.command("macro", async (ctx) => {
+        await handleMacroCommand(ctx, ctx.message?.text ?? "/macro");
+    });
     bot.command("bots", async (ctx) => {
         await ensureOwnerControlAccess(ctx);
         const pendingNotice = await botManagement.getPendingOperationNotice();
@@ -825,6 +883,11 @@ ${bridge.formatStatus(mapping)}`);
             await reply(ctx, "Usage: `/보강 <1-10>`", { parse_mode: "Markdown" });
             return;
         }
+        const koreanMacro = parseKoreanMacroCommand(text, botId);
+        if (koreanMacro) {
+            await handleMacroCommand(ctx, text ?? "/매크로");
+            return;
+        }
         if (text && isRecognizedSlashCommand(text, botId)) {
             return;
         }
@@ -1155,22 +1218,46 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
     const currentSession = await bridge.status(botId, chatId);
     const sessionId = currentSession?.session.sessionId;
     const activeKey = workLoopKey(botId, chatId, sessionId);
-    if (activeWorkLoopKeys.has(activeKey)) {
-        const message = [
-            `Session ${currentSession?.session.publicId ?? sessionId ?? `${botId}:${chatId}`} is already running.`,
-            "Send /stop to interrupt the active work, then send the instruction again.",
-        ].join("\n");
-        await bridge.logSystem(botId, chatId, `Rejected overlapping Telegram work loop for ${activeKey}.`);
-        return [message];
-    }
-    activeWorkLoopKeys.add(activeKey);
-    if (currentSession) {
-        await memoryService.recordInstruction(currentSession.session, message);
+    const previousTail = workLoopTails.get(activeKey);
+    const generation = workLoopGenerations.get(activeKey) ?? 0;
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    const currentTail = (previousTail ?? Promise.resolve())
+        .catch(() => undefined)
+        .then(() => gate);
+    workLoopTails.set(activeKey, currentTail);
+    if (previousTail) {
+        await bridge.logSystem(botId, chatId, `Queued overlapping Telegram work loop for ${activeKey}.`);
+        await helpers.reportProgress([`Queued instruction for ${currentSession?.session.publicId ?? "this session"}. It will run after the active work finishes.`]);
+        await previousTail.catch(() => undefined);
+        if ((workLoopGenerations.get(activeKey) ?? 0) !== generation || autoContinue.isStopRequested(botId, chatId, sessionId)) {
+            await bridge.logSystem(botId, chatId, `Discarded queued Telegram work loop for ${activeKey}.`);
+            release();
+            if (workLoopTails.get(activeKey) === currentTail) {
+                workLoopTails.delete(activeKey);
+            }
+            throw new SilentTelegramAbort("Queued work was discarded.");
+        }
+    }
+    let managedContext = "";
+    try {
+        if (currentSession) {
+            await memoryService.recordInstruction(currentSession.session, message);
+        }
+        managedContext = currentSession
+            ? await memoryService.formatProviderContext(currentSession.session)
+            : "";
+        autoContinue.clear(botId, chatId, sessionId);
+    }
+    catch (error) {
+        release();
+        if (workLoopTails.get(activeKey) === currentTail) {
+            workLoopTails.delete(activeKey);
+        }
+        throw error;
     }
-    const managedContext = currentSession
-        ? await memoryService.formatProviderContext(currentSession.session)
-        : "";
-    autoContinue.clear(botId, chatId, sessionId);
     let prompt = appendManagedContext(appendReportProtocol(message), managedContext);
     const maxTurns = options.maxTurns ?? config.telegramAutoProgressMaxTurns;
     const emptyResponseRetries = config.telegramEmptyResponseRetries;
@@ -1351,7 +1438,10 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
         }
     }
     finally {
-        activeWorkLoopKeys.delete(activeKey);
+        release();
+        if (workLoopTails.get(activeKey) === currentTail) {
+            workLoopTails.delete(activeKey);
+        }
         if (currentSession) {
             if (providerCompleted) {
                 await botManagement.markProviderCompleted(botId, sessionId);
@@ -1365,6 +1455,15 @@ async function routeTelegramWorkLoop(bridge, botId, chatId, message, label, botM
 function workLoopKey(botId, chatId, sessionId) {
     return sessionId ? `session:${sessionId}` : `chat:${botId}:${chatId}`;
 }
+function cancelQueuedWorkLoops(botId, chatId, sessionId) {
+    const keys = [workLoopKey(botId, chatId, sessionId)];
+    if (sessionId) {
+        keys.push(workLoopKey(botId, chatId));
+    }
+    for (const key of keys) {
+        workLoopGenerations.set(key, (workLoopGenerations.get(key) ?? 0) + 1);
+    }
+}
 class SilentTelegramAbort extends Error {
     constructor(message) {
         super(message);
@@ -1711,6 +1810,124 @@ function parseCommand(text, headCount) {
         rest: remaining || undefined,
     };
 }
+function parseMacroCommandText(text, botId) {
+    const body = stripSlashCommand(text, ["macro", "매크로"], botId).trim();
+    if (!body) {
+        return { kind: "help" };
+    }
+    const tokens = tokenizeCommandBody(body);
+    const action = tokens[0]?.toLowerCase();
+    if (action === "list") {
+        return { kind: "help" };
+    }
+    if (action === "set") {
+        const alias = tokens[1]?.trim();
+        const prompt = tokens.length >= 3
+            ? tokens.slice(2).join(" ").trim()
+            : "";
+        if (!alias || !prompt) {
+            throw new Error("Usage: /macro set <alias> <instruction>");
+        }
+        return { kind: "set", alias, prompt };
+    }
+    if (action === "remove" || action === "rm" || action === "delete" || action === "del" || action === "clear") {
+        const alias = tokens[1]?.trim();
+        if (!alias || tokens.length > 2) {
+            throw new Error("Usage: /macro remove <alias>");
+        }
+        return { kind: "remove", alias };
+    }
+    return { kind: "run", target: tokens.length === 1 ? tokens[0] : body };
+}
+function parseKoreanMacroCommand(text, botId) {
+    return Boolean(text && stripSlashCommand(text, ["매크로"], botId) !== text);
+}
+function stripSlashCommand(text, names, botId) {
+    const trimmed = text?.trim() ?? "";
+    for (const name of names) {
+        const escaped = escapeRegExp(name);
+        const username = botId ? `(?:@${escapeRegExp(botId.replace(/^@/, ""))})?` : "(?:@\\w+)?";
+        const pattern = new RegExp(`^/${escaped}${username}(?:\\s+|$)`, "i");
+        if (pattern.test(trimmed)) {
+            return trimmed.replace(pattern, "");
+        }
+    }
+    return trimmed;
+}
+function tokenizeCommandBody(input) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    let escaped = false;
+    for (const char of input) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === "\"") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (escaped) {
+        current += "\\";
+    }
+    if (quote) {
+        throw new Error("Unclosed quote in command.");
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function formatMacroHelp(memoryService) {
+    return [
+        "Macro command guide",
+        "",
+        "Commands:",
+        "```text",
+        "/macro",
+        "/macro set 초기설정 너의 역할은 ...",
+        "/macro set '초기설정' '너의 역할은 ...'",
+        "/macro 초기설정",
+        "/macro 1",
+        "/macro remove 초기설정",
+        "/매크로",
+        "/매크로 초기설정",
+        "```",
+        "",
+        "Rules:",
+        "- Macro aliases can use Korean, letters, numbers, dot, underscore, and dash.",
+        "- Numeric-only aliases are reserved for list selection and cannot be registered.",
+        "",
+        await memoryService.listMacros(),
+    ].join("\n");
+}
 function parsePlanReinforcementCount(raw) {
     const value = raw?.trim();
     if (!value) {

package/dist/config.js

@@ -152,6 +152,8 @@ export const config = {
     artifactCleanupEnabled: readBoolean("ARTIFACT_CLEANUP_ENABLED", true),
     artifactRetentionDays: readTimeout("ARTIFACT_RETENTION_DAYS", 30),
     artifactCleanupIntervalMs: readTimeout("ARTIFACT_CLEANUP_INTERVAL_MS", 86_400_000),
+    workspaceCleanupEnabled: readBoolean("WORKSPACE_CLEANUP_ENABLED", true),
+    workspaceCleanupIntervalMs: readTimeout("WORKSPACE_CLEANUP_INTERVAL_MS", 86_400_000),
     dataDir: defaultDataDir,
     defaultMode: readMode("DEFAULT_MODE", "codex"),
     defaultWorkspace: path.resolve(process.env.DEFAULT_WORKSPACE?.trim() || os.homedir()),

package/dist/index.js

@@ -14,6 +14,7 @@ import { BridgeService } from "./services/bridge-service.js";
 import { BotManagementService } from "./services/bot-management-service.js";
 import { LocalUiService } from "./services/local-ui-service.js";
 import { AgentMemoryService } from "./services/agent-memory-service.js";
+import { WorkspaceCleanupService } from "./services/workspace-cleanup-service.js";
 import { BotPollingStateService } from "./services/bot-polling-state-service.js";
 import { ProviderRecoveryService } from "./services/provider-recovery-service.js";
 import { computePolicyPollIntervalMs, computeRecentMessageRanks } from "./services/polling-policy.js";
@@ -56,6 +57,7 @@ async function main() {
     const bridge = new BridgeService(store, adapters, config.defaultWorkspace, config.workspaceRoot, isProviderInstalled, config.defaultMode, config.codexSandboxMode);
     const botManagement = new BotManagementService(config.dataDir, config.botRestartServiceName, config.botRestartHelperPath, botPollingState);
     startArtifactCleanupSchedule(new AgentMemoryService(config.dataDir));
+    startWorkspaceCleanupSchedule(new WorkspaceCleanupService(config.dataDir, config.workspaceRoot));
     if (config.localUiEnabled) {
         const localUi = new LocalUiService(bridge, config.localUiHost, config.localUiPort);
         await localUi.start()
@@ -88,6 +90,30 @@ async function main() {
     });
     await startManualPollingScheduler(bots);
 }
+function startWorkspaceCleanupSchedule(workspaceCleanupService) {
+    if (!config.workspaceCleanupEnabled) {
+        console.log("Workspace cleanup schedule is disabled.");
+        return;
+    }
+    const run = async () => {
+        try {
+            const result = await workspaceCleanupService.cleanupOrphanWorkspaces();
+            console.log(`[workspace-cleanup] ${result}`);
+        }
+        catch (error) {
+            console.error("[workspace-cleanup] failed:", error);
+        }
+    };
+    console.log(`Workspace cleanup schedule enabled: interval=${config.workspaceCleanupIntervalMs}ms`);
+    const initial = setTimeout(() => {
+        void run();
+    }, 120_000);
+    initial.unref();
+    const interval = setInterval(() => {
+        void run();
+    }, config.workspaceCleanupIntervalMs);
+    interval.unref();
+}
 function startArtifactCleanupSchedule(memoryService) {
     if (!config.artifactCleanupEnabled) {
         console.log("Artifact cleanup schedule is disabled.");

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

@@ -9,6 +9,7 @@ export class AgentMemoryService {
     artifactsPath;
     secretsPath;
     docsPath;
+    macrosPath;
     telegramUploadsDir;
     constructor(dataDir) {
         this.dataDir = dataDir;
@@ -16,6 +17,7 @@ export class AgentMemoryService {
         this.artifactsPath = path.join(this.rootDir, "artifacts.json");
         this.secretsPath = path.join(this.rootDir, "secrets.json");
         this.docsPath = path.join(this.rootDir, "docs-index.json");
+        this.macrosPath = path.join(this.rootDir, "macros.json");
         this.telegramUploadsDir = path.join(dataDir, "uploads", "telegram");
     }
     async recordInstruction(session, instruction) {
@@ -238,6 +240,57 @@ export class AgentMemoryService {
         await this.writeSecrets(secrets);
         return existed;
     }
+    async setMacro(alias, prompt) {
+        const normalizedAlias = this.normalizeMacroAlias(alias);
+        const normalizedPrompt = prompt.trim();
+        if (!normalizedPrompt) {
+            throw new Error("Macro prompt must not be empty.");
+        }
+        const macros = await this.readMacros();
+        const now = new Date().toISOString();
+        const record = {
+            alias: normalizedAlias,
+            prompt: normalizedPrompt,
+            createdAt: macros[normalizedAlias]?.createdAt ?? now,
+            updatedAt: now,
+        };
+        macros[normalizedAlias] = record;
+        await this.writeJson(this.macrosPath, macros);
+        return record;
+    }
+    async removeMacro(alias) {
+        const normalizedAlias = this.normalizeMacroAlias(alias);
+        const macros = await this.readMacros();
+        const existed = Boolean(macros[normalizedAlias]);
+        delete macros[normalizedAlias];
+        await this.writeJson(this.macrosPath, macros);
+        return existed;
+    }
+    async getMacro(aliasOrIndex) {
+        const macros = Object.values(await this.readMacros())
+            .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+        const trimmed = aliasOrIndex.trim();
+        if (/^[0-9]+$/.test(trimmed)) {
+            const index = Number.parseInt(trimmed, 10);
+            return index >= 1 && index <= macros.length ? macros[index - 1] : undefined;
+        }
+        const normalizedAlias = this.normalizeMacroAlias(trimmed);
+        return macros.find((macro) => macro.alias === normalizedAlias);
+    }
+    async listMacros() {
+        const macros = Object.values(await this.readMacros())
+            .sort((left, right) => left.alias.localeCompare(right.alias, "ko"));
+        if (macros.length === 0) {
+            return "No macros are stored.";
+        }
+        return [
+            `Macros (${macros.length})`,
+            ...macros.map((macro, index) => {
+                const preview = macro.prompt.replace(/\s+/g, " ").slice(0, 120);
+                return `${index + 1}. ${macro.alias}\n   ${preview}${macro.prompt.length > preview.length ? "..." : ""}`;
+            }),
+        ].join("\n");
+    }
     async getSecret(key) {
         this.assertSecretKey(key);
         const secrets = await this.readSecrets();
@@ -646,6 +699,19 @@ export class AgentMemoryService {
     async readDocs() {
         return this.readJson(this.docsPath, {});
     }
+    async readMacros() {
+        return this.readJson(this.macrosPath, {});
+    }
+    normalizeMacroAlias(alias) {
+        const normalized = alias.trim();
+        if (/^[0-9]+$/.test(normalized)) {
+            throw new Error("Macro alias cannot be numeric. Numeric values are reserved for list selection.");
+        }
+        if (!/^[a-z0-9가-힣._-]{1,80}$/i.test(normalized)) {
+            throw new Error("Macro alias must be 1-80 chars and may contain letters, numbers, Korean, dot, underscore, or dash.");
+        }
+        return normalized;
+    }
     normalizeKeyword(keyword) {
         const normalized = keyword.trim().toLowerCase();
         if (!/^[a-z0-9가-힣._-]{1,80}$/i.test(normalized)) {

package/dist/services/bridge-service.js

@@ -354,7 +354,8 @@ export class BridgeService {
     formatResponses(responses) {
         return responses.map((response) => {
             const sessionLabel = response.publicSessionId ?? response.sessionId;
-            const header = `[${response.provider.toUpperCase()} | ${sessionLabel}]`;
+            const modelLabel = response.model?.trim() || this.defaultModelFor(response.provider);
+            const header = `[${response.provider.toUpperCase()} | ${modelLabel} | ${sessionLabel}]`;
             return `${header}\n${response.output}`;
         });
     }
@@ -520,6 +521,7 @@ export class BridgeService {
             responses.push({
                 ...response,
                 publicSessionId: session.publicId,
+                model: providerSession.model ?? this.defaultModelFor(provider),
             });
         }
         return responses;

package/dist/services/workspace-cleanup-service.js

@@ -0,0 +1,150 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const PRESERVED_WORKSPACE_TODO_FILES = new Set(["TODO.md", "todo.md", "todo.json"]);
+export class WorkspaceCleanupService {
+    dataDir;
+    workspaceRoot;
+    constructor(dataDir, workspaceRoot) {
+        this.dataDir = dataDir;
+        this.workspaceRoot = workspaceRoot;
+    }
+    async cleanupOrphanWorkspaces() {
+        const referenced = await this.referencedWorkspaceNames();
+        const entries = await fs.readdir(this.workspaceRoot, { withFileTypes: true }).catch(() => []);
+        const result = { removedPaths: 0, removedBytes: 0, skipped: 0, messages: [] };
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (referenced.has(entry.name)) {
+                continue;
+            }
+            const target = path.join(this.workspaceRoot, entry.name);
+            const bytes = await this.directorySize(target);
+            await fs.rm(target, { recursive: true, force: true });
+            result.removedPaths += 1;
+            result.removedBytes += bytes;
+            result.messages.push(`${entry.name} (${formatBytes(bytes)})`);
+        }
+        return [
+            "Workspace orphan cleanup finished.",
+            `removed=${result.removedPaths}`,
+            `freed=${formatBytes(result.removedBytes)}`,
+            result.messages.length > 0 ? `items=${result.messages.join(", ")}` : "items=none",
+        ].join(" ");
+    }
+    async cleanupSessionWorkspace(session) {
+        if (!this.isManagedWorkspace(session.workspace)) {
+            return [
+                `Workspace cleanup skipped for ${session.publicId}.`,
+                "The current workspace is not managed by RemoteAgent.",
+                `workspace=${session.workspace}`,
+            ].join("\n");
+        }
+        const result = { removedPaths: 0, removedBytes: 0, skipped: 0, messages: [] };
+        await this.cleanupWorkspaceContents(session.workspace, result);
+        return [
+            `Workspace cleanup finished for ${session.publicId}.`,
+            `workspace=${session.workspace}`,
+            `preservedSessionMemory=${path.join(this.dataDir, "managed", "sessions", session.publicId)}`,
+            `removed=${result.removedPaths}`,
+            `freed=${formatBytes(result.removedBytes)}`,
+            `skipped=${result.skipped}`,
+            result.messages.length > 0
+                ? ["removedItems:", ...result.messages.slice(0, 30).map((item) => `- ${item}`)].join("\n")
+                : "removedItems: none",
+        ].join("\n");
+    }
+    async cleanupWorkspaceContents(root, result) {
+        const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const entryPath = path.join(root, entry.name);
+            if (entry.isFile() && PRESERVED_WORKSPACE_TODO_FILES.has(entry.name)) {
+                result.skipped += 1;
+                continue;
+            }
+            await this.removePath(entryPath, result);
+        }
+    }
+    async removePath(target, result) {
+        const bytes = await this.pathSize(target);
+        await fs.rm(target, { recursive: true, force: true });
+        result.removedPaths += 1;
+        result.removedBytes += bytes;
+        result.messages.push(`${path.relative(this.workspaceRoot, target)} (${formatBytes(bytes)})`);
+    }
+    async referencedWorkspaceNames() {
+        const state = await this.readState();
+        const referenced = new Set();
+        const root = path.resolve(this.workspaceRoot);
+        for (const session of Object.values(state.sessions ?? {})) {
+            const workspace = session.workspace ? path.resolve(session.workspace) : "";
+            if (!workspace || !this.isPathInside(root, workspace)) {
+                continue;
+            }
+            referenced.add(path.basename(workspace));
+        }
+        return referenced;
+    }
+    async readState() {
+        const statePath = path.join(this.dataDir, "state.json");
+        const raw = await fs.readFile(statePath, "utf8").catch((error) => {
+            throw new Error(`state unavailable, refusing workspace cleanup: ${error.message}`);
+        });
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || !parsed.sessions || typeof parsed.sessions !== "object") {
+            throw new Error(`state unavailable, refusing workspace cleanup: invalid state at ${statePath}`);
+        }
+        return parsed;
+    }
+    isManagedWorkspace(workspace) {
+        const root = path.resolve(this.workspaceRoot);
+        const resolved = path.resolve(workspace);
+        return this.isPathInside(root, resolved) && resolved !== root;
+    }
+    isPathInside(parent, child) {
+        const relative = path.relative(parent, child);
+        return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+    }
+    async pathSize(target) {
+        const stat = await fs.stat(target).catch(() => undefined);
+        if (!stat) {
+            return 0;
+        }
+        if (stat.isFile()) {
+            return stat.size;
+        }
+        if (stat.isDirectory()) {
+            return this.directorySize(target);
+        }
+        return 0;
+    }
+    async directorySize(directory) {
+        const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+        let total = 0;
+        for (const entry of entries) {
+            const entryPath = path.join(directory, entry.name);
+            const stat = await fs.stat(entryPath).catch(() => undefined);
+            if (!stat) {
+                continue;
+            }
+            if (stat.isFile()) {
+                total += stat.size;
+            }
+            else if (stat.isDirectory()) {
+                total += await this.directorySize(entryPath);
+            }
+        }
+        return total;
+    }
+}
+function formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    return `${unitIndex === 0 ? value.toFixed(0) : value.toFixed(1)}${units[unitIndex]}`;
+}

package/dist/telegram-command-menu.js

@@ -13,11 +13,13 @@ export const TELEGRAM_COMMAND_MENU = [
     { command: "option", description: "Show or change runtime options" },
     { command: "secret", description: "Store or manage hidden secret values" },
     { command: "docs", description: "Pin or find session documents" },
+    { command: "macro", description: "Save or run reusable instructions" },
     { command: "model", description: "Show or change provider model" },
     { command: "stop", description: "Stop active work and clear queued messages" },
     { command: "sandbox", description: "Set Codex sandbox mode" },
     { command: "batch", description: "Collect and send a multi-message batch" },
     { command: "artifacts", description: "List or clean uploaded artifacts" },
+    { command: "cleanup", description: "Clean current session workspace" },
     { command: "bots", description: "List configured Telegram bots" },
     { command: "bot", description: "Manage Telegram bots" },
     { command: "install", description: "Install or update Codex or Claude" },

package/docs/OPERATIONS.md

@@ -122,6 +122,75 @@ Check the lock owner:
 cat /home/au2223/.remoteagent/remoteagent.lock
 ```
 
+## Disk maintenance
+
+RemoteAgent disk growth usually comes from Docker build cache, Docker volumes, Codex session logs, managed workspaces, Telegram uploads, and temporary build artifacts.
+
+Use one script for repeatable checks and conservative cleanup:
+
+```bash
+npm run maintenance:disk -- report
+```
+
+Run the safe cleanup path:
+
+```bash
+npm run maintenance:disk -- prune-safe
+```
+
+`prune-safe` performs only these actions:
+
+- `docker builder prune -f`
+- remove old `/tmp/remoteagent-codex-*`, `/tmp/remoteagent-claude-*`, and `/tmp/appback-*` directories older than 2 days
+- remove managed workspace directories under `WORKSPACE_ROOT` only when they are not referenced by RemoteAgent `state.json`
+
+Clean only orphan managed workspaces:
+
+```bash
+npm run maintenance:disk -- prune-workspaces
+```
+
+RemoteAgent also runs conservative workspace cleanup on a schedule when enabled:
+
+```bash
+WORKSPACE_CLEANUP_ENABLED=true
+WORKSPACE_CLEANUP_INTERVAL_MS=86400000
+```
+
+Scheduled workspace cleanup only removes managed workspace directories under `WORKSPACE_ROOT` when they are not referenced by RemoteAgent `state.json`.
+If `state.json` is missing or invalid, workspace cleanup refuses to run.
+
+Clean the current chat session workspace manually from Telegram:
+
+```text
+/cleanup
+```
+
+`/cleanup` does not delete the session workspace directory itself. It removes the contents of the current managed workspace while preserving RemoteAgent's session todo/state/history under `~/.remoteagent/managed/sessions/<session>`. If a top-level `TODO.md`, `todo.md`, or `todo.json` exists inside the workspace, it is also preserved. The command refuses non-RemoteAgent-managed workspaces.
+
+Archive old Codex session logs explicitly:
+
+```bash
+npm run maintenance:disk -- prune-codex-sessions 45
+```
+
+This creates an archive under `~/.codex/session-archive/` and removes the archived jsonl files from `~/.codex/sessions`.
+Use this only when old Codex resume history is no longer needed.
+
+For server 30, run the installed package script through npm:
+
+```bash
+ssh au2223@192.168.0.30 'export PATH="/home/au2223/.local/bin:/home/au2223/.nvm/versions/node/v22.22.0/bin:$PATH"; npm explore -g appback-remoteagent -- npm run maintenance:disk -- report'
+ssh au2223@192.168.0.30 'export PATH="/home/au2223/.local/bin:/home/au2223/.nvm/versions/node/v22.22.0/bin:$PATH"; npm explore -g appback-remoteagent -- npm run maintenance:disk -- prune-safe'
+```
+
+For server 26:
+
+```bash
+ssh ospadmin@192.168.0.26 'export PATH="$HOME/.local/bin:$PATH"; npm explore -g appback-remoteagent -- npm run maintenance:disk -- report'
+ssh ospadmin@192.168.0.26 'export PATH="$HOME/.local/bin:$PATH"; npm explore -g appback-remoteagent -- npm run maintenance:disk -- prune-safe'
+```
+
 ## Git workflow
 
 The intended workflow is:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.15.6",
+  "version": "0.16.0",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",
@@ -23,7 +23,8 @@
     "prepublishOnly": "node scripts/prepublish-guard.mjs",
     "release:version": "bash scripts/release-version.sh",
     "release:publish": "bash scripts/release-publish.sh",
-    "release:deploy": "bash scripts/release-deploy.sh"
+    "release:deploy": "bash scripts/release-deploy.sh",
+    "maintenance:disk": "bash scripts/disk-maintenance.sh"
   },
   "dependencies": {
     "dotenv": "^16.6.1",

package/scripts/disk-maintenance.sh

@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat >&2 <<'USAGE'
+Usage: scripts/disk-maintenance.sh <report|prune-safe|prune-workspaces|prune-codex-sessions> [days]
+
+Examples:
+  scripts/disk-maintenance.sh report
+  scripts/disk-maintenance.sh prune-safe
+  scripts/disk-maintenance.sh prune-workspaces
+  scripts/disk-maintenance.sh prune-codex-sessions 45
+
+Notes:
+  report              Prints disk, Docker, workspace, cache, and large-file usage.
+  prune-safe          Removes Docker build cache, old RemoteAgent temp dirs, and orphan managed workspaces only.
+  prune-workspaces    Removes only managed workspace directories not referenced by RemoteAgent state.
+  prune-codex-sessions <days>
+                      Archives Codex session jsonl files older than <days> into ~/.codex/session-archive.
+                      This can break resume for archived old sessions, so it must be explicit.
+USAGE
+}
+
+ACTION="${1:-}"
+RETENTION_DAYS="${2:-}"
+DATA_DIR="${DATA_DIR:-$HOME/.remoteagent}"
+WORKSPACE_ROOT="${WORKSPACE_ROOT:-$HOME/workspaces/remoteagent}"
+CODEX_SESSIONS_DIR="${CODEX_SESSIONS_DIR:-$HOME/.codex/sessions}"
+CODEX_ARCHIVE_DIR="${CODEX_ARCHIVE_DIR:-$HOME/.codex/session-archive}"
+
+if [[ -z "$ACTION" ]]; then
+  usage
+  exit 1
+fi
+
+require_integer_days() {
+  local value="$1"
+  if [[ ! "$value" =~ ^[0-9]+$ ]] || [[ "$value" -lt 1 ]]; then
+    echo "Retention days must be a positive integer." >&2
+    exit 1
+  fi
+}
+
+print_section() {
+  printf '\n== %s ==\n' "$1"
+}
+
+docker_available() {
+  command -v docker >/dev/null 2>&1 && docker info >/dev/null 2>&1
+}
+
+report() {
+  print_section "filesystem"
+  df -hT /
+
+  print_section "top level"
+  sudo -n du -xhd1 / 2>/dev/null | sort -h | tail -30 || du -xhd1 "$HOME" 2>/dev/null | sort -h | tail -30 || true
+
+  print_section "home"
+  du -xhd1 "$HOME" 2>/dev/null | sort -h | tail -50 || true
+
+  if [[ -d "$WORKSPACE_ROOT" ]]; then
+    print_section "remoteagent workspaces"
+    du -xhd1 "$WORKSPACE_ROOT" 2>/dev/null | sort -h | tail -80 || true
+    print_section "orphan managed workspaces"
+    orphan_workspaces dry-run
+  fi
+
+  if [[ -d "$CODEX_SESSIONS_DIR" ]]; then
+    print_section "codex sessions"
+    du -xhd1 "$HOME/.codex" "$CODEX_SESSIONS_DIR" 2>/dev/null | sort -h | tail -40 || true
+  fi
+
+  print_section "tmp"
+  du -xhd1 /tmp 2>/dev/null | sort -h | tail -50 || true
+
+  if docker_available; then
+    print_section "docker system df"
+    docker system df || true
+  fi
+
+  print_section "largest files over 200M"
+  sudo -n find "$HOME" /var /tmp -xdev -type f -size +200M -printf '%s\t%p\n' 2>/dev/null \
+    | sort -n \
+    | tail -80 \
+    | awk '{size=$1/1024/1024/1024; $1=""; sub(/^\t/, ""); printf "%.2fG\t%s\n", size, $0}' || true
+}
+
+orphan_workspaces() {
+  local mode="${1:-dry-run}"
+  python3 - "$DATA_DIR" "$WORKSPACE_ROOT" "$mode" <<'PY'
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+data_dir, workspace_root, mode = sys.argv[1:4]
+state_path = os.path.join(data_dir, "state.json")
+
+def size_label(path):
+    try:
+        return subprocess.check_output(["du", "-sh", path], text=True).split()[0]
+    except Exception:
+        return "?"
+
+if not os.path.isdir(workspace_root):
+    print(f"workspace root not found: {workspace_root}")
+    sys.exit(0)
+
+try:
+    with open(state_path, "r", encoding="utf-8") as handle:
+        state = json.load(handle)
+except Exception as exc:
+    print(f"state unavailable, refusing workspace cleanup: {exc}")
+    sys.exit(0 if mode == "dry-run" else 1)
+
+referenced = set()
+for session in (state.get("sessions") or {}).values():
+    workspace = session.get("workspace") or session.get("workspacePath")
+    if isinstance(workspace, str):
+        normalized = os.path.abspath(workspace)
+        root = os.path.abspath(workspace_root)
+        if normalized == root or normalized.startswith(root + os.sep):
+            referenced.add(os.path.basename(normalized.rstrip(os.sep)))
+
+all_dirs = {
+    name for name in os.listdir(workspace_root)
+    if os.path.isdir(os.path.join(workspace_root, name))
+}
+orphans = sorted(all_dirs - referenced)
+
+print(f"referenced={len(referenced)} all={len(all_dirs)} orphan={len(orphans)}")
+for name in orphans:
+    path = os.path.join(workspace_root, name)
+    print(f"{size_label(path)}\t{name}")
+    if mode == "delete":
+        shutil.rmtree(path, ignore_errors=True)
+PY
+}
+
+prune_safe() {
+  print_section "before"
+  df -hT /
+
+  if docker_available; then
+    print_section "docker builder prune"
+    docker builder prune -f
+  else
+    print_section "docker builder prune skipped"
+    echo "docker is unavailable or current user cannot access it"
+  fi
+
+  print_section "old temp directories"
+  find /tmp -maxdepth 1 -mindepth 1 -type d \
+    \( -name 'remoteagent-codex-*' -o -name 'remoteagent-claude-*' -o -name 'appback-*' \) \
+    -mtime +2 -print -exec rm -rf {} +
+
+  print_section "orphan managed workspaces"
+  orphan_workspaces delete
+
+  print_section "after"
+  df -hT /
+}
+
+prune_codex_sessions() {
+  local days="$1"
+  require_integer_days "$days"
+
+  if [[ ! -d "$CODEX_SESSIONS_DIR" ]]; then
+    echo "Codex sessions dir not found: $CODEX_SESSIONS_DIR"
+    exit 0
+  fi
+
+  mkdir -p "$CODEX_ARCHIVE_DIR"
+  local stamp
+  stamp="$(date +%Y%m%d-%H%M%S)"
+  local list_file archive_file
+  list_file="$(mktemp)"
+  archive_file="$CODEX_ARCHIVE_DIR/codex-sessions-older-than-${days}d-$stamp.tar.gz"
+  find "$CODEX_SESSIONS_DIR" -type f -name '*.jsonl' -mtime +"$days" -print > "$list_file"
+
+  if [[ ! -s "$list_file" ]]; then
+    rm -f "$list_file"
+    echo "No Codex session files older than ${days}d."
+    exit 0
+  fi
+
+  tar -czf "$archive_file" --files-from "$list_file"
+  while IFS= read -r file; do
+    rm -f "$file"
+  done < "$list_file"
+  rm -f "$list_file"
+
+  find "$CODEX_SESSIONS_DIR" -type d -empty -delete
+  echo "Archived old Codex session files to $archive_file"
+}
+
+case "$ACTION" in
+  report)
+    report
+    ;;
+  prune-safe)
+    prune_safe
+    ;;
+  prune-workspaces)
+    orphan_workspaces delete
+    ;;
+  prune-codex-sessions)
+    prune_codex_sessions "${RETENTION_DAYS:-}"
+    ;;
+  *)
+    usage
+    exit 1
+    ;;
+esac

package/scripts/release-deploy.sh

@@ -39,6 +39,19 @@ deploy_30() {
   ssh au2223@192.168.0.30 "VERSION=$VERSION bash -s" <<'REMOTE'
 set -euo pipefail
 export PATH="/home/au2223/.local/bin:/home/au2223/.nvm/versions/node/v22.22.0/bin:$PATH"
+node - <<'NODE'
+const fs = require("fs");
+const path = "/home/au2223/.remoteagent/bot-polling-state.json";
+const state = JSON.parse(fs.readFileSync(path, "utf8"));
+const running = Object.values(state.bots || {})
+  .filter((bot) => Array.isArray(bot.runningSessionIds) && bot.runningSessionIds.length > 0)
+  .map((bot) => `${bot.username || bot.botId}: ${bot.runningSessionIds.join(", ")}`);
+if (running.length > 0) {
+  console.error("RemoteAgent has active provider work. Retry deploy after it finishes:");
+  for (const item of running) console.error(`- ${item}`);
+  process.exit(2);
+}
+NODE
 npm install -g "appback-remoteagent@$VERSION"
 remoteagent-install
 sudo -n systemctl restart remoteagent
@@ -53,6 +66,21 @@ deploy_26() {
   ssh ospadmin@192.168.0.26 "VERSION=$VERSION bash -s" <<'REMOTE'
 set -euo pipefail
 export PATH="$HOME/.local/bin:$PATH"
+node - <<'NODE'
+const fs = require("fs");
+const path = `${process.env.HOME}/.remoteagent/bot-polling-state.json`;
+if (fs.existsSync(path)) {
+  const state = JSON.parse(fs.readFileSync(path, "utf8"));
+  const running = Object.values(state.bots || {})
+    .filter((bot) => Array.isArray(bot.runningSessionIds) && bot.runningSessionIds.length > 0)
+    .map((bot) => `${bot.username || bot.botId}: ${bot.runningSessionIds.join(", ")}`);
+  if (running.length > 0) {
+    console.error("RemoteAgent has active provider work. Retry deploy after it finishes:");
+    for (const item of running) console.error(`- ${item}`);
+    process.exit(2);
+  }
+}
+NODE
 npm install -g "appback-remoteagent@$VERSION"
 remoteagent-install
 ~/.remoteagent/stop-remoteagent.sh || true

package/scripts/selftest-telegram-update.mjs

@@ -62,12 +62,20 @@ process.env.TELEGRAM_EMPTY_RESPONSE_RETRIES = "0";
 process.env.TELEGRAM_RETRYABLE_ERROR_RETRIES = "0";
 process.env.LOCAL_UI_ENABLED = "false";
 
-const [{ createBot }, { BridgeService }, { BotManagementService }, { FileStore }, { AgentMemoryService }] = await Promise.all([
+const [
+  { createBot },
+  { BridgeService },
+  { BotManagementService },
+  { FileStore },
+  { AgentMemoryService },
+  { WorkspaceCleanupService },
+] = await Promise.all([
   import(path.join(root, "dist", "bot.js")),
   import(path.join(root, "dist", "services", "bridge-service.js")),
   import(path.join(root, "dist", "services", "bot-management-service.js")),
   import(path.join(root, "dist", "store", "file-store.js")),
   import(path.join(root, "dist", "services", "agent-memory-service.js")),
+  import(path.join(root, "dist", "services", "workspace-cleanup-service.js")),
 ]);
 
 const providerCalls = [];
@@ -188,6 +196,59 @@ if (!/^TELEGRAM_UNTAGGED_INTENT_RETRIES=4$/m.test(envText)) {
   throw new Error(`Option command did not persist untagged intent retry limit to .env: ${envText}`);
 }
 
+const sessionWorkspace = session.workspace;
+await fs.mkdir(path.join(sessionWorkspace, "node_modules", "left-pad"), { recursive: true });
+await fs.mkdir(path.join(sessionWorkspace, "src"), { recursive: true });
+await fs.writeFile(path.join(sessionWorkspace, "node_modules", "left-pad", "index.js"), "module.exports = 1;\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "src", "keep.ts"), "export const keep = true;\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "debug.log"), "temporary log\n", "utf8");
+await fs.writeFile(path.join(sessionWorkspace, "TODO.md"), "- keep cleanup notes\n", "utf8");
+await send("/cleanup");
+await fs.access(path.join(sessionWorkspace, "TODO.md"));
+if (await pathExists(path.join(sessionWorkspace, "node_modules"))) {
+  throw new Error("/cleanup did not remove node_modules");
+}
+if (await pathExists(path.join(sessionWorkspace, "debug.log"))) {
+  throw new Error("/cleanup did not remove log file");
+}
+if (await pathExists(path.join(sessionWorkspace, "src"))) {
+  throw new Error("/cleanup did not remove regular workspace contents");
+}
+
+const orphanWorkspace = path.join(workspaceRoot, "orphan123");
+const referencedWorkspace = sessionWorkspace;
+await fs.mkdir(orphanWorkspace, { recursive: true });
+await fs.writeFile(path.join(orphanWorkspace, "artifact.tmp"), "orphan\n", "utf8");
+const workspaceCleanup = new WorkspaceCleanupService(dataDir, workspaceRoot);
+const orphanResult = await workspaceCleanup.cleanupOrphanWorkspaces();
+if (!/removed=1/.test(orphanResult)) {
+  throw new Error(`Expected one orphan workspace removal, got: ${orphanResult}`);
+}
+if (await pathExists(orphanWorkspace)) {
+  throw new Error("Orphan workspace was not removed");
+}
+if (!(await pathExists(referencedWorkspace))) {
+  throw new Error("Referenced workspace was removed unexpectedly");
+}
+
+const missingStateDataDir = path.join(tmp, "missing-state-data");
+const missingStateWorkspaceRoot = path.join(tmp, "missing-state-workspaces");
+const shouldRemain = path.join(missingStateWorkspaceRoot, "should-remain");
+await fs.mkdir(shouldRemain, { recursive: true });
+const missingStateCleanup = new WorkspaceCleanupService(missingStateDataDir, missingStateWorkspaceRoot);
+let refusedMissingState = false;
+try {
+  await missingStateCleanup.cleanupOrphanWorkspaces();
+} catch {
+  refusedMissingState = true;
+}
+if (!refusedMissingState) {
+  throw new Error("Workspace cleanup should refuse to run when state.json is missing");
+}
+if (!(await pathExists(shouldRemain))) {
+  throw new Error("Workspace cleanup removed a workspace when state.json was missing");
+}
+
 const memory = new AgentMemoryService(dataDir);
 const developmentSession = {
   ...session,
@@ -258,6 +319,9 @@ if (!calls.some((call) => call.method === "sendMessage" && /Set provider executi
 if (!calls.some((call) => call.method === "sendMessage" && /Set untagged intent retry limit to 4/.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))) {
+  throw new Error(`Did not see workspace cleanup acknowledgement. Calls: ${JSON.stringify(calls, null, 2)}`);
+}
 if (calls.some((call) => /미완료 TODO|\/task|새 작업으로 접수/.test(call.text))) {
   throw new Error(`Task gate language leaked to Telegram replies. Calls: ${JSON.stringify(calls, null, 2)}`);
 }
@@ -333,7 +397,10 @@ const evidenceCalls = (await fs.readFile(telegramCalls, "utf8"))
 if (missingEvidenceCalls !== 2) {
   throw new Error(`Expected missing evidence result to be retried once, got ${missingEvidenceCalls}`);
 }
-if (!evidenceCalls.some((call) => /변경 파일: `src\/example\.ts`/.test(call.text) && /`npm run check` 통과/.test(call.text))) {
+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()))) {
@@ -357,3 +424,7 @@ console.log(JSON.stringify({
 }, null, 2));
 
 process.exit(0);
+
+async function pathExists(target) {
+  return fs.access(target).then(() => true, () => false);
+}