misterpropre 0.0.1

package/dist/chunk-JCB4UDCP.js

@@ -0,0 +1,1348 @@
+import {
+  Banner,
+  FIX_INSTALL_NAME,
+  GhCli,
+  PURGE_INSTALL_NAME,
+  Panel,
+  appT,
+  appendRun,
+  configDir,
+  phaseLabel,
+  readConfig,
+  renderBundledSkill,
+  summarizeOutcome,
+  theme,
+  writeConfig
+} from "./chunk-HMGF6JWH.js";
+
+// src/core/spawn.ts
+import { spawn } from "child_process";
+var activeAgents = /* @__PURE__ */ new Set();
+function killGroup(child, signal) {
+  if (child.pid == null) return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+function killActiveAgents(signal) {
+  for (const child of activeAgents) killGroup(child, signal);
+}
+function runAgent(opts) {
+  const { command, args, env, cwd, timeoutMs, killGraceMs = 6e4, onStdout, onStderr } = opts;
+  return new Promise((resolve) => {
+    const start = Date.now();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    let killTimer;
+    let graceTimer;
+    const child = spawn(command, args, {
+      env: env ?? process.env,
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
+      // own process group → the shutdown handler/timeout can kill the agent + its children
+    });
+    activeAgents.add(child);
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (c) => {
+      stdout += c;
+      onStdout?.(c);
+    });
+    child.stderr?.on("data", (c) => {
+      stderr += c;
+      onStderr?.(c);
+    });
+    if (timeoutMs && timeoutMs > 0) {
+      killTimer = setTimeout(() => {
+        timedOut = true;
+        killGroup(child, "SIGTERM");
+        graceTimer = setTimeout(() => killGroup(child, "SIGKILL"), killGraceMs);
+      }, timeoutMs);
+    }
+    const finish = (code, signal) => {
+      if (settled) return;
+      settled = true;
+      activeAgents.delete(child);
+      if (killTimer) clearTimeout(killTimer);
+      if (graceTimer) clearTimeout(graceTimer);
+      resolve({ stdout, stderr, code, signal, timedOut, durationMs: Date.now() - start });
+    };
+    child.on("error", (err) => {
+      stderr += String(err);
+      finish(null, null);
+    });
+    child.on("close", (code, signal) => finish(code, signal));
+  });
+}
+
+// src/core/lock.ts
+import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/core/proc.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+
+// src/core/lock.ts
+var safe = (s) => s.replace(/[/\\]/g, "_");
+function locksRoot() {
+  const base = process.env.XDG_CACHE_HOME?.trim() || join(homedir(), ".cache");
+  return join(base, "misterpropre", "locks");
+}
+function lockDirFor(repo) {
+  return join(locksRoot(), `${safe(repo)}.lock`);
+}
+function readMeta(lockDir) {
+  try {
+    return JSON.parse(readFileSync(join(lockDir, "meta.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function acquireRepoLock(repo) {
+  const lockDir = lockDirFor(repo);
+  mkdirSync(locksRoot(), { recursive: true });
+  const tryCreate = () => {
+    try {
+      mkdirSync(lockDir);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!tryCreate()) {
+    const meta = readMeta(lockDir);
+    if (meta.pid && isProcessAlive(meta.pid)) {
+      return { acquired: false, heldByPid: meta.pid, since: meta.since };
+    }
+    rmSync(lockDir, { recursive: true, force: true });
+    if (!tryCreate()) {
+      const m2 = readMeta(lockDir);
+      return { acquired: false, heldByPid: m2.pid, since: m2.since };
+    }
+  }
+  writeFileSync(
+    join(lockDir, "meta.json"),
+    JSON.stringify({ pid: process.pid, since: (/* @__PURE__ */ new Date()).toISOString() }),
+    "utf8"
+  );
+  return {
+    acquired: true,
+    handle: { repo, path: lockDir, release: () => rmSync(lockDir, { recursive: true, force: true }) }
+  };
+}
+function releaseOwnLocks() {
+  let names;
+  try {
+    names = readdirSync(locksRoot());
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const lockDir = join(locksRoot(), name);
+    if (readMeta(lockDir).pid === process.pid) {
+      try {
+        rmSync(lockDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/core/worktree.ts
+import { existsSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, realpathSync, rmSync as rmSync2, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, isAbsolute, join as join2, relative } from "path";
+
+// src/core/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var pexec = promisify(execFile);
+async function git(args, opts = {}) {
+  const { stdout, stderr } = await pexec("git", args, {
+    cwd: opts.cwd,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024
+  });
+  return { stdout, stderr };
+}
+async function gitSafe(args, opts = {}) {
+  try {
+    const { stdout, stderr } = await git(args, opts);
+    return { ok: true, stdout, stderr };
+  } catch (e) {
+    return {
+      ok: false,
+      stdout: typeof e?.stdout === "string" ? e.stdout : "",
+      stderr: typeof e?.stderr === "string" ? e.stderr : String(e)
+    };
+  }
+}
+
+// src/core/worktree.ts
+function under(child, parent) {
+  const real = (p) => {
+    try {
+      return realpathSync(p);
+    } catch {
+      return p;
+    }
+  };
+  const rel = relative(real(parent), real(child));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+var safe2 = (s) => s.replace(/[/\\]/g, "_");
+function worktreeRoot() {
+  const base = process.env.XDG_CACHE_HOME?.trim() || join2(homedir2(), ".cache");
+  return join2(base, "misterpropre", "wt");
+}
+function worktreePath(repo, phase, runId) {
+  return join2(worktreeRoot(), safe2(repo), `${safe2(phase)}-${safe2(runId)}`);
+}
+async function worktreeHoldingBranch(clonePath, branch) {
+  const { stdout } = await git(["-C", clonePath, "worktree", "list", "--porcelain"]);
+  let current = null;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) current = line.slice("worktree ".length);
+    else if (line === `branch refs/heads/${branch}` && current) return current;
+  }
+  return null;
+}
+async function branchExists(clonePath, branch) {
+  return (await gitSafe(["-C", clonePath, "rev-parse", "--verify", "--quiet", `refs/heads/${branch}`])).ok;
+}
+var activeWorktrees = /* @__PURE__ */ new Set();
+function track(wt) {
+  if (!wt.external && under(wt.path, worktreeRoot())) activeWorktrees.add(wt.path);
+  return wt;
+}
+function removeActiveWorktreesSync() {
+  for (const p of activeWorktrees) {
+    if (under(p, worktreeRoot())) {
+      try {
+        rmSync2(p, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  activeWorktrees.clear();
+}
+async function addWorktree(opts) {
+  const { clonePath, path, newBranch, startPoint, ref, force } = opts;
+  const targetBranch = newBranch ?? ref;
+  if (targetBranch) {
+    const holder = await worktreeHoldingBranch(clonePath, targetBranch);
+    if (holder) {
+      return track({ path: holder, branch: targetBranch, reused: true, external: !under(holder, worktreeRoot()) });
+    }
+  }
+  mkdirSync2(dirname(path), { recursive: true });
+  const args = ["-C", clonePath, "worktree", "add"];
+  if (force) args.push("--force");
+  if (newBranch) {
+    if (!startPoint) throw new Error("addWorktree: startPoint is required with newBranch");
+    if (await branchExists(clonePath, newBranch)) {
+      args.push(path, newBranch);
+      await git(args);
+      return track({ path, branch: newBranch, reused: true, external: false });
+    }
+    args.push("-b", newBranch, path, startPoint);
+  } else if (ref) {
+    args.push(path, ref);
+  } else {
+    args.push(path);
+  }
+  await git(args);
+  return track({ path, branch: newBranch, external: false });
+}
+async function removeWorktree(clonePath, path) {
+  activeWorktrees.delete(path);
+  await gitSafe(["-C", clonePath, "worktree", "remove", "--force", path]);
+  if (under(path, worktreeRoot())) rmSync2(path, { recursive: true, force: true });
+}
+async function gcWorktrees(opts = {}) {
+  const root = worktreeRoot();
+  const removed = [];
+  if (!existsSync(root)) return { removed };
+  const now = opts.now ?? Date.now();
+  const maxAge = opts.maxAgeMs ?? 3 * 24 * 60 * 60 * 1e3;
+  for (const repo of readdirSync2(root)) {
+    const repoDir = join2(root, repo);
+    let entries;
+    try {
+      entries = readdirSync2(repoDir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const p = join2(repoDir, name);
+      let mtimeMs;
+      try {
+        mtimeMs = statSync(p).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (now - mtimeMs > maxAge) {
+        rmSync2(p, { recursive: true, force: true });
+        removed.push(p);
+      }
+    }
+  }
+  if (opts.clonePath) await gitSafe(["-C", opts.clonePath, "worktree", "prune"]);
+  return { removed };
+}
+
+// src/core/shutdown.ts
+var shuttingDown = false;
+function requestShutdown(code) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  try {
+    process.stderr.write("\n\u23F9  Stopping \u2014 killing the agent and cleaning up\u2026\n");
+  } catch {
+  }
+  killActiveAgents("SIGTERM");
+  try {
+    releaseOwnLocks();
+  } catch {
+  }
+  try {
+    removeActiveWorktreesSync();
+  } catch {
+  }
+  setTimeout(() => {
+    killActiveAgents("SIGKILL");
+    process.exit(code);
+  }, 1500);
+}
+function installSignalHandlers() {
+  process.on("SIGINT", () => requestShutdown(130));
+  process.on("SIGTERM", () => requestShutdown(143));
+}
+
+// src/commands/run.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/core/providers/model.ts
+var LATEST_OPUS = {
+  claude: "opus",
+  kiro: "claude-opus-4.8",
+  q: "opus"
+  // unused — the Q adapter inlines the skill and uses Q's default model
+};
+function resolveModel(model, provider) {
+  if (!model) return void 0;
+  return model === "opus" ? LATEST_OPUS[provider] : model;
+}
+
+// src/core/providers/claude.ts
+var CLAUDE_BIN = process.env.MRP_CLAUDE_BIN || "claude";
+function buildClaudeInvocation(skill, repo, opts) {
+  const args = ["-p", `/${skill} ${repo}`, "--dangerously-skip-permissions"];
+  if (opts.maxTurns) args.push("--max-turns", String(opts.maxTurns));
+  const model = resolveModel(opts.model, "claude");
+  if (model) args.push("--model", model);
+  if (opts.effort) args.push("--effort", opts.effort);
+  return { command: CLAUDE_BIN, args };
+}
+var ClaudeAdapter = class {
+  id = "claude";
+  buildInvocation(skill, repo, opts) {
+    return buildClaudeInvocation(skill, repo, opts);
+  }
+  invoke(skill, repo, opts) {
+    const { command, args } = buildClaudeInvocation(skill, repo, opts);
+    const env = { ...opts.env ?? process.env };
+    delete env.ANTHROPIC_API_KEY;
+    return runAgent({
+      command,
+      args,
+      env,
+      cwd: opts.cwd,
+      timeoutMs: opts.timeoutMs,
+      onStdout: opts.onStdout
+    });
+  }
+};
+
+// src/core/providers/kiro.ts
+import { execFileSync } from "child_process";
+var KIRO_BIN = process.env.MRP_KIRO_BIN || "kiro-cli";
+function promptFor(skill, repo) {
+  if (skill === PURGE_INSTALL_NAME) {
+    return `You ARE the misterpropre orchestrator's prepared invocation, operating in the "${repo}" repository's clone. The setup is done \u2014 do NOT ask for confirmation, do NOT clone, and do NOT propose alternatives. Run the "${skill}" skill's workflow NOW: process the open Renovate/Dependabot dependency-update PRs (merge what is safe, hand off the rest), then print the machine-readable MISTERPROPRE_RESULT_V1 and MISTERPROPRE_NOTIFY_V1 lines.`;
+  }
+  return `You ARE the misterpropre orchestrator's prepared invocation. The environment is ALREADY set up: your current working directory IS the isolated git worktree for the "${repo}" repository, already checked out on the security-fix branch (off dev). The setup is done \u2014 do NOT clone, do NOT create or switch worktrees/branches, do NOT ask for confirmation, and do NOT propose alternatives. Run the "${skill}" skill's workflow NOW: fix all open Dependabot security alerts, open or update the PR, then print the machine-readable MISTERPROPRE_RESULT_V1 line.`;
+}
+function buildKiroInvocation(skill, repo, _opts) {
+  return {
+    command: KIRO_BIN,
+    args: ["chat", "--no-interactive", "--trust-all-tools", promptFor(skill, repo)]
+  };
+}
+function isKiroAuthed(env = process.env) {
+  if (env.KIRO_API_KEY) return true;
+  try {
+    execFileSync(KIRO_BIN, ["whoami"], { env, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var KiroAdapter = class {
+  id = "kiro";
+  buildInvocation(skill, repo, opts) {
+    return buildKiroInvocation(skill, repo, opts);
+  }
+  invoke(skill, repo, opts) {
+    try {
+      execFileSync(KIRO_BIN, ["settings", "chat.defaultModel", "auto"], { env: opts.env, stdio: "ignore" });
+    } catch {
+    }
+    const { command, args } = buildKiroInvocation(skill, repo, opts);
+    return runAgent({
+      command,
+      args,
+      env: opts.env,
+      // SSO session (or KIRO_API_KEY, if set) authorizes the headless run
+      cwd: opts.cwd,
+      timeoutMs: opts.timeoutMs,
+      onStdout: opts.onStdout
+    });
+  }
+};
+
+// src/core/providers/q.ts
+var Q_BIN = process.env.MRP_Q_BIN || "q";
+var QAdapter = class {
+  constructor(vars) {
+    this.vars = vars;
+  }
+  vars;
+  id = "q";
+  buildInvocation(skill, repo, _opts) {
+    const body = renderBundledSkill(skill, this.vars) ?? `Run the "${skill}" dependency-automation skill.`;
+    const prompt = `${body}
+
+---
+You ARE the misterpropre orchestrator's prepared invocation for the "${repo}" repository \u2014 the environment is ALREADY set up (your current working directory is the prepared checkout). The setup is done: do NOT clone, do NOT create/switch worktrees or branches, do NOT ask for confirmation, and do NOT propose alternatives. Run the skill's workflow above NOW and print the framed MISTERPROPRE_RESULT_V1 (and MISTERPROPRE_NOTIFY_V1, if the skill defines it) line(s).`;
+    return { command: Q_BIN, args: ["chat", "--no-interactive", "--trust-all-tools", prompt] };
+  }
+  invoke(skill, repo, opts) {
+    const { command, args } = this.buildInvocation(skill, repo, opts);
+    return runAgent({
+      command,
+      args,
+      env: opts.env,
+      // auth via the `q login` session (Builder ID / IAM Identity Center) — no API key
+      cwd: opts.cwd,
+      timeoutMs: opts.timeoutMs,
+      onStdout: opts.onStdout
+    });
+  }
+};
+
+// src/core/registry.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function registryRoot() {
+  const base = process.env.XDG_CACHE_HOME?.trim() || join3(homedir3(), ".cache");
+  return join3(base, "misterpropre", "runs", "active");
+}
+function runFile(id) {
+  return join3(registryRoot(), `${id.replace(/[/\\]/g, "_")}.json`);
+}
+function registerRun(run) {
+  mkdirSync3(registryRoot(), { recursive: true });
+  writeFileSync2(runFile(run.id), JSON.stringify(run), "utf8");
+}
+function unregisterRun(id) {
+  rmSync3(runFile(id), { force: true });
+}
+
+// src/core/concurrency.ts
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Math.max(1, Math.min(limit, items.length));
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: workers }, worker));
+  return results;
+}
+
+// src/core/reconcile.ts
+async function snapshotFix(client, repo) {
+  const [alerts, prs] = await Promise.all([
+    client.listOpenAlerts(repo),
+    client.listAutomationPRs(repo)
+  ]);
+  const alertSeverities = {};
+  for (const a of alerts) alertSeverities[a.severity] = (alertSeverities[a.severity] ?? 0) + 1;
+  const newest = prs.slice().sort((a, b) => b.number - a.number)[0];
+  return {
+    openAlertCount: alerts.length,
+    alertSeverities,
+    automationPr: newest ? {
+      number: newest.number,
+      headSha: newest.headSha,
+      url: newest.url,
+      headRefName: newest.headRefName
+    } : null
+  };
+}
+async function localFixState(worktreePath2, baseRef) {
+  const status = await gitSafe(["-C", worktreePath2, "status", "--porcelain"]);
+  const dirty = status.ok && status.stdout.trim().length > 0;
+  const rev = await gitSafe(["-C", worktreePath2, "rev-list", "--count", `${baseRef}..HEAD`]);
+  const commitsAhead = rev.ok ? Number.parseInt(rev.stdout.trim(), 10) || 0 : 0;
+  return { commitsAhead, dirty };
+}
+function reconcileFix(input) {
+  const { process: proc, before, after, local, hint } = input;
+  const decide = () => {
+    if (proc.timedOut) return { kind: "FAIL", detail: "timed out" };
+    if (after.automationPr) {
+      const url = after.automationPr.url;
+      if (!before.automationPr) return { kind: "NEW_PR", prUrl: url };
+      if (before.automationPr.headSha !== after.automationPr.headSha)
+        return { kind: "UPDATED_PR", prUrl: url };
+      return { kind: "PR_UP_TO_DATE", prUrl: url };
+    }
+    if (local.commitsAhead > 0 || local.dirty)
+      return { kind: "LEFT_LOCAL", detail: `${local.commitsAhead} local commit(s)` };
+    if (proc.code === null) return { kind: "FAIL", detail: "the agent could not start" };
+    if (proc.code !== 0) return { kind: "FAIL", detail: "the agent exited with an error" };
+    if (before.openAlertCount === 0) return { kind: "NO_ALERTS" };
+    return { kind: "NO_FIXABLE" };
+  };
+  const d = decide();
+  const hintAgreed = hint?.kind ? hint.kind === d.kind : true;
+  return { ...d, hintAgreed };
+}
+
+// src/core/result.ts
+import { z } from "zod";
+var RESULT_PREFIX = "MISTERPROPRE_RESULT_V1";
+var CountsSchema = z.object({
+  // fix-phase counts
+  fixed: z.number().int().nonnegative(),
+  critical: z.number().int().nonnegative(),
+  high: z.number().int().nonnegative(),
+  medium: z.number().int().nonnegative(),
+  low: z.number().int().nonnegative(),
+  // purge-phase counts
+  merged: z.number().int().nonnegative(),
+  handedOff: z.number().int().nonnegative(),
+  stillOpen: z.number().int().nonnegative()
+}).partial();
+var ResultSchema = z.object({
+  v: z.literal(1),
+  phase: z.enum(["fix", "purge"]),
+  kind: z.string().min(1),
+  prUrl: z.string().url().optional(),
+  counts: CountsSchema.optional(),
+  message: z.string().optional()
+});
+function parseResults(stdout) {
+  let result = null;
+  let validCount = 0;
+  let malformedCount = 0;
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (!line.startsWith(RESULT_PREFIX)) continue;
+    const json = line.slice(RESULT_PREFIX.length).trim();
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      malformedCount++;
+      continue;
+    }
+    const validated = ResultSchema.safeParse(parsed);
+    if (validated.success) {
+      result = validated.data;
+      validCount++;
+    } else {
+      malformedCount++;
+    }
+  }
+  return { result, validCount, malformedCount };
+}
+
+// src/core/logs.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+function runLogsDir() {
+  return join4(configDir(), "logs");
+}
+var safe3 = (s) => s.replace(/[^a-zA-Z0-9._-]/g, "_");
+function writeRunLog(runId, repo, phase, content) {
+  const path = join4(runLogsDir(), `${safe3(runId)}-${safe3(repo)}-${safe3(phase)}.log`);
+  try {
+    mkdirSync4(dirname2(path), { recursive: true });
+    writeFileSync3(path, content, "utf8");
+  } catch {
+  }
+  return path;
+}
+
+// src/core/orchestrator.ts
+async function runFix(opts) {
+  const start = Date.now();
+  const skill = opts.skill ?? "security-dependabot-fix";
+  await gcWorktrees({ clonePath: opts.clonePath }).catch(() => {
+  });
+  await gitSafe(["-C", opts.clonePath, "fetch", "origin", "--prune"]);
+  const before = await snapshotFix(opts.github, opts.repo);
+  const wtPlanned = worktreePath(opts.repo, "fix", opts.runId);
+  let wt;
+  try {
+    if (before.automationPr?.headRefName) {
+      wt = await addWorktree({
+        clonePath: opts.clonePath,
+        path: wtPlanned,
+        ref: before.automationPr.headRefName,
+        force: true
+      });
+    } else {
+      wt = await addWorktree({
+        clonePath: opts.clonePath,
+        path: wtPlanned,
+        newBranch: `fix/dependabot-security-${opts.branchDate}`,
+        startPoint: opts.baseRef,
+        force: true
+      });
+    }
+    const run = await opts.provider.invoke(skill, opts.repo, {
+      cwd: wt.path,
+      model: opts.model,
+      maxTurns: opts.maxTurns,
+      timeoutMs: opts.timeoutMs,
+      env: opts.env,
+      onStdout: opts.onStdout
+    });
+    writeRunLog(opts.runId, opts.repo, "fix", run.stdout + (run.stderr ? `
+--- stderr ---
+${run.stderr}` : ""));
+    const hint = parseResults(run.stdout);
+    const after = await snapshotFix(opts.github, opts.repo);
+    const local = await localFixState(wt.path, opts.baseRef);
+    const outcome = reconcileFix({
+      process: { timedOut: run.timedOut, code: run.code },
+      before,
+      after,
+      local,
+      hint: hint.result ? { kind: hint.result.kind } : null
+    });
+    return {
+      repo: opts.repo,
+      outcome: { ...outcome, fixed: hint.result?.counts?.fixed },
+      durationMs: Date.now() - start,
+      resultHintMalformed: hint.malformedCount,
+      worktreePath: wt.path
+    };
+  } finally {
+    if (wt && !wt.external) await removeWorktree(opts.clonePath, wt.path).catch(() => {
+    });
+  }
+}
+
+// src/core/notify-events.ts
+import { z as z2 } from "zod";
+var NOTIFY_PREFIX = "MISTERPROPRE_NOTIFY_V1";
+var NotifyEventSchema = z2.object({
+  v: z2.literal(1),
+  repo: z2.string().optional(),
+  pr: z2.number().optional(),
+  url: z2.string().url().optional(),
+  outcome: z2.string().min(1),
+  package: z2.string().optional(),
+  bump: z2.string().optional(),
+  message: z2.string().min(1)
+});
+function parseNotifyEvents(stdout) {
+  const events = [];
+  let malformedCount = 0;
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith(NOTIFY_PREFIX)) continue;
+    const json = line.slice(NOTIFY_PREFIX.length).trim();
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      malformedCount++;
+      continue;
+    }
+    const v = NotifyEventSchema.safeParse(parsed);
+    if (v.success) events.push(v.data);
+    else malformedCount++;
+  }
+  return { events, malformedCount };
+}
+
+// src/core/reconcile-purge.ts
+var NEEDS_HUMAN_LABEL = "purge:needs-human";
+async function snapshotPurge(client, repo) {
+  const prs = await client.listBotPRs(repo);
+  return { open: prs.map((p) => ({ number: p.number, headRefName: p.headRefName, labels: p.labels })) };
+}
+async function resolveMergedNumbers(client, repo, beforeOpenNumbers, afterOpenNumbers) {
+  const disappeared = beforeOpenNumbers.filter((n) => !afterOpenNumbers.includes(n));
+  const states = await Promise.all(
+    disappeared.map(async (n) => ({ n, state: await client.pullState(repo, n) }))
+  );
+  return states.filter((s) => s.state === "MERGED").map((s) => s.n);
+}
+function reconcilePurge(input) {
+  const { process: proc, afterOpen, mergedNumbers, hint } = input;
+  const merged = mergedNumbers.length;
+  const handedOff = afterOpen.filter((p) => p.labels.includes(NEEDS_HUMAN_LABEL)).length;
+  const stillOpen = afterOpen.length - handedOff;
+  let kind = "DONE";
+  let detail;
+  if (proc.timedOut) {
+    kind = "FAIL";
+    detail = "timeout";
+  } else if (proc.code === null) {
+    kind = "FAIL";
+    detail = "spawn failed";
+  } else if (proc.code !== 0) {
+    kind = "FAIL";
+    detail = `rc=${proc.code}`;
+  }
+  const hintAgreed = hint ? (hint.merged ?? merged) === merged && (hint.handedOff ?? handedOff) === handedOff : true;
+  return { kind, merged, handedOff, stillOpen, detail, hintAgreed };
+}
+
+// src/core/orchestrator-purge.ts
+async function runPurge(opts) {
+  const start = Date.now();
+  const skill = opts.skill ?? "mrp-dependabot-purge";
+  await gcWorktrees({ clonePath: opts.clonePath }).catch(() => {
+  });
+  await gitSafe(["-C", opts.clonePath, "fetch", "origin", "--prune"]);
+  const before = await snapshotPurge(opts.github, opts.repo);
+  const run = await opts.provider.invoke(skill, opts.repo, {
+    cwd: opts.clonePath,
+    model: opts.model,
+    maxTurns: opts.maxTurns,
+    timeoutMs: opts.timeoutMs,
+    env: opts.env,
+    onStdout: opts.onStdout
+  });
+  writeRunLog(opts.runId, opts.repo, "purge", run.stdout + (run.stderr ? `
+--- stderr ---
+${run.stderr}` : ""));
+  const hint = parseResults(run.stdout);
+  const notify = parseNotifyEvents(run.stdout);
+  const after = await snapshotPurge(opts.github, opts.repo);
+  const mergedNumbers = await resolveMergedNumbers(
+    opts.github,
+    opts.repo,
+    before.open.map((p) => p.number),
+    after.open.map((p) => p.number)
+  );
+  const outcome = reconcilePurge({
+    process: { timedOut: run.timedOut, code: run.code },
+    afterOpen: after.open,
+    mergedNumbers,
+    hint: hint.result?.counts ? { merged: hint.result.counts.merged, handedOff: hint.result.counts.handedOff } : null
+  });
+  return {
+    repo: opts.repo,
+    outcome,
+    notifyEvents: notify.events,
+    durationMs: Date.now() - start,
+    resultHintMalformed: hint.malformedCount
+  };
+}
+
+// src/core/orchestrator-multi.ts
+async function runRepos(opts) {
+  registerRun({
+    id: opts.runId,
+    pid: process.pid,
+    repos: opts.repos,
+    phase: opts.phases.join("+"),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  try {
+    return await mapLimit(opts.repos, opts.maxParallel, (repo) => processRepo(repo, opts));
+  } finally {
+    unregisterRun(opts.runId);
+  }
+}
+async function processRepo(repo, opts) {
+  const lock = acquireRepoLock(repo);
+  if (!lock.acquired) {
+    opts.onLog?.(`skip ${repo}: a run is already operating on it (pid ${lock.heldByPid})`);
+    opts.onProgress?.({ repo, state: "skip", detail: `held by pid ${lock.heldByPid}` });
+    return { repo, status: "skipped-busy", outcomes: {}, notifyEvents: [], heldByPid: lock.heldByPid };
+  }
+  const outcomes = {};
+  const notifyEvents = [];
+  let failedPhase;
+  try {
+    const clonePath = await opts.resolveClone(repo);
+    for (const phase of opts.phases) {
+      failedPhase = phase;
+      opts.onProgress?.({ repo, phase, state: "start" });
+      if (phase === "purge") {
+        opts.onLog?.(`purge ${repo} \u2026`);
+        const r = await runPurge({
+          repo,
+          clonePath,
+          runId: opts.runId,
+          provider: opts.provider,
+          github: opts.github,
+          skill: PURGE_INSTALL_NAME,
+          model: opts.model,
+          maxTurns: opts.maxTurns?.purge,
+          timeoutMs: opts.timeoutMs?.purge,
+          env: opts.env
+        });
+        outcomes.purge = r.outcome;
+        notifyEvents.push(...r.notifyEvents);
+        opts.onLog?.(`purge ${repo}: ${r.outcome.kind} (merged ${r.outcome.merged}, handed off ${r.outcome.handedOff})`);
+        opts.onProgress?.({ repo, phase, state: "phase-done", detail: r.outcome.kind });
+      } else {
+        opts.onLog?.(`fix ${repo} \u2026`);
+        const r = await runFix({
+          repo,
+          skill: FIX_INSTALL_NAME,
+          clonePath,
+          baseRef: opts.baseRef,
+          runId: opts.runId,
+          branchDate: opts.branchDate,
+          provider: opts.provider,
+          github: opts.github,
+          model: opts.model,
+          maxTurns: opts.maxTurns?.fix,
+          timeoutMs: opts.timeoutMs?.fix,
+          env: opts.env
+        });
+        outcomes.fix = r.outcome;
+        opts.onLog?.(`fix ${repo}: ${r.outcome.kind}`);
+        opts.onProgress?.({ repo, phase, state: "phase-done", detail: r.outcome.kind });
+      }
+    }
+    return { repo, status: "done", outcomes, notifyEvents };
+  } catch (e) {
+    const error = e?.message || String(e);
+    opts.onProgress?.({ repo, state: "error", detail: error });
+    return { repo, status: "error", outcomes, notifyEvents, error, errorPhase: failedPhase };
+  } finally {
+    lock.handle.release();
+  }
+}
+
+// src/ui/run-progress.tsx
+import { createElement } from "react";
+import { Box, Text, render, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function glyph(state, spin, L) {
+  switch (state) {
+    case "purging":
+      return { icon: spin, color: theme.primary, label: L.purging };
+    case "fixing":
+      return { icon: spin, color: theme.accent, label: L.fixing };
+    case "done":
+      return { icon: "\u2713", color: theme.success, label: L.done };
+    case "failed":
+      return { icon: "\u2717", color: theme.error, label: L.failed };
+    case "skipped":
+      return { icon: "\u25D1", color: theme.warn, label: L.skipped };
+    default:
+      return { icon: "\u25CC", color: theme.dim, label: L.queued };
+  }
+}
+function RunProgress({
+  rows,
+  spinnerTick = 0,
+  title = "Running",
+  lang = "en"
+}) {
+  const labels = appT(lang).grid;
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") requestShutdown(130);
+  });
+  const spin = SPINNER[spinnerTick % SPINNER.length];
+  const settled = rows.filter((r) => r.state === "done" || r.state === "failed" || r.state === "skipped").length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Banner, { lang }),
+    /* @__PURE__ */ jsx(Panel, { title: `\u25B6 ${title} \xB7 ${settled}/${rows.length}`, color: theme.primary, children: rows.map((r) => {
+      const g = glyph(r.state, spin, labels);
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: g.color, children: g.icon }),
+        " ",
+        r.repo.padEnd(38),
+        " ",
+        /* @__PURE__ */ jsx(Text, { color: theme.dim, children: r.detail ? `${g.label} \xB7 ${r.detail}` : g.label })
+      ] }, r.repo);
+    }) })
+  ] });
+}
+async function runWithProgress(opts, lang = "en") {
+  const live = new Map(opts.repos.map((r) => [r, { repo: r, state: "queued" }]));
+  const lastPhase = opts.phases[opts.phases.length - 1];
+  const title = opts.phases.map((p) => phaseLabel(p, lang)).join(" \u2192 ");
+  let tick = 0;
+  const view = () => createElement(RunProgress, { rows: [...live.values()], spinnerTick: tick, title, lang });
+  const inst = render(view(), { exitOnCtrlC: false });
+  const draw = () => inst.rerender(view());
+  const spinner = setInterval(() => {
+    tick++;
+    draw();
+  }, 120);
+  const onProgress = (e) => {
+    const cur = live.get(e.repo) ?? { repo: e.repo, state: "queued" };
+    const next = { ...cur };
+    if (e.state === "skip") next.state = "skipped";
+    else if (e.state === "error") {
+      next.state = "failed";
+      next.detail = e.detail;
+    } else if (e.state === "start") {
+      next.state = e.phase === "purge" ? "purging" : "fixing";
+    } else if (e.state === "phase-done") {
+      next.detail = e.detail;
+      if (e.phase === lastPhase) next.state = "done";
+    }
+    live.set(e.repo, next);
+    draw();
+  };
+  try {
+    return await runRepos({ ...opts, onProgress });
+  } finally {
+    clearInterval(spinner);
+    draw();
+    inst.unmount();
+  }
+}
+
+// src/core/secrets.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+function secretsPath() {
+  return join5(configDir(), "secrets.json");
+}
+var KNOWN_SECRET_KEYS = [
+  "TELEGRAM_BOT_TOKEN",
+  "TELEGRAM_CHAT_ID",
+  "SLACK_WEBHOOK_URL",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "KIRO_API_KEY",
+  "GH_TOKEN"
+];
+function read() {
+  const p = secretsPath();
+  if (!existsSync3(p)) return {};
+  try {
+    const v = JSON.parse(readFileSync3(p, "utf8"));
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+function write(map) {
+  mkdirSync5(configDir(), { recursive: true });
+  const p = secretsPath();
+  writeFileSync4(p, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+  try {
+    chmodSync(p, 384);
+  } catch {
+  }
+}
+function getSecret(key) {
+  return read()[key];
+}
+function setSecret(key, value) {
+  const m = read();
+  m[key] = value;
+  write(m);
+}
+function deleteSecret(key) {
+  const m = read();
+  delete m[key];
+  write(m);
+}
+function listSecretKeys() {
+  return Object.keys(read());
+}
+function secretsEnv() {
+  const m = read();
+  const env = {};
+  for (const key of KNOWN_SECRET_KEYS) {
+    if (m[key]) env[key] = m[key];
+  }
+  return env;
+}
+
+// src/commands/run.ts
+var pexec2 = promisify2(execFile2);
+function expandTilde(p) {
+  return p === "~" || p.startsWith("~/") ? join6(homedir4(), p.slice(1)) : p;
+}
+function parsePhases(phase) {
+  if (phase === "fix") return ["fix"];
+  if (phase === "purge") return ["purge"];
+  if (phase === "both") return ["purge", "fix"];
+  return null;
+}
+async function runCommand(repos, options) {
+  const cfg = readConfig();
+  if (!cfg) {
+    console.error("Not configured \u2014 run `misterpropre setup` first.");
+    return 1;
+  }
+  const phases = parsePhases(options.phase);
+  if (!phases) {
+    console.error(`Invalid --phase "${options.phase}" (expected purge | fix | both).`);
+    return 1;
+  }
+  const targetRepos = options.all ? cfg.repos : repos;
+  if (targetRepos.length === 0) {
+    console.error(
+      options.all ? "No repos configured (config.repos is empty)." : "Specify one or more repos, or use --all."
+    );
+    return 1;
+  }
+  const providerId = options.provider ?? cfg.provider.default;
+  const baseDir = expandTilde(cfg.repoBaseDir);
+  const skillVars = { ORG: cfg.org, REPO_BASE: baseDir, PKG_SCOPE: cfg.packageScope, BASE_BRANCH: cfg.baseBranch };
+  const env = { ...process.env, ...secretsEnv() };
+  if (providerId === "kiro" && !isKiroAuthed(env)) {
+    console.error(
+      "Kiro is not authenticated. Run `kiro-cli login` once (AWS Builder ID / IAM Identity Center), or set KIRO_API_KEY."
+    );
+    return 1;
+  }
+  const provider = providerId === "kiro" ? new KiroAdapter() : providerId === "q" ? new QAdapter(skillVars) : new ClaudeAdapter();
+  const resolveClone = async (repo) => {
+    const clonePath = join6(baseDir, repo);
+    if (!existsSync4(join6(clonePath, ".git"))) {
+      console.log(`Cloning ${cfg.org}/${repo} \u2192 ${clonePath} \u2026`);
+      await pexec2("gh", ["repo", "clone", `${cfg.org}/${repo}`, clonePath]);
+    }
+    return clonePath;
+  };
+  const trigger = options.scheduled ? "scheduled" : "manual";
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+  if (!process.stdout.isTTY) {
+    console.log(
+      `\u25B6 ${phases.map((p) => phaseLabel(p, cfg.lang)).join(" \u2192 ")} \xB7 ${cfg.org} \xB7 ${targetRepos.length} repo(s) \xB7 provider=${providerId}
+`
+    );
+  }
+  const baseOpts = {
+    repos: targetRepos,
+    phases,
+    provider,
+    github: new GhCli(cfg.org),
+    resolveClone,
+    baseRef: `origin/${cfg.baseBranch}`,
+    branchDate: startedAt.slice(0, 10),
+    runId,
+    trigger,
+    maxParallel: cfg.execution.maxParallel,
+    model: cfg.execution.model || void 0,
+    maxTurns: cfg.execution.maxTurns,
+    timeoutMs: {
+      fix: cfg.execution.timeouts.fix * 1e3,
+      purge: cfg.execution.timeouts.purge * 1e3
+    },
+    env
+  };
+  const results = process.stdout.isTTY ? await runWithProgress(baseOpts, cfg.lang) : await runRepos({ ...baseOpts, onLog: (msg) => console.log(`  ${msg}`) });
+  const repoOutcomes = [];
+  for (const r of results) {
+    if (r.status === "skipped-busy") {
+      repoOutcomes.push({ repo: r.repo, phase: phases[0], kind: "SKIPPED_BUSY", detail: `held by pid ${r.heldByPid}` });
+      continue;
+    }
+    if (r.status === "error") {
+      repoOutcomes.push({ repo: r.repo, phase: r.errorPhase ?? phases[0], kind: "ERROR", detail: r.error });
+      continue;
+    }
+    if (r.outcomes.purge) {
+      const p = r.outcomes.purge;
+      repoOutcomes.push({
+        repo: r.repo,
+        phase: "purge",
+        kind: p.kind,
+        detail: `merged ${p.merged}, handed off ${p.handedOff}, open ${p.stillOpen}`,
+        merged: p.merged,
+        handedOff: p.handedOff,
+        stillOpen: p.stillOpen
+      });
+    }
+    if (r.outcomes.fix) {
+      const f = r.outcomes.fix;
+      repoOutcomes.push({ repo: r.repo, phase: "fix", kind: f.kind, prUrl: f.prUrl, detail: f.detail, hintAgreed: f.hintAgreed, fixed: f.fixed });
+    }
+  }
+  const record = {
+    id: runId,
+    startedAt,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    trigger,
+    provider: providerId,
+    phases,
+    repos: repoOutcomes
+  };
+  appendRun(record);
+  const t = appT(cfg.lang);
+  console.log("\n\u2500\u2500 Summary \u2500\u2500");
+  for (const o of repoOutcomes) {
+    const line = summarizeOutcome(o, t.status);
+    const pr = o.prUrl ? ` \u2192 ${o.prUrl}` : "";
+    console.log(`  ${line.ok ? "\u2713" : "\u2717"} ${o.repo} \xB7 ${phaseLabel(o.phase, cfg.lang)}: ${line.status}${pr}`);
+  }
+  const notifyEvents = results.flatMap((r) => r.notifyEvents);
+  if (notifyEvents.length > 0) {
+    console.log(`
+${t.handoffsHeader(notifyEvents.length)}`);
+    for (const e of notifyEvents) console.log(`  \u2022 #${e.pr ?? "?"} ${e.outcome} \u2014 ${e.message}`);
+  }
+  const failed = results.some(
+    (r) => r.status === "error" || r.outcomes.fix?.kind === "FAIL" || r.outcomes.purge?.kind === "FAIL"
+  );
+  if (failed) {
+    console.log(`
+\u2139 Agent logs: ${runLogsDir()}  (the .log files there show exactly what the agent did)`);
+  }
+  return failed ? 1 : 0;
+}
+
+// src/commands/schedule.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+
+// src/core/scheduler.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir5, platform } from "os";
+import { dirname as dirname3, join as join7 } from "path";
+var SCHEDULE_LABEL = "com.misterpropre.daily";
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildLaunchdPlist(s) {
+  const argv = [s.nodePath, s.cliPath, ...s.args].map((a) => `    <string>${escapeXml(a)}</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>
+  <key>Label</key>
+  <string>${SCHEDULE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argv}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(s.path)}</string>
+  </dict>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${s.hour}</integer>
+    <key>Minute</key>
+    <integer>${s.minute}</integer>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(s.workingDir)}</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(s.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(s.logPath)}</string>
+  <key>RunAtLoad</key>
+  <false/>
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+function isMac() {
+  return platform() === "darwin";
+}
+function launchAgentsDir() {
+  return join7(homedir5(), "Library", "LaunchAgents");
+}
+function plistPath() {
+  return join7(launchAgentsDir(), `${SCHEDULE_LABEL}.plist`);
+}
+function schedulePath(nodePath) {
+  const dirs = [
+    dirname3(nodePath),
+    join7(homedir5(), ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  return [...new Set(dirs)].join(":");
+}
+function installSchedule(spec) {
+  if (!isMac()) {
+    return { ok: false, message: `native scheduling is only wired for macOS so far (got ${platform()})` };
+  }
+  mkdirSync6(launchAgentsDir(), { recursive: true });
+  const p = plistPath();
+  try {
+    execFileSync2("launchctl", ["unload", p], { stdio: "ignore" });
+  } catch {
+  }
+  writeFileSync5(p, buildLaunchdPlist(spec), "utf8");
+  try {
+    execFileSync2("launchctl", ["load", p], { stdio: "ignore" });
+    return { ok: true, message: `scheduled daily at ${pad(spec.hour)}:${pad(spec.minute)} (launchd)`, path: p };
+  } catch (e) {
+    return { ok: false, message: `wrote ${p} but \`launchctl load\` failed: ${e.message}`, path: p };
+  }
+}
+function uninstallSchedule() {
+  if (!isMac()) return { ok: false, message: `native scheduling is only wired for macOS so far (got ${platform()})` };
+  const p = plistPath();
+  if (!existsSync5(p)) return { ok: true, message: "no schedule was installed" };
+  try {
+    execFileSync2("launchctl", ["unload", p], { stdio: "ignore" });
+  } catch {
+  }
+  rmSync4(p, { force: true });
+  return { ok: true, message: "schedule removed" };
+}
+function scheduleInstalled() {
+  return existsSync5(plistPath());
+}
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+
+// src/commands/schedule.ts
+function resolveCliPath() {
+  const entry = process.argv[1] ?? "";
+  try {
+    return realpathSync2(entry);
+  } catch {
+    return entry;
+  }
+}
+function applySchedule(cfg, input) {
+  const time = input.time;
+  const m = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(time);
+  if (!m) return { ok: false, message: `Invalid time "${time}" (expected HH:MM, 24h).` };
+  const phase = input.phase ?? "both";
+  if (!["fix", "purge", "both"].includes(phase)) {
+    return { ok: false, message: `Invalid phase "${phase}" (expected fix | purge | both).` };
+  }
+  if (cfg.repos.length === 0) {
+    return { ok: false, message: "No repos configured (config.repos is empty) \u2014 nothing to schedule." };
+  }
+  const chosen = (input.repos ?? []).filter((r) => cfg.repos.includes(r));
+  const runAll = chosen.length === 0 || chosen.length === cfg.repos.length;
+  const runArgs = runAll ? ["run", "--all"] : ["run", ...chosen];
+  const nodePath = process.execPath;
+  const spec = {
+    hour: Number(m[1]),
+    minute: Number(m[2]),
+    nodePath,
+    cliPath: resolveCliPath(),
+    args: [...runArgs, "--provider", cfg.provider.scheduled, "--phase", phase, "--scheduled"],
+    path: schedulePath(nodePath),
+    logPath: join8(configDir(), "schedule.log"),
+    workingDir: homedir6()
+  };
+  const res = installSchedule(spec);
+  if (!res.ok) return { ok: false, message: res.message };
+  const repos = runAll ? [] : chosen;
+  writeConfig({ ...cfg, schedule: { enabled: true, time, phase, repos } });
+  const count = runAll ? cfg.repos.length : chosen.length;
+  return { ok: true, message: res.message, detail: `${cfg.provider.scheduled} \xB7 phase=${phase} \xB7 ${count} repo(s)` };
+}
+function applyUnschedule() {
+  const res = uninstallSchedule();
+  const cfg = readConfig();
+  if (cfg) writeConfig({ ...cfg, schedule: { ...cfg.schedule, enabled: false } });
+  return { ok: res.ok, message: res.message };
+}
+function runScheduleSet(opts) {
+  const cfg = readConfig();
+  if (!cfg) {
+    console.error("Not configured \u2014 run `misterpropre setup` first.");
+    return 1;
+  }
+  const res = applySchedule(cfg, { time: opts.time ?? cfg.schedule.time, phase: opts.phase });
+  if (!res.ok) {
+    console.error(res.message);
+    return 1;
+  }
+  console.log(`\u2713 ${res.message}`);
+  if (res.detail) console.log(`  ${res.detail}`);
+  console.log(`  plist: ${plistPath()}`);
+  console.log(`  logs:  ${join8(configDir(), "schedule.log")}`);
+  return 0;
+}
+function runScheduleStatus() {
+  const cfg = readConfig();
+  const installed = scheduleInstalled();
+  console.log(`Schedule: ${cfg?.schedule.enabled ? `enabled at ${cfg.schedule.time}` : "disabled"}`);
+  console.log(`launchd job: ${installed ? `installed (${plistPath()})` : "not installed"}`);
+  if (cfg) {
+    const count = cfg.schedule.repos.length || cfg.repos.length;
+    console.log(`Scheduled run: ${cfg.provider.scheduled} \xB7 phase=${cfg.schedule.phase} \xB7 ${count} repo(s)`);
+  }
+  return 0;
+}
+function runScheduleClear() {
+  const res = applyUnschedule();
+  console.log(res.ok ? `\u2713 ${res.message}` : res.message);
+  return res.ok ? 0 : 1;
+}
+
+export {
+  KNOWN_SECRET_KEYS,
+  getSecret,
+  setSecret,
+  deleteSecret,
+  listSecretKeys,
+  installSignalHandlers,
+  runCommand,
+  applySchedule,
+  applyUnschedule,
+  runScheduleSet,
+  runScheduleStatus,
+  runScheduleClear
+};
+//# sourceMappingURL=chunk-JCB4UDCP.js.map