@lnilluv/pi-ralph-loop 1.0.0 → 1.2.0

package/README.md

@@ -57,6 +57,9 @@ Stop with <promise>DONE</promise> only when the gate passes.
 | `/ralph [path-or-task]` | Run an existing task folder or `RALPH.md`, or draft a new loop from a task description. |
 | `/ralph-draft [path-or-task]` | Draft or edit a loop without starting it. |
 | `/ralph-stop [path-or-task]` | Request a graceful stop after the current iteration. |
+| `/ralph-cancel [path-or-task]` | Cancel the active iteration immediately. |
+| `/ralph-scaffold <name-or-path>` | Create a non-interactive RALPH.md starter template. |
+| `/ralph-logs [--path <task>] [--dest <dir>]` | Export run logs to an external directory. |
 
 ## Config reference
 | Field | Purpose |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lnilluv/pi-ralph-loop",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pi-native ralph loop — autonomous coding iterations with mid-turn supervision",
   "type": "module",
   "pi": {

package/src/index.ts

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext, SessionEntry, AgentEndEvent as PiAgentEndEvent, ToolResultEvent as PiToolResultEvent } from "@mariozechner/pi-coding-agent";
 import {
@@ -30,6 +30,8 @@ import { runRalphLoop } from "./runner.ts";
 import {
   checkStopSignal,
   createStopSignal,
+  createCancelSignal,
+  checkCancelSignal,
   listActiveLoopRegistryEntries,
   readActiveLoopRegistry,
   readIterationRecords,
@@ -119,6 +121,106 @@ type StopTarget = {
   source: StopTargetSource;
 };
 
+type ResolveRalphTargetResult =
+  | { kind: "resolved"; taskDir: string }
+  | { kind: "not-found" };
+
+function resolveRalphTarget(
+  ctx: Pick<CommandContext, "cwd" | "sessionManager" | "ui">,
+  options: {
+    commandName: string;
+    explicitPath?: string;
+    checkCrossProcess?: boolean;
+    allowCompletedRuns?: boolean;
+  },
+): ResolveRalphTargetResult | undefined {
+  const { commandName, explicitPath, checkCrossProcess = false, allowCompletedRuns = false } = options;
+  const now = new Date().toISOString();
+  const activeRegistryEntries = () => listActiveLoopRegistryEntries(ctx.cwd);
+  const { target: sessionTarget } = resolveSessionStopTarget(ctx, now);
+  const resolvedExplicitPath = explicitPath?.trim();
+
+  if (resolvedExplicitPath) {
+    const inspection = inspectExistingTarget(resolvedExplicitPath, ctx.cwd, true);
+    if (inspection.kind === "run") {
+      const taskDir = dirname(inspection.ralphPath);
+      if (checkCrossProcess) {
+        const registryTarget = activeRegistryEntries().find((entry) => entry.taskDir === taskDir);
+        if (registryTarget) {
+          return { kind: "resolved", taskDir: registryTarget.taskDir };
+        }
+
+        const statusFile = readStatusFile(taskDir);
+        if (
+          statusFile &&
+          (statusFile.status === "running" || statusFile.status === "initializing") &&
+          typeof statusFile.cwd === "string" &&
+          statusFile.cwd.length > 0
+        ) {
+          const statusRegistryTarget = listActiveLoopRegistryEntries(statusFile.cwd).find(
+            (entry) => entry.taskDir === taskDir && entry.loopToken === statusFile.loopToken,
+          );
+          if (statusRegistryTarget) {
+            return { kind: "resolved", taskDir: statusRegistryTarget.taskDir };
+          }
+        }
+      }
+
+      return { kind: "resolved", taskDir };
+    }
+
+    if (allowCompletedRuns) {
+      const taskDir = resolve(ctx.cwd, resolvedExplicitPath);
+      if (existsSync(join(taskDir, ".ralph-runner"))) {
+        return { kind: "resolved", taskDir };
+      }
+      ctx.ui.notify(`No ralph run data found at ${displayPath(ctx.cwd, taskDir)}.`, "error");
+      return { kind: "not-found" };
+    }
+
+    if (inspection.kind === "invalid-markdown") {
+      ctx.ui.notify(`Only task folders or RALPH.md can be stopped directly. ${displayPath(ctx.cwd, inspection.path)} is not stoppable.`, "error");
+      return undefined;
+    }
+    if (inspection.kind === "invalid-target") {
+      ctx.ui.notify(`Only task folders or RALPH.md can be stopped directly. ${displayPath(ctx.cwd, inspection.path)} is a file, not a task folder.`, "error");
+      return undefined;
+    }
+    if (inspection.kind === "dir-without-ralph" || inspection.kind === "missing-path") {
+      ctx.ui.notify(`No active ralph loop found at ${displayPath(ctx.cwd, inspection.dirPath)}.`, "warning");
+      return { kind: "not-found" };
+    }
+
+    ctx.ui.notify(`${commandName} expects a task folder or RALPH.md path.`, "error");
+    return undefined;
+  }
+
+  if (sessionTarget) {
+    return { kind: "resolved", taskDir: sessionTarget.taskDir };
+  }
+
+  const activeEntries = activeRegistryEntries();
+  if (activeEntries.length === 0) {
+    ctx.ui.notify(
+      allowCompletedRuns
+        ? `No ralph run data found. Specify a task path with ${commandName} <path>.`
+        : "No active ralph loops found.",
+      "warning",
+    );
+    return { kind: "not-found" };
+  }
+
+  if (activeEntries.length > 1) {
+    ctx.ui.notify(
+      `Multiple active ralph loops found. Use ${commandName} <task folder or RALPH.md> for an explicit target path.`,
+      "error",
+    );
+    return undefined;
+  }
+
+  return { kind: "resolved", taskDir: activeEntries[0].taskDir };
+}
+
 type ToolEvent = {
   toolName?: string;
   toolCallId?: string;
@@ -717,6 +819,81 @@ function displayPath(cwd: string, filePath: string): string {
   return rel && !rel.startsWith("..") ? `./${rel}` : filePath;
 }
 
+function exportRalphLogs(taskDir: string, destDir: string): { iterations: number; events: number; transcripts: number } {
+  const runnerDir = join(taskDir, ".ralph-runner");
+  if (!existsSync(runnerDir)) {
+    throw new Error(`No .ralph-runner directory found at ${taskDir}`);
+  }
+
+  mkdirSync(destDir, { recursive: true });
+
+  const filesToCopy = ["status.json", "iterations.jsonl", "events.jsonl"];
+  for (const file of filesToCopy) {
+    const src = join(runnerDir, file);
+    if (existsSync(src)) {
+      copyFileSync(src, join(destDir, file));
+    }
+  }
+
+  // Copy transcripts directory
+  const transcriptsDir = join(runnerDir, "transcripts");
+  let transcripts = 0;
+  if (existsSync(transcriptsDir)) {
+    const destTranscripts = join(destDir, "transcripts");
+    mkdirSync(destTranscripts, { recursive: true });
+    for (const entry of readdirSync(transcriptsDir)) {
+      const srcPath = join(transcriptsDir, entry);
+      try {
+        const stat = lstatSync(srcPath);
+        if (stat.isFile() && !stat.isSymbolicLink()) {
+          copyFileSync(srcPath, join(destTranscripts, entry));
+          transcripts++;
+        }
+      } catch {
+        // skip unreadable entries
+      }
+    }
+  }
+
+  // Count iterations and events
+  let iterations = 0;
+  let events = 0;
+  const iterPath = join(destDir, "iterations.jsonl");
+  if (existsSync(iterPath)) {
+    iterations = readFileSync(iterPath, "utf8").split("\n").filter((l) => l.trim()).length;
+  }
+  const evPath = join(destDir, "events.jsonl");
+  if (existsSync(evPath)) {
+    events = readFileSync(evPath, "utf8").split("\n").filter((l) => l.trim()).length;
+  }
+
+  return { iterations, events, transcripts };
+}
+
+export function parseLogExportArgs(raw: string): { path?: string; dest?: string; error?: string } {
+  const parts = raw.trim().split(/\s+/);
+  let path: string | undefined;
+  let dest: string | undefined;
+  let i = 0;
+  while (i < parts.length) {
+    if (parts[i] === "--dest" || parts[i] === "-d") {
+      if (i + 1 >= parts.length) return { error: "--dest requires a directory path" };
+      dest = parts[i + 1];
+      i += 2;
+    } else if (parts[i] === "--path" || parts[i] === "-p") {
+      if (i + 1 >= parts.length) return { error: "--path requires a task path" };
+      path = parts[i + 1];
+      i += 2;
+    } else if (!path && parts[i]) {
+      path = parts[i];
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return { path, dest };
+}
+
 async function promptForTask(ctx: Pick<CommandContext, "hasUI" | "ui">, title: string, placeholder: string): Promise<string | undefined> {
   if (!ctx.hasUI) return undefined;
   const value = await ctx.ui.input(title, placeholder);
@@ -955,6 +1132,32 @@ function applyStopTarget(
 let loopState: LoopState = defaultLoopState();
 const RALPH_EXTENSION_REGISTERED = Symbol.for("pi-ralph-loop.registered");
 
+function scaffoldRalphTemplate(): string {
+  return `---
+max_iterations: 10
+timeout: 120
+commands: []
+---
+# {{ task.name }}
+
+Describe the task here.
+
+## Evidence
+Use {{ commands.* }} outputs as evidence.
+
+## Completion
+Stop with <promise>DONE</promise> when finished.
+`;
+}
+
+function slugifyTaskName(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
 export default function (pi: ExtensionAPI, services: RegisterRalphCommandServices = {}) {
   const registeredPi = pi as ExtensionAPI & Record<symbol, boolean | undefined>;
   if (registeredPi[RALPH_EXTENSION_REGISTERED]) return;
@@ -1032,6 +1235,7 @@ export default function (pi: ExtensionAPI, services: RegisterRalphCommandService
 
   async function startRalphLoop(ralphPath: string, ctx: CommandContext, runLoopFn: typeof runRalphLoop = runRalphLoop, runtimeArgs: RuntimeArgs = {}) {
     let name: string;
+    let currentStopOnError = true;
     try {
       const raw = readFileSync(ralphPath, "utf8");
       const draftError = validateDraftContent(raw);
@@ -1042,6 +1246,7 @@ export default function (pi: ExtensionAPI, services: RegisterRalphCommandService
       const parsed = parseRalphMarkdown(raw);
       const { frontmatter } = parsed;
       if (!validateFrontmatter(frontmatter, ctx)) return;
+      currentStopOnError = frontmatter.stopOnError;
       const runtimeValidationError = validateRuntimeArgs(frontmatter, parsed.body, frontmatter.commands, runtimeArgs);
       if (runtimeValidationError) {
         ctx.ui.notify(runtimeValidationError, "error");
@@ -1078,6 +1283,7 @@ export default function (pi: ExtensionAPI, services: RegisterRalphCommandService
         timeout: loopState.timeout,
         maxIterations: loopState.maxIterations,
         guardrails: loopState.guardrails,
+        stopOnError: currentStopOnError,
         runtimeArgs,
         modelPattern: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
         thinkingLevel: ctx.model?.reasoning ? "high" : undefined,
@@ -1480,4 +1686,133 @@ export default function (pi: ExtensionAPI, services: RegisterRalphCommandService
       applyStopTarget(pi, ctx, materializeRegistryStopTarget(activeEntries[0]), now);
     },
   });
+
+  pi.registerCommand("ralph-cancel", {
+    description: "Cancel the active ralph iteration immediately",
+    handler: async (args: string, ctx: CommandContext) => {
+      const parsed = parseCommandArgs(args ?? "");
+      if (parsed.error) {
+        ctx.ui.notify(parsed.error, "error");
+        return;
+      }
+      if (parsed.mode === "task") {
+        ctx.ui.notify("/ralph-cancel expects a task folder or RALPH.md path, not task text.", "error");
+        return;
+      }
+
+      const result = resolveRalphTarget(ctx, {
+        commandName: "/ralph-cancel",
+        explicitPath: parsed.value || undefined,
+        checkCrossProcess: true,
+      });
+      if (!result || result.kind === "not-found") return;
+
+      const statusPath = join(result.taskDir, ".ralph-runner", "status.json");
+      if (!existsSync(statusPath)) {
+        ctx.ui.notify(`No active loop found at ${displayPath(ctx.cwd, result.taskDir)}. No run data exists.`, "warning");
+        return;
+      }
+
+      const statusFile = readStatusFile(result.taskDir);
+      const finishedStatuses = new Set([
+        "complete",
+        "max-iterations",
+        "no-progress-exhaustion",
+        "stopped",
+        "timeout",
+        "error",
+        "cancelled",
+      ]);
+      if (statusFile?.status && finishedStatuses.has(statusFile.status)) {
+        ctx.ui.notify(
+          `No active loop found at ${displayPath(ctx.cwd, result.taskDir)}. The loop already ended with status: ${statusFile.status}.`,
+          "warning",
+        );
+        return;
+      }
+
+      createCancelSignal(result.taskDir);
+      ctx.ui.notify("Cancel requested. The active iteration will be terminated immediately.", "warning");
+    },
+  });
+
+  pi.registerCommand("ralph-scaffold", {
+    description: "Create a non-interactive RALPH.md starter template",
+    handler: async (args: string, ctx: CommandContext) => {
+      const name = (args ?? "").trim();
+      if (!name) {
+        ctx.ui.notify("/ralph-scaffold expects a task name or path.", "error");
+        return;
+      }
+
+      let taskDir: string;
+      let ralphPath: string;
+
+      if (name.includes("/") || name.startsWith("./")) {
+        ralphPath = resolve(ctx.cwd, name.endsWith("/RALPH.md") ? name : join(name, "RALPH.md"));
+        taskDir = dirname(ralphPath);
+      } else {
+        const slug = slugifyTaskName(name);
+        if (!slug) {
+          ctx.ui.notify(`Cannot slugify "${name}" into a valid directory name.`, "error");
+          return;
+        }
+        taskDir = join(ctx.cwd, slug);
+        ralphPath = join(taskDir, "RALPH.md");
+      }
+
+      const resolvedTaskDir = resolve(taskDir);
+      const resolvedCwd = resolve(ctx.cwd);
+      if (!resolvedTaskDir.startsWith(resolvedCwd + "/") && resolvedTaskDir !== resolvedCwd) {
+        ctx.ui.notify("Task path must be within the current working directory.", "error");
+        return;
+      }
+
+      if (existsSync(ralphPath)) {
+        ctx.ui.notify(`RALPH.md already exists at ${displayPath(ctx.cwd, ralphPath)}. Not overwriting.`, "error");
+        return;
+      }
+
+      if (existsSync(taskDir) && readdirSync(taskDir).length > 0) {
+        ctx.ui.notify(`Directory ${displayPath(ctx.cwd, taskDir)} already exists and is not empty. Not overwriting.`, "error");
+        return;
+      }
+
+      mkdirSync(taskDir, { recursive: true });
+      writeFileSync(ralphPath, scaffoldRalphTemplate(), "utf8");
+      ctx.ui.notify(`Scaffolded ${displayPath(ctx.cwd, ralphPath)}`, "info");
+    },
+  });
+
+  pi.registerCommand("ralph-logs", {
+    description: "Export run logs from a ralph task to an external directory",
+    handler: async (args: string, ctx: CommandContext) => {
+      const parsed = parseLogExportArgs(args ?? "");
+      if (parsed.error) {
+        ctx.ui.notify(parsed.error, "error");
+        return;
+      }
+
+      const resolvedTarget = resolveRalphTarget(ctx, {
+        commandName: "/ralph-logs",
+        explicitPath: parsed.path,
+        allowCompletedRuns: true,
+      });
+      if (!resolvedTarget || resolvedTarget.kind === "not-found") return;
+      const taskDir = resolvedTarget.taskDir;
+
+      // Resolve dest directory
+      const destDir = parsed.dest
+        ? resolve(ctx.cwd, parsed.dest)
+        : join(ctx.cwd, `ralph-logs-${new Date().toISOString().replace(/[:.]/g, "-")}`);
+
+      try {
+        const result = exportRalphLogs(taskDir, destDir);
+        ctx.ui.notify(`Exported ${result.iterations} iteration records, ${result.events} events, ${result.transcripts} transcripts to ${displayPath(ctx.cwd, destDir)}`, "info");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Log export failed: ${message}`, "error");
+      }
+    },
+  });
 }

package/src/ralph.ts

@@ -17,6 +17,7 @@ export type Frontmatter = {
   timeout: number;
   completionPromise?: string;
   requiredOutputs?: string[];
+  stopOnError: boolean;
   guardrails: { blockCommands: string[]; protectedFiles: string[] };
   invalidCommandEntries?: number[];
   invalidArgEntries?: number[];
@@ -483,7 +484,7 @@ function escapeHtmlCommentMarkers(text: string): string {
 }
 
 export function defaultFrontmatter(): Frontmatter {
-  return { commands: [], maxIterations: 50, interIterationDelay: 0, timeout: 300, requiredOutputs: [], guardrails: { blockCommands: [], protectedFiles: [] } };
+  return { commands: [], maxIterations: 50, interIterationDelay: 0, timeout: 300, requiredOutputs: [], stopOnError: true, guardrails: { blockCommands: [], protectedFiles: [] } };
 }
 
 export function parseRalphMarkdown(raw: string): ParsedRalph {
@@ -514,6 +515,7 @@ export function parseRalphMarkdown(raw: string): ParsedRalph {
       completionPromise:
         typeof yaml.completion_promise === "string" && yaml.completion_promise.trim() ? yaml.completion_promise : undefined,
       requiredOutputs: toStringArray(yaml.required_outputs),
+      stopOnError: yaml.stop_on_error === false ? false : true,
       guardrails: {
         blockCommands: toStringArray(guardrails.block_commands),
         protectedFiles: toStringArray(guardrails.protected_files),
@@ -558,6 +560,9 @@ export function validateFrontmatter(fm: Frontmatter): string | null {
     }
     seenArgNames.add(arg);
   }
+  if (typeof fm.stopOnError !== "boolean") {
+    return "Invalid stop_on_error: must be true or false";
+  }
   for (const output of fm.requiredOutputs ?? []) {
     const requiredOutputError = validateRequiredOutputEntry(output);
     if (requiredOutputError) {
@@ -1137,6 +1142,7 @@ function buildDraftFrontmatter(mode: DraftMode, commands: CommandDef[]): Frontma
     interIterationDelay: 0,
     timeout: 300,
     requiredOutputs: [],
+    stopOnError: true,
     guardrails,
   };
 }
@@ -1177,6 +1183,7 @@ function renderDraftPlan(task: string, mode: DraftMode, target: DraftTarget, fro
     `max_iterations: ${frontmatter.maxIterations}`,
     `inter_iteration_delay: ${frontmatter.interIterationDelay}`,
     `timeout: ${frontmatter.timeout}`,
+    ...(frontmatter.stopOnError === false ? ["stop_on_error: false"] : []),
     ...(requiredOutputs.length > 0
       ? ["required_outputs:", ...requiredOutputs.map((output) => `  - ${yamlQuote(output)}`)]
       : []),

package/src/runner-rpc.ts

@@ -34,6 +34,10 @@ export type RpcSubprocessConfig = {
   thinkingLevel?: string;
   /** Callback for observing events as they stream */
   onEvent?: (event: RpcEvent) => void;
+  /** AbortSignal for cooperative cancellation. On abort, the direct child process is SIGKILLed.
+   *  Grandchild processes may survive — the caller is responsible for process group cleanup
+   *  if full-tree termination is required. */
+  signal?: AbortSignal;
 };
 
 export type RpcTelemetry = {
@@ -55,6 +59,7 @@ export type RpcSubprocessResult = {
   lastAssistantText: string;
   agentEndMessages: unknown[];
   timedOut: boolean;
+  cancelled?: boolean;
   error?: string;
   telemetry: RpcTelemetry;
 };
@@ -126,6 +131,7 @@ export async function runRpcIteration(config: RpcSubprocessConfig): Promise<RpcS
     provider: explicitProvider,
     modelId: explicitModelId,
     onEvent,
+    signal,
   } = config;
 
   // Parse modelPattern ("provider/modelId" or "provider/modelId:thinking") into provider and modelId
@@ -201,7 +207,35 @@ export async function runRpcIteration(config: RpcSubprocessConfig): Promise<RpcS
       telemetry.lastEventType = eventType;
     };
 
-    const timeout = setTimeout(() => {
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      telemetry.error = "cancelled";
+      try {
+        childProcess.kill("SIGKILL");
+      } catch {
+        // process may already be dead
+      }
+      clearTimeout(timeout);
+      resolve(buildResult({
+        success: false,
+        lastAssistantText,
+        agentEndMessages,
+        timedOut: false,
+        cancelled: true,
+        error: "cancelled",
+      }));
+    };
+
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+
+    timeout = setTimeout(() => {
       if (settled) return;
       settled = true;
       telemetry.timedOutAt = nowIso();
@@ -230,6 +264,7 @@ export async function runRpcIteration(config: RpcSubprocessConfig): Promise<RpcS
     const cleanup = () => {
       clearTimeout(timeout);
       endStdin();
+      signal?.removeEventListener("abort", onAbort);
     };
 
     const settle = (result: RpcSubprocessResult) => {

package/src/runner-state.ts

@@ -33,7 +33,7 @@ export type Guardrails = {
 
 export type IterationRecord = {
   iteration: number;
-  status: "running" | "complete" | "timeout" | "error";
+  status: "running" | "complete" | "timeout" | "error" | "cancelled";
   startedAt: string;
   completedAt?: string;
   durationMs?: number;
@@ -146,7 +146,7 @@ export type IterationCompletedEvent = {
   timestamp: string;
   iteration: number;
   loopToken: string;
-  status: "complete" | "timeout" | "error";
+  status: "complete" | "timeout" | "error" | "cancelled";
   progress: ProgressState;
   changedFiles: string[];
   noProgressStreak: number;
@@ -230,6 +230,7 @@ const STATUS_FILE = "status.json";
 const ITERATIONS_FILE = "iterations.jsonl";
 const EVENTS_FILE = "events.jsonl";
 const STOP_FLAG_FILE = "stop.flag";
+const CANCEL_FLAG_FILE = "cancel.flag";
 const ACTIVE_LOOP_REGISTRY_DIR = "active-loops";
 const ACTIVE_LOOP_REGISTRY_LEGACY_FILE = "active-loops.json";
 const ACTIVE_LOOP_REGISTRY_FILE_EXTENSION = ".json";
@@ -328,7 +329,7 @@ function isCompletionGate(value: unknown): value is { ready: boolean; reasons: s
 }
 
 function isIterationCompletedStatus(value: unknown): value is IterationRecord["status"] {
-  return value === "complete" || value === "timeout" || value === "error";
+  return value === "complete" || value === "timeout" || value === "error" || value === "cancelled";
 }
 
 function isRunnerEvent(value: unknown): value is RunnerEvent {
@@ -610,6 +611,22 @@ export function clearStopSignal(taskDir: string): void {
   }
 }
 
+export function createCancelSignal(taskDir: string): void {
+  const dir = ensureRunnerDir(taskDir);
+  writeFileSync(join(dir, CANCEL_FLAG_FILE), "", "utf8");
+}
+
+export function checkCancelSignal(taskDir: string): boolean {
+  return existsSync(join(runnerDir(taskDir), CANCEL_FLAG_FILE));
+}
+
+export function clearCancelSignal(taskDir: string): void {
+  const filePath = join(runnerDir(taskDir), CANCEL_FLAG_FILE);
+  if (existsSync(filePath)) {
+    rmSync(filePath, { force: true });
+  }
+}
+
 export function clearRunnerDir(taskDir: string): void {
   const dir = runnerDir(taskDir);
   if (existsSync(dir)) {