@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/scheduler/clock-install/darwin-launchd.js

@@ -0,0 +1,238 @@
+import { spawn } from "node:child_process";
+import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { deriveClockUnitName, hashManagedConfig, } from "../clock.js";
+import { MANAGED_MARKER } from "./types.js";
+function launchAgentsDir() {
+    return path.join(os.homedir(), "Library", "LaunchAgents");
+}
+function plistPath(unitName) {
+    return path.join(launchAgentsDir(), `${unitName}.plist`);
+}
+export function renderLaunchdPlist(input) {
+    const args = [
+        input.nodeBin,
+        input.agentWorkerEntry,
+        "scheduler",
+        "tick",
+        "--repo",
+        input.controlRepoRoot,
+        "--loop-agent-bin",
+        input.loopAgentBin,
+        "--clock-source",
+        "launchd",
+        "--json",
+    ];
+    const programArgs = args
+        .map((arg) => `\t\t<string>${escapeXml(arg)}</string>`)
+        .join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>Label</key>
+\t<string>${escapeXml(input.unitName)}</string>
+\t<key>Comment</key>
+\t<string>${MANAGED_MARKER} ${escapeXml(input.managedConfigHash)}</string>
+\t<key>ProgramArguments</key>
+\t<array>
+${programArgs}
+\t</array>
+\t<key>StartInterval</key>
+\t<integer>${input.intervalSec}</integer>
+\t<key>RunAtLoad</key>
+\t<true/>
+\t<key>WorkingDirectory</key>
+\t<string>${escapeXml(input.controlRepoRoot)}</string>
+\t<key>StandardOutPath</key>
+\t<string>${escapeXml(path.join(input.controlRepoRoot, ".harness/task-pool/scheduler/clock-launchd.out.log"))}</string>
+\t<key>StandardErrorPath</key>
+\t<string>${escapeXml(path.join(input.controlRepoRoot, ".harness/task-pool/scheduler/clock-launchd.err.log"))}</string>
+\t<key>ProcessType</key>
+\t<string>Background</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+async function runLaunchctl(args) {
+    return new Promise((resolve) => {
+        const child = spawn("launchctl", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({
+                code: 1,
+                stdout,
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+        });
+    });
+}
+export const darwinLaunchdAdapter = {
+    provider: "launchd",
+    async isAvailable() {
+        if (process.platform !== "darwin")
+            return false;
+        try {
+            await access("/bin/launchctl");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    unitName(controlRepoRoot) {
+        return deriveClockUnitName(controlRepoRoot);
+    },
+    renderConfig(input) {
+        return renderLaunchdPlist({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+    },
+    async install(input) {
+        const file = plistPath(input.receipt.unitName);
+        await mkdir(launchAgentsDir(), { recursive: true });
+        // Fail-closed if an unmanaged unit with same label exists.
+        try {
+            const existing = await readFile(file, "utf-8");
+            if (!existing.includes(MANAGED_MARKER) &&
+                !existing.includes("tea-agent.loop-agent.night")) {
+                throw new Error(`Refusing to overwrite unmanaged LaunchAgent at ${file}`);
+            }
+            // bootout before rewrite when loaded
+            await runLaunchctl([
+                "bootout",
+                `gui/${process.getuid?.() ?? 501}/${input.receipt.unitName}`,
+            ]);
+        }
+        catch (error) {
+            if (!(error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT")) {
+                // ignore bootout failures for unloaded units; rethrow ownership errors
+                if (error instanceof Error &&
+                    error.message.includes("Refusing to overwrite")) {
+                    throw error;
+                }
+            }
+        }
+        const body = renderLaunchdPlist({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+        await writeFile(file, body, "utf-8");
+        const uid = process.getuid?.() ?? 501;
+        const bootstrap = await runLaunchctl(["bootstrap", `gui/${uid}`, file]);
+        if (bootstrap.code !== 0) {
+            // try enable + kickstart as softer recovery
+            const enable = await runLaunchctl([
+                "enable",
+                `gui/${uid}/${input.receipt.unitName}`,
+            ]);
+            const kick = await runLaunchctl([
+                "kickstart",
+                "-k",
+                `gui/${uid}/${input.receipt.unitName}`,
+            ]);
+            if (enable.code !== 0 && kick.code !== 0 && bootstrap.code !== 0) {
+                throw new Error(`launchctl bootstrap failed: ${bootstrap.stderr || bootstrap.stdout || `exit ${bootstrap.code}`}`);
+            }
+        }
+    },
+    async uninstall(input) {
+        const file = plistPath(input.receipt.unitName);
+        try {
+            const existing = await readFile(file, "utf-8");
+            if (!existing.includes(MANAGED_MARKER) &&
+                !existing.includes(input.receipt.managedConfigHash)) {
+                throw new Error(`Refusing to uninstall non-managed LaunchAgent at ${file}`);
+            }
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        const uid = process.getuid?.() ?? 501;
+        await runLaunchctl(["bootout", `gui/${uid}/${input.receipt.unitName}`]);
+        await unlink(file).catch(() => { });
+    },
+    async probe(input) {
+        const unitName = input.receipt?.unitName ?? input.unitName ?? deriveClockUnitName(".");
+        const file = plistPath(unitName);
+        let present = false;
+        let body = "";
+        try {
+            body = await readFile(file, "utf-8");
+            present = true;
+        }
+        catch {
+            present = false;
+        }
+        const uid = process.getuid?.() ?? 501;
+        const print = await runLaunchctl(["print", `gui/${uid}/${unitName}`]);
+        const loaded = print.code === 0;
+        let configMatches = null;
+        if (present && input.receipt) {
+            configMatches =
+                body.includes(MANAGED_MARKER) &&
+                    (body.includes(input.receipt.managedConfigHash) ||
+                        body.includes(input.receipt.controlRepoRoot));
+        }
+        return {
+            present,
+            loaded,
+            configMatches,
+            detail: loaded
+                ? "launchctl print ok"
+                : print.stderr.trim() || print.stdout.trim() || "not loaded",
+        };
+    },
+};
+export function expectedLaunchdHash(receipt) {
+    return hashManagedConfig({
+        provider: "launchd",
+        unitName: receipt.unitName,
+        controlRepoRoot: receipt.controlRepoRoot,
+        intervalSec: receipt.intervalSec,
+        nodeBin: receipt.nodeBin,
+        agentWorkerEntry: receipt.agentWorkerEntry,
+        loopAgentBin: receipt.loopAgentBin,
+    });
+}

package/dist/worker/scheduler/clock-install/linux-systemd-user.js

@@ -0,0 +1,224 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { deriveClockUnitName } from "../clock.js";
+import { MANAGED_MARKER } from "./types.js";
+function userUnitDir() {
+    return path.join(os.homedir(), ".config", "systemd", "user");
+}
+function servicePath(unitName) {
+    return path.join(userUnitDir(), `${unitName}.service`);
+}
+function timerPath(unitName) {
+    return path.join(userUnitDir(), `${unitName}.timer`);
+}
+export function renderSystemdService(input) {
+    // Absolute argv — no shell.
+    const execStart = [
+        input.nodeBin,
+        input.agentWorkerEntry,
+        "scheduler",
+        "tick",
+        "--repo",
+        input.controlRepoRoot,
+        "--loop-agent-bin",
+        input.loopAgentBin,
+        "--clock-source",
+        "systemd-user",
+        "--json",
+    ]
+        .map(escapeSystemdArg)
+        .join(" ");
+    return `# ${MANAGED_MARKER} ${input.managedConfigHash}
+[Unit]
+Description=loop-agent Night Scheduler clock tick (${input.unitName})
+ConditionPathIsDirectory=${escapeSystemdArg(input.controlRepoRoot)}
+
+[Service]
+Type=oneshot
+WorkingDirectory=${escapeSystemdArg(input.controlRepoRoot)}
+ExecStart=${execStart}
+`;
+}
+export function renderSystemdTimer(input) {
+    return `# ${MANAGED_MARKER} ${input.managedConfigHash}
+[Unit]
+Description=loop-agent Night Scheduler clock timer (${input.unitName})
+
+[Timer]
+OnBootSec=30
+OnUnitActiveSec=${input.intervalSec}
+AccuracySec=10
+Unit=${input.unitName}.service
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function escapeSystemdArg(value) {
+    // Quote if needed; keep absolute paths intact.
+    if (/^[A-Za-z0-9_./:@%+=-]+$/.test(value))
+        return value;
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function runSystemctl(args) {
+    return new Promise((resolve) => {
+        const child = spawn("systemctl", ["--user", ...args], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({
+                code: 1,
+                stdout,
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+        });
+    });
+}
+export const linuxSystemdUserAdapter = {
+    provider: "systemd-user",
+    async isAvailable() {
+        if (process.platform !== "linux")
+            return false;
+        const probe = await runSystemctl(["show-environment"]);
+        return probe.code === 0;
+    },
+    unitName(controlRepoRoot) {
+        // systemd unit names prefer simple chars; reuse hash-derived label.
+        return deriveClockUnitName(controlRepoRoot).replace(/^com\.tea-agent\./, "loop-agent-");
+    },
+    renderConfig(input) {
+        return [
+            renderSystemdService({
+                unitName: input.receipt.unitName,
+                nodeBin: input.entrypoints.nodeBin,
+                agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+                controlRepoRoot: input.entrypoints.controlRepoRoot,
+                loopAgentBin: input.entrypoints.loopAgentBin,
+                managedConfigHash: input.receipt.managedConfigHash,
+            }),
+            renderSystemdTimer({
+                unitName: input.receipt.unitName,
+                intervalSec: input.receipt.intervalSec,
+                managedConfigHash: input.receipt.managedConfigHash,
+            }),
+        ].join("\n---\n");
+    },
+    async install(input) {
+        const svc = servicePath(input.receipt.unitName);
+        const tmr = timerPath(input.receipt.unitName);
+        await mkdir(userUnitDir(), { recursive: true });
+        for (const file of [svc, tmr]) {
+            try {
+                const existing = await readFile(file, "utf-8");
+                if (!existing.includes(MANAGED_MARKER)) {
+                    throw new Error(`Refusing to overwrite unmanaged systemd unit at ${file}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes("Refusing to overwrite")) {
+                    throw error;
+                }
+                // ENOENT ok
+            }
+        }
+        const serviceBody = renderSystemdService({
+            unitName: input.receipt.unitName,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+        const timerBody = renderSystemdTimer({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+        await writeFile(svc, serviceBody, "utf-8");
+        await writeFile(tmr, timerBody, "utf-8");
+        const reload = await runSystemctl(["daemon-reload"]);
+        if (reload.code !== 0) {
+            throw new Error(`systemctl --user daemon-reload failed: ${reload.stderr || reload.stdout}`);
+        }
+        const enable = await runSystemctl([
+            "enable",
+            "--now",
+            `${input.receipt.unitName}.timer`,
+        ]);
+        if (enable.code !== 0) {
+            throw new Error(`systemctl --user enable --now failed: ${enable.stderr || enable.stdout}`);
+        }
+    },
+    async uninstall(input) {
+        const svc = servicePath(input.receipt.unitName);
+        const tmr = timerPath(input.receipt.unitName);
+        for (const file of [svc, tmr]) {
+            try {
+                const existing = await readFile(file, "utf-8");
+                if (!existing.includes(MANAGED_MARKER) &&
+                    !existing.includes(input.receipt.managedConfigHash)) {
+                    throw new Error(`Refusing to uninstall non-managed systemd unit at ${file}`);
+                }
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    continue;
+                }
+                if (error instanceof Error &&
+                    error.message.includes("Refusing to uninstall")) {
+                    throw error;
+                }
+            }
+        }
+        await runSystemctl(["disable", "--now", `${input.receipt.unitName}.timer`]);
+        await unlink(svc).catch(() => { });
+        await unlink(tmr).catch(() => { });
+        await runSystemctl(["daemon-reload"]);
+    },
+    async probe(input) {
+        const unitName = input.receipt?.unitName ?? input.unitName;
+        const tmr = timerPath(unitName);
+        let present = false;
+        let body = "";
+        try {
+            body = await readFile(tmr, "utf-8");
+            present = true;
+        }
+        catch {
+            present = false;
+        }
+        const isActive = await runSystemctl(["is-active", `${unitName}.timer`]);
+        const loaded = isActive.code === 0 && isActive.stdout.trim() === "active";
+        let configMatches = null;
+        if (present && input.receipt) {
+            configMatches =
+                body.includes(MANAGED_MARKER) &&
+                    body.includes(input.receipt.managedConfigHash);
+        }
+        return {
+            present,
+            loaded,
+            configMatches,
+            detail: isActive.stdout.trim() || isActive.stderr.trim(),
+        };
+    },
+};

package/dist/worker/scheduler/clock-install/types.js

@@ -0,0 +1 @@
+export const MANAGED_MARKER = "tea-agent-loop-agent-night-clock";

package/dist/worker/scheduler/clock-install/win32-schtasks.js

@@ -0,0 +1,227 @@
+import { spawn } from "node:child_process";
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { deriveClockUnitName } from "../clock.js";
+import { MANAGED_MARKER } from "./types.js";
+/** schtasks /TR hard limit (Windows). Long node+bin+args lines must use a .cmd wrapper. */
+export const SCHTASKS_TR_MAX_CHARS = 261;
+function taskName(unitName) {
+    // schtasks task path; keep under user-visible folder.
+    return `\\${unitName}`;
+}
+/** Short, user-writable wrapper path (avoids long repo paths in /TR). */
+export function schtasksTickWrapperPath(unitName) {
+    const localAppData = process.env.LOCALAPPDATA?.trim() ||
+        path.join(os.homedir(), "AppData", "Local");
+    return path.join(localAppData, "tea-agent", "loop-agent-night", `${unitName}.cmd`);
+}
+export function renderSchtasksTickCmd(input) {
+    const line = [
+        quoteWin(input.nodeBin),
+        quoteWin(input.agentWorkerEntry),
+        "scheduler",
+        "tick",
+        "--repo",
+        quoteWin(input.controlRepoRoot),
+        "--loop-agent-bin",
+        quoteWin(input.loopAgentBin),
+        "--clock-source",
+        "schtasks",
+        "--json",
+    ].join(" ");
+    return [
+        "@echo off",
+        `cd /d ${quoteWin(input.controlRepoRoot)}`,
+        line,
+        "",
+    ].join("\r\n");
+}
+export function renderSchtasksCreateArgs(input) {
+    // /SC MINUTE /MO N → every N minutes (minimum 1). Sub-minute not supported by schtasks.
+    const minutes = Math.max(1, Math.round(input.intervalSec / 60));
+    const tr = quoteWin(input.trPath);
+    return [
+        "/Create",
+        "/F",
+        "/TN",
+        taskName(input.unitName),
+        "/TR",
+        tr,
+        "/SC",
+        "MINUTE",
+        "/MO",
+        String(minutes),
+        "/RL",
+        "LIMITED",
+    ];
+}
+export function assertSchtasksTrLength(trPath) {
+    const tr = quoteWin(trPath);
+    if (tr.length > SCHTASKS_TR_MAX_CHARS) {
+        throw new Error(`schtasks /TR exceeds ${SCHTASKS_TR_MAX_CHARS} characters (${tr.length}). ` +
+            `Use a shorter LOCALAPPDATA path or shorten the wrapper location. Got: ${tr}`);
+    }
+}
+function quoteWin(value) {
+    if (!/[ \t"]/.test(value))
+        return value;
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function formatSchtasksFailure(detail) {
+    const raw = detail.trim() || "unknown schtasks error";
+    if (/261/.test(raw) || /\/TR/i.test(raw)) {
+        return (`${raw} — Windows schtasks /TR 不能超过 ${SCHTASKS_TR_MAX_CHARS} 个字符。` +
+            `已应改用短路径 .cmd 包装；若仍失败请升级到含此修复的版本，或改用 Console 前台辅助 ticker / 手动 scheduler tick。`);
+    }
+    if (/access is denied|拒绝访问|0x80070005/i.test(raw)) {
+        return (`${raw} — 当前用户无权限创建计划任务。` +
+            `本适配器使用 /RL LIMITED，通常不需要管理员；请检查公司策略是否禁止普通用户创建任务。` +
+            `可改用 Console「开着时辅助 tick」或手动：agent-worker scheduler tick --repo .`);
+    }
+    return raw;
+}
+async function runSchtasks(args) {
+    return new Promise((resolve) => {
+        const child = spawn("schtasks", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({
+                code: 1,
+                stdout,
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+        });
+    });
+}
+async function writeTickWrapper(input) {
+    const wrapper = schtasksTickWrapperPath(input.unitName);
+    await mkdir(path.dirname(wrapper), { recursive: true });
+    const body = renderSchtasksTickCmd(input);
+    await writeFile(wrapper, body, "utf8");
+    assertSchtasksTrLength(wrapper);
+    return wrapper;
+}
+export const win32SchtasksAdapter = {
+    provider: "schtasks",
+    async isAvailable() {
+        if (process.platform !== "win32")
+            return false;
+        const probe = await runSchtasks(["/Query"]);
+        // /Query without /TN lists tasks; permission errors still mean binary exists.
+        return (probe.code === 0 ||
+            probe.stderr.length > 0 ||
+            probe.stdout.length > 0 ||
+            !probe.stderr.includes("not recognized"));
+    },
+    unitName(controlRepoRoot) {
+        return deriveClockUnitName(controlRepoRoot);
+    },
+    renderConfig(input) {
+        const wrapper = schtasksTickWrapperPath(input.receipt.unitName);
+        return renderSchtasksCreateArgs({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            trPath: wrapper,
+        }).join(" ");
+    },
+    async install(input) {
+        // Delete previous managed task if present (idempotent update).
+        await runSchtasks([
+            "/Delete",
+            "/F",
+            "/TN",
+            taskName(input.receipt.unitName),
+        ]);
+        const trPath = await writeTickWrapper({
+            unitName: input.receipt.unitName,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+        });
+        const args = renderSchtasksCreateArgs({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            trPath,
+        });
+        const created = await runSchtasks(args);
+        if (created.code !== 0) {
+            throw new Error(`schtasks create failed: ${formatSchtasksFailure(created.stderr || created.stdout || `exit ${created.code}`)}`);
+        }
+        // Marker is stored only in install receipt; schtasks has limited annotation.
+        // Ownership is enforced via receipt unitName hash + TR path match on probe.
+        void MANAGED_MARKER;
+    },
+    async uninstall(input) {
+        const query = await runSchtasks([
+            "/Query",
+            "/TN",
+            taskName(input.receipt.unitName),
+            "/V",
+            "/FO",
+            "LIST",
+        ]);
+        if (query.code !== 0) {
+            await unlink(schtasksTickWrapperPath(input.receipt.unitName)).catch(() => undefined);
+            return; // already gone
+        }
+        const body = `${query.stdout}\n${query.stderr}`;
+        const wrapper = schtasksTickWrapperPath(input.receipt.unitName);
+        if (!body.includes(input.receipt.controlRepoRoot) &&
+            !body.includes(input.receipt.agentWorkerEntry) &&
+            !body.includes(wrapper)) {
+            throw new Error(`Refusing to uninstall schtasks unit that does not match install receipt: ${input.receipt.unitName}`);
+        }
+        const del = await runSchtasks([
+            "/Delete",
+            "/F",
+            "/TN",
+            taskName(input.receipt.unitName),
+        ]);
+        if (del.code !== 0) {
+            throw new Error(`schtasks delete failed: ${formatSchtasksFailure(del.stderr || del.stdout || `exit ${del.code}`)}`);
+        }
+        await unlink(wrapper).catch(() => undefined);
+    },
+    async probe(input) {
+        const unitName = input.receipt?.unitName ?? input.unitName;
+        const query = await runSchtasks([
+            "/Query",
+            "/TN",
+            taskName(unitName),
+            "/V",
+            "/FO",
+            "LIST",
+        ]);
+        const present = query.code === 0;
+        const body = `${query.stdout}\n${query.stderr}`;
+        let configMatches = null;
+        if (present && input.receipt) {
+            const wrapper = schtasksTickWrapperPath(input.receipt.unitName);
+            configMatches =
+                body.includes(wrapper) ||
+                    (body.includes(input.receipt.controlRepoRoot) &&
+                        body.includes(input.receipt.agentWorkerEntry));
+        }
+        return {
+            present,
+            loaded: present,
+            configMatches,
+            detail: present ? "schtasks query ok" : query.stderr.trim() || "missing",
+        };
+    },
+};