aiden-runtime 4.1.1 → 4.1.2

package/dist/tools/v4/memory/sessionSummary.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * tools/v4/memory/sessionSummary.ts — Phase v4.1.2 alive-core.
+ *
+ * `session_summary` — append a five-bullet summary of the current
+ * session to MEMORY.md under a `## Recent sessions` section.
+ *
+ * Why this exists: until v4.1.2, "what did we work on last session?"
+ * was unanswerable — MEMORY.md held durable facts but no rolling
+ * conversation log. After this tool runs at /quit (or on demand), the
+ * NEXT session's PromptBuilder injects MEMORY.md as a slot, and the
+ * model can read the summary back as ambient context.
+ *
+ * Design:
+ *
+ *   - The model is responsible for generating the five bullets. It
+ *     already has the full conversation context in its message
+ *     history, so this tool's job is *persistence* — not LLM dispatch.
+ *     This avoids threading the AuxiliaryClient into ToolContext just
+ *     for one tool and keeps the verify-on-disk contract clean.
+ *
+ *   - Section rotation: append the new entry at the top of the
+ *     section (most-recent-first), keep the most recent 10, drop the
+ *     rest. Bound the size so MEMORY.md doesn't grow indefinitely.
+ *
+ *   - Write goes through `MemoryGuard.replaceSection`, which preserves
+ *     the standard `verified: true` contract that
+ *     HonestyEnforcement relies on.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionSummaryTool = void 0;
+const RECENT_SESSIONS_HEADER = '## Recent sessions';
+const MAX_RECENT_ENTRIES = 10;
+/**
+ * Render one summary entry: timestamp header + bullets. Trims and
+ * normalises so two adjacent entries don't collide on whitespace.
+ */
+function formatEntry(bullets, when) {
+    const stamp = when.toISOString().replace(/\.\d+Z$/, 'Z'); // second precision
+    const cleaned = bullets
+        .map((b) => b.trim())
+        .filter((b) => b.length > 0)
+        .map((b) => (b.startsWith('-') ? b : `- ${b}`));
+    return [`### ${stamp}`, ...cleaned].join('\n');
+}
+/**
+ * Split an existing Recent-sessions body into entries (each headed by
+ * a `### ` timestamp line). The most-recent entry is index 0.
+ */
+function parseEntries(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return [];
+    // Split on `### ` at line start; first chunk is empty when the body
+    // starts with the marker, which we filter out.
+    const parts = trimmed
+        .split(/^### /m)
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0)
+        .map((p) => `### ${p}`);
+    return parts;
+}
+exports.sessionSummaryTool = {
+    schema: {
+        name: 'session_summary',
+        description: 'Append a five-bullet summary of the current session to MEMORY.md ' +
+            '(under "## Recent sessions"). The next session will see it as ambient ' +
+            'context. Call this at the end of a meaningful session, or right before ' +
+            'the user types /quit. You craft the bullets — be concise and concrete: ' +
+            'what we worked on, decisions made, files changed, problems solved, open items.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                bullets: {
+                    type: 'array',
+                    description: 'Exactly five concise bullets (3-15 words each) summarising the session. ' +
+                        'Focus on what will be useful for the next session.',
+                    items: {
+                        type: 'string',
+                        description: 'One bullet. Plain prose; leading "- " optional (added if missing).',
+                    },
+                },
+                trigger: {
+                    type: 'string',
+                    enum: ['manual', 'auto-quit'],
+                    description: 'Diagnostic only — whether the model invoked this directly ' +
+                        '("manual") or the REPL auto-triggered it on /quit ("auto-quit"). ' +
+                        'Defaults to "manual" when omitted.',
+                },
+            },
+            required: ['bullets'],
+        },
+    },
+    category: 'write',
+    mutates: true,
+    toolset: 'memory',
+    async execute(args, ctx) {
+        if (!ctx.memoryGuard) {
+            return { success: false, error: 'memory guard not configured' };
+        }
+        if (!ctx.memory) {
+            return { success: false, error: 'memory manager not configured' };
+        }
+        const rawBullets = Array.isArray(args.bullets) ? args.bullets : [];
+        const bullets = rawBullets
+            .filter((b) => typeof b === 'string')
+            .map((b) => b.trim())
+            .filter((b) => b.length > 0);
+        if (bullets.length === 0) {
+            return {
+                success: false,
+                error: 'session_summary requires at least one non-empty bullet',
+            };
+        }
+        const now = new Date();
+        const newEntry = formatEntry(bullets, now);
+        // Read current MEMORY.md to find existing Recent-sessions body.
+        const snap = await ctx.memory.loadSnapshot();
+        const memoryMd = snap.memoryMd ?? '';
+        // Pull existing section body (if any). The header consumes its
+        // line; the capture group grabs everything until the next h2 or
+        // EOF. Whitespace-only bodies are captured as empty after trim.
+        const headerEscaped = RECENT_SESSIONS_HEADER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Note: NO `m` flag — we want `$` to mean end-of-string, not
+        // end-of-line. With `m`, the lookahead `$` matches before every
+        // newline and we capture only the first body line instead of the
+        // whole section.
+        const sectionRe = new RegExp(`${headerEscaped}[^\\n]*\\n([\\s\\S]*?)(?=\\n## |$)`);
+        const match = memoryMd.match(sectionRe);
+        const existingBody = match ? (match[1] ?? '').trim() : '';
+        const existingEntries = parseEntries(existingBody);
+        // Most-recent-first ordering, capped to 10.
+        const combined = [newEntry, ...existingEntries].slice(0, MAX_RECENT_ENTRIES);
+        const newBody = combined.join('\n\n');
+        const result = await ctx.memoryGuard.replaceSection('memory', RECENT_SESSIONS_HEADER, newBody);
+        return {
+            success: result.ok,
+            verified: result.verified,
+            error: result.ok ? undefined : result.reason,
+            entries: combined.length,
+            trigger: args.trigger ?? 'manual',
+            timestamp: now.toISOString(),
+        };
+    },
+};

package/dist/tools/v4/sessions/recallSession.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * tools/v4/sessions/recallSession.ts — Phase v4.1.2-memory-C.
+ *
+ * `recall_session` — return ranked SessionDistillation summaries for
+ * past sessions matching the user's query (or just the most recent N
+ * when no query is supplied).
+ *
+ * Coexists with `session_search`:
+ *   - session_search → FTS5 over message TEXT in SessionStore.
+ *     Returns per-message snippets. Use when the user wants the exact
+ *     words of a past message.
+ *   - recall_session → ranked DISTILLATIONS by TOPIC. Returns
+ *     structured per-session summaries (decisions, open items, files
+ *     touched). Use when the user wants context on what HAPPENED in
+ *     past sessions.
+ *
+ * Index strategy: scan-all. Reads every distillation JSON from
+ * `<paths.root>/distillations/` per query. Expected file count is
+ * <1000 per user; sub-100ms at that scale. When telemetry shows
+ * latency >500ms, the escalation path is direct migration to SQLite
+ * FTS5 — JSON-index intermediate is intentionally skipped.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testFs = exports.recallSessionTool = void 0;
+exports.getDistillationsDir = getDistillationsDir;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const distillationStore_1 = require("../../../core/v4/distillationStore");
+const distillationIndex_1 = require("../../../core/v4/distillationIndex");
+const DEFAULT_LIMIT = 5;
+const MAX_LIMIT = 25;
+exports.recallSessionTool = {
+    schema: {
+        name: 'recall_session',
+        description: 'Recall past SESSIONS by topic. Returns ranked summaries — ' +
+            'decisions made, files touched, open items, tool usage — from ' +
+            'previously persisted session distillations. ' +
+            'For the EXACT WORDS of a past message, call `session_search` ' +
+            'instead (FTS5 over message text). For "what happened" / "what ' +
+            'did we work on" / "what was unfinished", use this tool.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional keyword filter. Case-insensitive substring match ' +
+                        'across keywords, bullets, decisions, open_items, and ' +
+                        'tool names. Omit to get the most recent sessions.',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Maximum number of matches to return. Default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}.`,
+                },
+                days: {
+                    type: 'number',
+                    description: 'Optional recency window in days. Drops distillations older ' +
+                        'than this before ranking. Omit for no time filter.',
+                },
+                include_full: {
+                    type: 'boolean',
+                    description: 'When true, each match also carries tools_used + keywords ' +
+                        '(useful when the agent needs granular tool history). ' +
+                        'Default false to keep responses compact.',
+                },
+            },
+        },
+    },
+    category: 'read',
+    mutates: false,
+    toolset: 'sessions',
+    async execute(args, ctx) {
+        if (!ctx.paths?.root) {
+            return {
+                success: false,
+                error: 'recall_session requires resolved aiden paths',
+            };
+        }
+        const dir = node_path_1.default.join(ctx.paths.root, 'distillations');
+        // Read everything off disk first. Each failure (malformed JSON,
+        // EACCES on individual files) is skipped silently; the diagnostic
+        // for "files exist but couldn't be read" is the gap between
+        // scanned (id count) and dists.length (parse-success count).
+        let ids;
+        try {
+            ids = await (0, distillationStore_1.listDistillationIds)(dir);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                // No distillations directory yet — first-run case is
+                // success with zero matches, NOT a failure.
+                return {
+                    success: true,
+                    query: typeof args.query === 'string' ? args.query : undefined,
+                    matches: [],
+                    total_found: 0,
+                    scanned: 0,
+                };
+            }
+            return {
+                success: false,
+                error: `Failed to enumerate distillations: ${err.message}`,
+            };
+        }
+        const dists = [];
+        for (const id of ids) {
+            try {
+                const d = await (0, distillationStore_1.readDistillation)(dir, id);
+                if (d)
+                    dists.push(d);
+            }
+            catch {
+                // One bad file shouldn't prevent the agent from seeing the
+                // rest. The user can diagnose via `aiden doctor` (the file
+                // is still on disk).
+            }
+        }
+        const recallQuery = {
+            query: typeof args.query === 'string' ? args.query : undefined,
+            limit: typeof args.limit === 'number' ? args.limit : undefined,
+            days: typeof args.days === 'number' ? args.days : undefined,
+            include_full: args.include_full === true,
+        };
+        const ranked = (0, distillationIndex_1.rankDistillations)(dists, recallQuery);
+        return {
+            success: true,
+            query: recallQuery.query,
+            matches: ranked.matches,
+            total_found: ranked.total_found,
+            // scanned reflects files we attempted to read — useful diagnostic.
+            // If scanned > ranked.total_found AND dists.length < scanned, the
+            // delta is malformed files; the agent can suggest running aiden
+            // doctor to inspect.
+            scanned: ids.length,
+        };
+        // Note re: subsystem health — wire-up happens at the runtime
+        // construction layer (cli/v4/aidenCLI.ts) where the registry is
+        // built. The tool itself stays pure of registry-knowledge for
+        // testability; the registry caller decides whether to wrap the
+        // file-read errors in a tracker.
+    },
+};
+// Expose the directory path for runtime wire-up. Tools that want to
+// register recall_session with the slice3 SubsystemHealthRegistry
+// pass this helper to the tracker so they get health snapshots without
+// hard-coding the path in two places.
+function getDistillationsDir(rootDir) {
+    return node_path_1.default.join(rootDir, 'distillations');
+}
+// Re-export read-only fs surface used by tests under controlled
+// fixtures. Production code never imports from here; the tool calls
+// fs directly.
+exports.__testFs = node_fs_1.promises;

package/dist/tools/v4/sessions/sessionSearch.js

@@ -22,7 +22,11 @@ const MAX_LIMIT = 50;
 exports.sessionSearchTool = {
     schema: {
         name: 'session_search',
-        description: 'Search past conversation sessions by keyword (FTS5 full-text). Returns matching message snippets with the session id and timestamp. Use to recall something the user said in an earlier conversation.',
+        description: 'Search past conversation MESSAGES by keyword (FTS5 full-text). ' +
+            'Returns matching message SNIPPETS with the session id and timestamp. ' +
+            'Use when you need the exact words a past message contained. ' +
+            'For topic-level recall of what happened in past sessions (decisions, ' +
+            'files touched, open items), call `recall_session` instead.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/tools/v4/system/_psHelpers.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * tools/v4/system/_psHelpers.ts — Phase v4.1.2-followup-3.
+ *
+ * Shared utilities for the computer-control tool family. Each tool
+ * (screenshot / os_process_list / media_key / volume_set / app_launch /
+ * app_close / clipboard_read / clipboard_write) gates on `win32` and
+ * shells out to PowerShell. The gate + exec boilerplate is identical
+ * across all eight tools — extracted here so the per-tool files stay
+ * focused on the one PowerShell snippet that matters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWindows = exports.execAsync = void 0;
+exports.windowsOnlyError = windowsOnlyError;
+exports.runPowerShell = runPowerShell;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+exports.execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+/**
+ * Standard "not supported on this platform" error payload. Surfaces a
+ * link the user can file an issue against rather than pretending the
+ * call quietly no-op'd.
+ */
+function windowsOnlyError(toolName) {
+    return {
+        success: false,
+        error: `Tool '${toolName}' is Windows-only in v4.1.2. macOS/Linux ` +
+            `support tracked at github.com/taracodlabs/aiden — please file an ` +
+            `issue if needed. (Detected platform: ${process.platform})`,
+    };
+}
+/**
+ * Run a PowerShell snippet and return stdout. Defaults to a 15-second
+ * timeout — caller passes a different one when a slower operation
+ * (screenshot, app launch) is expected.
+ *
+ * Single source of truth for the `shell: 'powershell.exe'` invocation
+ * shape so future powershell-CLI / `pwsh` migration is one-line.
+ */
+async function runPowerShell(script, options = {}) {
+    const opts = {
+        shell: 'powershell.exe',
+        timeout: options.timeoutMs ?? 15000,
+        maxBuffer: (options.maxBufferMb ?? 4) * 1024 * 1024,
+    };
+    return await (0, exports.execAsync)(script, opts);
+}
+const isWindows = () => process.platform === 'win32';
+exports.isWindows = isWindows;

package/dist/tools/v4/system/aidenSelfUpdate.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * tools/v4/system/aidenSelfUpdate.ts — Phase v4.1.2-update.
+ *
+ * Natural-language entry point for self-update. When the user asks
+ * Aiden to update / install latest / upgrade itself, the model calls
+ * this tool. Routes to the same shared executor (`executeInstall`)
+ * that `/update install` uses — single source of truth for install
+ * behavior.
+ *
+ * Two-step confirmation contract (consent gate):
+ *   1. First call with `confirm: false` — returns status + a prompt
+ *      asking the user to confirm. NEVER spawns.
+ *   2. Model surfaces the prompt to the user; waits for explicit
+ *      agreement ("yes update", "go ahead", "do it").
+ *   3. Second call with `confirm: true` — only after explicit user
+ *      agreement; spawns the install.
+ *
+ * The contract is enforced via tool DESCRIPTION (model-facing rule).
+ * Tool-side, we don't track "did the user actually consent" — that
+ * needs a runtime approval object (request_id + fresh-confirmation
+ * verification) which is a v4.2+ design. For v4.1.2 the description
+ * carries the rule and the tool trusts the model to follow it.
+ *
+ * Acceptable risk: failure mode of a misbehaving model is "user gets
+ * an unwanted install they have to /quit to apply" — not data loss.
+ * Phase D's promotion path is the more sensitive consent surface and
+ * is user-driven UI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aidenSelfUpdateTool = void 0;
+const version_1 = require("../../../core/version");
+const checkUpdate_1 = require("../../../core/v4/update/checkUpdate");
+const executeInstall_1 = require("../../../core/v4/update/executeInstall");
+exports.aidenSelfUpdateTool = {
+    schema: {
+        name: 'aiden_self_update',
+        description: 'Update Aiden to the latest version via npm install -g aiden-runtime@latest. ' +
+            'TWO-STEP CONFIRMATION REQUIRED: first call with confirm:false to check status ' +
+            'and surface to the user; only call with confirm:true AFTER the user explicitly ' +
+            'agrees in their next message ("yes update", "go ahead", "do it"). NEVER call ' +
+            'with confirm:true autonomously. ' +
+            'Call this tool ONLY when the user explicitly asks Aiden to update / install ' +
+            'latest / upgrade itself. Example user phrases that warrant a call: ' +
+            '"update yourself", "can you install the latest version?", "upgrade to the latest", ' +
+            '"self-update". DO NOT call when: user asks about update status without requesting ' +
+            'action ("are there updates?") — for status queries, just answer from your context; ' +
+            'user mentions updates of OTHER software ("update VSCode"); user has not explicitly ' +
+            'asked Aiden to update itself.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                confirm: {
+                    type: 'boolean',
+                    description: 'False on first call (status check, no install). True on second call AFTER ' +
+                        'the user explicitly agreed to proceed in their last message.',
+                },
+            },
+            required: ['confirm'],
+        },
+    },
+    category: 'write',
+    mutates: true,
+    toolset: 'system',
+    async execute(args, ctx) {
+        if (!ctx.paths) {
+            return {
+                success: false,
+                error: 'aiden_self_update needs Aiden user-data paths — not configured in this context.',
+            };
+        }
+        const confirm = args.confirm === true;
+        // Status probe — bypass the 6h boot cache for user-initiated checks.
+        const status = await (0, checkUpdate_1.checkForUpdate)({
+            paths: ctx.paths,
+            installedVersion: version_1.VERSION,
+            cacheTtlMs: 0,
+        });
+        // ── First call: confirm:false → status + prompt. NEVER spawn. ─────
+        if (!confirm) {
+            if (status.latest === null) {
+                return {
+                    success: true,
+                    stage: 'status',
+                    message: "Couldn't check for updates (registry unreachable). " +
+                        'Try again in a moment, or run `npm install -g aiden-runtime@latest` manually.',
+                    installed: status.installed,
+                    latest: null,
+                    updateAvailable: false,
+                };
+            }
+            if (!status.updateAvailable) {
+                return {
+                    success: true,
+                    stage: 'status',
+                    message: `You're on the latest version (v${status.installed}). Nothing to update.`,
+                    installed: status.installed,
+                    latest: status.latest,
+                    updateAvailable: false,
+                };
+            }
+            return {
+                success: true,
+                stage: 'status',
+                message: `Update available: v${status.installed} → v${status.latest}. ` +
+                    `Confirm by saying "yes update" or "go ahead". This runs ` +
+                    `\`npm install -g aiden-runtime@latest\` and you'll need to ` +
+                    `restart Aiden after.`,
+                installed: status.installed,
+                latest: status.latest,
+                updateAvailable: true,
+            };
+        }
+        // ── Second call: confirm:true → install. ────────────────────────
+        if (status.latest === null) {
+            return {
+                success: false,
+                stage: 'install',
+                error: "Can't install — registry unreachable. " +
+                    'Try again or run `npm install -g aiden-runtime@latest` manually.',
+                installed: status.installed,
+            };
+        }
+        if (!status.updateAvailable) {
+            return {
+                success: true,
+                stage: 'install',
+                message: `Already on v${status.installed}. Nothing to install.`,
+                installed: status.installed,
+                latest: status.latest,
+                updateAvailable: false,
+            };
+        }
+        const result = await (0, executeInstall_1.executeInstall)();
+        if (result.success) {
+            const v = result.installedVersion ?? status.latest;
+            return {
+                success: true,
+                stage: 'install',
+                message: `✓ aiden-runtime v${v} installed. Restart Aiden to apply: ` +
+                    `type /quit then re-run \`aiden\`.`,
+                installed: status.installed,
+                installedVersion: v,
+            };
+        }
+        return {
+            success: false,
+            stage: 'install',
+            error: result.error ?? 'Install failed (no error message).',
+            installed: status.installed,
+            latestSeen: status.latest,
+            // Keep stdout/stderr off the model-visible response to avoid
+            // prompt bloat; user-actionable copy-paste is already in error.
+        };
+    },
+};

package/dist/tools/v4/system/appClose.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * tools/v4/system/appClose.ts — `app_close` tool.
+ *
+ * Close one or more Windows processes by process name. Accepts the
+ * bare name without `.exe` (matches `Stop-Process -Name` semantics).
+ * Returns the count of processes successfully terminated.
+ *
+ * The .exe stripper handles user input like "close notepad.exe" /
+ * "close notepad" identically — both resolve to the same call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appCloseTool = void 0;
+const _psHelpers_1 = require("./_psHelpers");
+function normalise(name) {
+    return name.trim().replace(/\.exe$/i, '');
+}
+function buildPs(processName, force) {
+    const safe = processName.replace(/'/g, "''");
+    const forceFlag = force ? '-Force' : '';
+    return [
+        `$procs = Get-Process -Name '${safe}' -ErrorAction SilentlyContinue;`,
+        `$count = ($procs | Measure-Object).Count;`,
+        `if ($count -gt 0) { $procs | Stop-Process ${forceFlag} -ErrorAction SilentlyContinue; }`,
+        `Write-Output ('closed:' + $count);`,
+    ].join(' ');
+}
+exports.appCloseTool = {
+    schema: {
+        name: 'app_close',
+        description: 'Close one or more Windows processes by name (with or without the .exe suffix). Matches all running instances of that name. Set `force: true` to skip the app\'s graceful-shutdown prompt. Windows-only in v4.1.2.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                app: {
+                    type: 'string',
+                    description: 'Process name (e.g. "notepad", "spotify"). The .exe suffix is stripped automatically. Matches ALL running instances of that name.',
+                },
+                force: {
+                    type: 'boolean',
+                    description: 'If true, terminate without giving the app a chance to save unsaved work. Default false (graceful close).',
+                },
+            },
+            required: ['app'],
+        },
+    },
+    category: 'execute',
+    mutates: true,
+    toolset: 'system',
+    async execute(args, _ctx) {
+        if (!(0, _psHelpers_1.isWindows)())
+            return (0, _psHelpers_1.windowsOnlyError)('app_close');
+        const app = typeof args.app === 'string' ? normalise(args.app) : '';
+        if (!app) {
+            return { success: false, error: '`app` is required and must be non-empty.' };
+        }
+        const force = args.force === true;
+        try {
+            const { stdout } = await (0, _psHelpers_1.runPowerShell)(buildPs(app, force), {
+                timeoutMs: 10000,
+            });
+            const m = stdout.trim().match(/closed:(\d+)/);
+            const closed = m ? Number(m[1]) : 0;
+            return { success: true, app, closed, force };
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    },
+};