opencode-jobs 0.2.0 → 1.1.0

package/dist/index.js

@@ -3,16 +3,8 @@
 import {
   tool
 } from "@opencode-ai/plugin";
-import {
-  closeSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  openSync,
-  readFileSync as readFileSync4,
-  rmSync as rmSync2
-} from "fs";
-import { spawn } from "child_process";
-import path6 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, rmSync as rmSync2 } from "fs";
+import path7 from "path";
 
 // src/cron.ts
 var DOW_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
@@ -149,31 +141,31 @@ function stateRoot() {
   return process.env.XDG_STATE_HOME ?? path.join(homedir(), ".local", "state");
 }
 function worktreesDirectory(scopeId) {
-  return path.join(stateRoot(), "opencode", "scheduler", "worktrees", scopeId);
+  return path.join(stateRoot(), "opencode", "jobs", "worktrees", scopeId);
 }
-function schedulerDirectory() {
-  return path.join(configRoot(), "opencode", "scheduler");
+function jobsStateDirectory() {
+  return path.join(configRoot(), "opencode", "jobs");
 }
 function registryPath() {
-  return path.join(schedulerDirectory(), "registry.json");
+  return path.join(jobsStateDirectory(), "registry.json");
 }
 function scopeDirectory(scopeId) {
-  return path.join(schedulerDirectory(), "scopes", scopeId);
+  return path.join(jobsStateDirectory(), "scopes", scopeId);
 }
 function runsDirectory(scopeId) {
-  return path.join(schedulerDirectory(), "runs", scopeId);
+  return path.join(jobsStateDirectory(), "runs", scopeId);
 }
 function runsFile(scopeId, slug) {
   return path.join(runsDirectory(scopeId), `${slug}.jsonl`);
 }
 function sessionStateDirectory(scopeId) {
-  return path.join(schedulerDirectory(), "sessions", scopeId);
+  return path.join(jobsStateDirectory(), "sessions", scopeId);
 }
 function sessionStateFile(scopeId, slug) {
   return path.join(sessionStateDirectory(scopeId), `${slug}.txt`);
 }
 function logDirectory(scopeId) {
-  return path.join(configRoot(), "opencode", "logs", "scheduler", scopeId);
+  return path.join(configRoot(), "opencode", "logs", "jobs", scopeId);
 }
 function logFile(scopeId, slug) {
   return path.join(logDirectory(scopeId), `${slug}.log`);
@@ -182,7 +174,7 @@ function systemdUserDirectory() {
   return path.join(configRoot(), "systemd", "user");
 }
 function jobsDirectory(workdir) {
-  return path.join(workdir, ".opencode", "scheduler", "jobs");
+  return path.join(workdir, ".opencode", "jobs");
 }
 function unitBase(scopeId, slug) {
   return `opencode-sched-${scopeId}-${slug}`;
@@ -447,19 +439,22 @@ var registryFileSchema = z2.object({
   version: z2.literal(1),
   projects: z2.record(z2.string(), z2.unknown())
 });
+function readRegistryFile(file) {
+  const parsed = JSON.parse(readFileSync2(file, "utf8"));
+  const result = registryFileSchema.safeParse(parsed);
+  if (!result.success)
+    throw new Error(`Invalid job registry: ${file}`);
+  const projects = {};
+  for (const [key, value] of Object.entries(result.data.projects)) {
+    const entry = registryEntrySchema.safeParse(value);
+    if (entry.success)
+      projects[key] = entry.data;
+  }
+  return { version: 1, projects };
+}
 function loadRegistry() {
   try {
-    const parsed = JSON.parse(readFileSync2(registryPath(), "utf8"));
-    const result = registryFileSchema.safeParse(parsed);
-    if (!result.success)
-      return { version: 1, projects: {} };
-    const projects = {};
-    for (const [key, value] of Object.entries(result.data.projects)) {
-      const entry = registryEntrySchema.safeParse(value);
-      if (entry.success)
-        projects[key] = entry.data;
-    }
-    return { version: 1, projects };
+    return readRegistryFile(registryPath());
   } catch {
     return { version: 1, projects: {} };
   }
@@ -548,7 +543,7 @@ import { spawnSync } from "child_process";
 import path4 from "path";
 import { homedir as homedir2 } from "os";
 function findOpencode() {
-  const override = process.env.OPENCODE_SCHEDULER_OPENCODE_PATH;
+  const override = process.env.OPENCODE_JOBS_OPENCODE_PATH ?? process.env.OPENCODE_SCHEDULER_OPENCODE_PATH;
   if (override !== undefined && override.length > 0)
     return override;
   const which = spawnSync("sh", ["-c", "command -v opencode"], {
@@ -581,24 +576,24 @@ function guardScriptLines(guard) {
   ];
 }
 function worktreeDefaultRoot(scopeId) {
-  return "${XDG_STATE_HOME:-$HOME/.local/state}/opencode/scheduler/worktrees/" + scopeId;
+  return "${XDG_STATE_HOME:-$HOME/.local/state}/opencode/jobs/worktrees/" + scopeId;
 }
 function worktreePrologueLines(job, scopeId) {
   const base = job.worktree?.base;
   return [
     "wt_enabled=1",
     'orig_pwd="$(pwd)"',
-    'lock_dir="$config_root/opencode/scheduler/locks/$scope"',
+    'lock_dir="$config_root/opencode/jobs/locks/$scope"',
     'mkdir -p "$lock_dir"',
     'exec 9>"$lock_dir/$slug.lock"',
     "if ! flock -n 9; then",
-    '  echo "scheduler: another run of $slug is already active, skipping"',
+    '  echo "opencode-jobs: another run of $slug is already active, skipping"',
     "  finish skipped 0",
     "  exit 0",
     "fi",
     base === undefined ? `wt_root="${worktreeDefaultRoot(scopeId)}"` : `wt_root=${shQuote(base)}`,
     'if ! mkdir -p "$wt_root"; then',
-    '  echo "scheduler: cannot create worktree base $wt_root"',
+    '  echo "opencode-jobs: cannot create worktree base $wt_root"',
     "  finish failed 1",
     "  exit 1",
     "fi",
@@ -613,31 +608,31 @@ function worktreePrologueLines(job, scopeId) {
     "    wt_stale_saved=1",
     '    git -C "$wt_path" add -A >/dev/null 2>&1 || wt_stale_saved=0',
     '    if [ "$wt_stale_saved" -eq 1 ] && ! git -C "$wt_path" diff --cached --quiet >/dev/null 2>&1; then',
-    '      git -C "$wt_path" -c user.name=opencode-jobs -c user.email=scheduler@opencode.invalid commit --no-gpg-sign -m "opencode-jobs: $slug recovery (stale worktree)" >/dev/null 2>&1 || wt_stale_saved=0',
+    '      git -C "$wt_path" -c user.name=opencode-jobs -c user.email=jobs@opencode.invalid commit --no-gpg-sign -m "opencode-jobs: $slug recovery (stale worktree)" >/dev/null 2>&1 || wt_stale_saved=0',
     "    fi",
     '    if [ "$wt_stale_saved" -eq 1 ]; then',
     '      git worktree remove --force "$wt_path" >/dev/null 2>&1',
     '      rm -rf "$wt_path"',
     "    else",
-    '      echo "scheduler: cannot save changes in stale worktree $wt_path; keeping it and aborting this run"',
+    '      echo "opencode-jobs: cannot save changes in stale worktree $wt_path; keeping it and aborting this run"',
     '      wt_branch=""',
     "      finish failed 1",
     "      exit 1",
     "    fi",
     "  else",
-    '    echo "scheduler: removing unexpected directory at $wt_path"',
+    '    echo "opencode-jobs: removing unexpected directory at $wt_path"',
     '    rm -rf "$wt_path"',
     "  fi",
     "  git worktree prune >/dev/null 2>&1",
     "fi",
     'if ! git worktree add -b "$wt_branch" "$wt_path" "$wt_base_ref"; then',
-    '  echo "scheduler: failed to create worktree $wt_path (worktree jobs require a git repository)"',
+    '  echo "opencode-jobs: failed to create worktree $wt_path (worktree jobs require a git repository)"',
     '  wt_branch=""',
     "  finish failed 1",
     "  exit 1",
     "fi",
     'if [ -n "$wt_sub" ] && [ ! -d "$wt_path/$wt_sub" ]; then',
-    '  echo "scheduler: project subdirectory $wt_sub is missing from the worktree at $wt_base_ref"',
+    '  echo "opencode-jobs: project subdirectory $wt_sub is missing from the worktree at $wt_base_ref"',
     '  git -C "$orig_pwd" worktree remove --force "$wt_path" >/dev/null 2>&1',
     '  rm -rf "$wt_path"',
     '  wt_branch=""',
@@ -659,10 +654,10 @@ function worktreeEpilogueLines(options) {
     '  git -C "$wt_path" add -A >/dev/null 2>&1',
     "  wt_keep=0",
     '  if ! git -C "$wt_path" diff --cached --quiet >/dev/null 2>&1; then',
-    '    if git -C "$wt_path" -c user.name=opencode-jobs -c user.email=scheduler@opencode.invalid commit --no-gpg-sign -m "$wt_msg" >/dev/null 2>&1; then',
-    '      echo "scheduler: committed worktree changes to branch $wt_branch"',
+    '    if git -C "$wt_path" -c user.name=opencode-jobs -c user.email=jobs@opencode.invalid commit --no-gpg-sign -m "$wt_msg" >/dev/null 2>&1; then',
+    '      echo "opencode-jobs: committed worktree changes to branch $wt_branch"',
     "    else",
-    '      echo "scheduler: worktree commit failed, keeping worktree at $wt_path"',
+    '      echo "opencode-jobs: worktree commit failed, keeping worktree at $wt_path"',
     "      wt_keep=1",
     "    fi",
     "  fi",
@@ -688,7 +683,7 @@ function compactSessionLines() {
     "compact_session() {",
     '  csid="$1"',
     "  if ! command -v curl >/dev/null 2>&1; then",
-    '    echo "scheduler: curl not available, skipping compaction"',
+    '    echo "opencode-jobs: curl not available, skipping compaction"',
     "    return 0",
     "  fi",
     '  serve_out="$(mktemp)"',
@@ -705,7 +700,7 @@ function compactSessionLines() {
     "    tries=$((tries + 1))",
     "  done",
     '  if [ -z "$serve_port" ]; then',
-    '    echo "scheduler: compaction server failed to start"',
+    '    echo "opencode-jobs: compaction server failed to start"',
     '    sed -n "1,10p" "$serve_err" >&2',
     '    kill "$serve_pid" 2>/dev/null',
     '    wait "$serve_pid" 2>/dev/null',
@@ -724,7 +719,7 @@ function compactSessionLines() {
     "    tries=$((tries + 1))",
     "  done",
     '  if [ "$healthy" -ne 1 ]; then',
-    '    echo "scheduler: compaction server never became healthy"',
+    '    echo "opencode-jobs: compaction server never became healthy"',
     '    kill "$serve_pid" 2>/dev/null',
     '    wait "$serve_pid" 2>/dev/null',
     '    rm -f "$serve_out" "$serve_err"',
@@ -744,22 +739,22 @@ function compactSessionLines() {
     String.raw`    cs_model="$(printf '%s\n' "$defaults" | sed -n '${DEFAULT_MODEL_SED}' | head -n 1)"`,
     "  fi",
     '  if [ -z "$cs_provider" ] || [ -z "$cs_model" ]; then',
-    '    echo "scheduler: could not resolve a model for compaction, skipping"',
+    '    echo "opencode-jobs: could not resolve a model for compaction, skipping"',
     '    kill "$serve_pid" 2>/dev/null',
     '    wait "$serve_pid" 2>/dev/null',
     '    rm -f "$serve_out" "$serve_err"',
     "    return 0",
     "  fi",
-    '  echo "scheduler: compacting session $csid (mode: $session_mode)"',
+    '  echo "opencode-jobs: compacting session $csid (mode: $session_mode)"',
     String.raw`  result="$(curl -s --max-time 900 -X POST -H 'content-type: application/json' -d "{\"providerID\":\"$cs_provider\",\"modelID\":\"$cs_model\"}" "http://127.0.0.1:$serve_port/session/$csid/summarize")"`,
     '  if [ "$result" != "true" ]; then',
-    '    echo "scheduler: compaction failed: $result"',
+    '    echo "opencode-jobs: compaction failed: $result"',
     "  fi",
     '  if [ "$result" = "true" ] && [ "$oc_keep_last" -eq 1 ] && [ -n "$cs_text" ]; then',
     String.raw`    inject_body="{\"noReply\":true,\"parts\":[{\"type\":\"text\",\"text\":\"$cs_text\"}]}"`,
     `    http="$(curl -s -o /dev/null -w '%{http_code}' --max-time 120 -X POST -H 'content-type: application/json' -d "$inject_body" "http://127.0.0.1:$serve_port/session/$csid/message")"`,
     '    if [ "$http" != "200" ]; then',
-    '      echo "scheduler: keeping last result failed (HTTP $http)"',
+    '      echo "opencode-jobs: keeping last result failed (HTTP $http)"',
     "    fi",
     "  fi",
     '  kill "$serve_pid" 2>/dev/null',
@@ -780,25 +775,25 @@ function runScriptContent(job, scopeId, opencodeBin) {
     `scope=${shQuote(scopeId)}`,
     `oc_bin=${shQuote(opencodeBin)}`,
     'config_root="${XDG_CONFIG_HOME:-$HOME/.config}"',
-    'runs="$config_root/opencode/scheduler/runs/$scope"',
+    'runs="$config_root/opencode/jobs/runs/$scope"',
     'mkdir -p "$runs"',
     'record_file="$runs/$slug.jsonl"',
     ...isTracked ? [
-      'sessions="$config_root/opencode/scheduler/sessions/$scope"',
+      'sessions="$config_root/opencode/jobs/sessions/$scope"',
       'mkdir -p "$sessions"',
       'state_file="$sessions/$slug.txt"',
       `session_mode=${shQuote(mode)}`,
       'prev_session=""',
       'if [ -f "$state_file" ]; then prev_session=$(cat "$state_file"); fi'
     ] : [],
-    'started_by="${OPENCODE_SCHEDULER_STARTED_BY:-scheduled}"',
+    'started_by="${OPENCODE_JOBS_STARTED_BY:-scheduled}"',
     'run_id="$(date +%s%N)-$$"',
     "started=$(date +%s)",
     'new_session=""',
     'wt_branch=""',
     'wt_commit=""',
     `export OPENCODE_PERMISSION='{"question":"deny"}'`,
-    'export OPENCODE_SCHEDULER_RUN_ID="$run_id"',
+    'export OPENCODE_JOBS_RUN_ID="$run_id"',
     "finish() {",
     '  status="$1"',
     '  code="$2"',
@@ -839,7 +834,7 @@ function runScriptContent(job, scopeId, opencodeBin) {
       'cat "$json_out"',
       ...extractSessionIdLines("new_session"),
       'if [ "$code" -ne 0 ] && [ -n "$prev_session" ] && [ -z "$new_session" ] && grep -qi "session not found" "$json_out"; then',
-      '  echo "scheduler: session $prev_session not found, retrying with a fresh session"',
+      '  echo "opencode-jobs: session $prev_session not found, retrying with a fresh session"',
       '  rm -f "$json_out"',
       '  json_out="$(mktemp)"',
       '  run_opencode "" 1 >"$json_out" 2>&1',
@@ -948,6 +943,16 @@ Hint: no systemd user session is reachable. Over SSH try enabling lingering: log
   }
   return "";
 }
+function isTimerLoaded(base) {
+  const result = systemctl([
+    "show",
+    timerUnit(base),
+    "-p",
+    "LoadState",
+    "--value"
+  ]);
+  return result.ok && result.stdout !== "not-found";
+}
 function timerStatus(base) {
   const result = systemctl([
     "show",
@@ -985,17 +990,25 @@ function writeJobUnits(job, workdir, scopeId, opencodeBin, pathEnvironment) {
 }
 function removeJobUnits(scopeId, slug) {
   const base = unitBase(scopeId, slug);
-  systemctl(["disable", "--now", timerUnit(base)]);
-  for (const file of [
+  const files = [
     path4.join(systemdUserDirectory(), timerUnit(base)),
     path4.join(systemdUserDirectory(), serviceUnit(base))
-  ]) {
+  ];
+  const script = runScriptPath(scopeId, slug);
+  if ([...files, script].every((file) => !existsSync3(file)) && !isTimerLoaded(base)) {
+    return;
+  }
+  const disable = systemctl(["disable", "--now", timerUnit(base)]);
+  if (!disable.ok) {
+    return `${timerUnit(base)}: ${disable.stderr}${systemdHint(disable.stderr)}`;
+  }
+  for (const file of files) {
     if (existsSync3(file))
       rmSync(file);
   }
-  const script = runScriptPath(scopeId, slug);
   if (existsSync3(script))
     rmSync(script);
+  return;
 }
 function removeStaleUnits(scopeId, expectedSlugs) {
   const prefix = `opencode-sched-${scopeId}-`;
@@ -1072,7 +1085,7 @@ ${errors.join(`
     lines.push(`Removed stale units for deleted jobs: ${removed.join(", ")}`);
   lines.push(...describeJobSchedules(jobs, scopeId));
   if (failures.length > 0)
-    lines.push(`Timer activation failures:
+    throw new Error(`Timer activation failures:
 ${failures.join(`
 `)}`);
   return lines.join(`
@@ -1093,9 +1106,19 @@ function disableProject(workdir) {
   const entry = registryEntry(abs);
   if (entry === undefined)
     return `Project is not enabled: ${abs}`;
-  for (const slug of entry.jobs)
-    removeJobUnits(entry.scopeId, slug);
-  systemctl(["daemon-reload"]);
+  const failures = entry.jobs.flatMap((slug) => {
+    const failure = removeJobUnits(entry.scopeId, slug);
+    return failure === undefined ? [] : [failure];
+  });
+  if (failures.length > 0) {
+    throw new Error(`Timer removal failures:
+${failures.join(`
+`)}`);
+  }
+  const reload = systemctl(["daemon-reload"]);
+  if (!reload.ok) {
+    throw new Error(`systemctl --user daemon-reload failed: ${reload.stderr}${systemdHint(reload.stderr)}`);
+  }
   const registry = loadRegistry();
   const { [abs]: _omitted, ...remainingProjects } = registry.projects;
   registry.projects = remainingProjects;
@@ -1108,13 +1131,10 @@ function disableProject(workdir) {
 `);
 }
 
-// src/tools.ts
-function ok(output) {
-  return { output };
-}
-function fail(message) {
-  return { output: `Error: ${message}`, metadata: { error: true } };
-}
+// src/management.ts
+import { spawn } from "child_process";
+import { closeSync, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync } from "fs";
+import path6 from "path";
 function tryParseCron(schedule) {
   try {
     return parseCron(schedule);
@@ -1122,7 +1142,7 @@ function tryParseCron(schedule) {
     return;
   }
 }
-function listJobsOutput(directory) {
+function listJobs(directory) {
   const { jobs, errors } = loadJobs(directory);
   const entry = registryEntry(directory);
   const header = entry ? `Project enabled (scope ${entry.scopeId}). Job definitions: ${jobsDirectory(directory)}` : `Project not enabled. Job definitions: ${jobsDirectory(directory)}`;
@@ -1144,8 +1164,63 @@ function listJobsOutput(directory) {
     lines.push(`- ${job.slug}: ${job.schedule} (${describeCron(sets)})${nextDesc}${lastDesc}`);
   }
   lines.push(...errors.map((error) => `! ${error}`));
-  return ok(lines.join(`
-`));
+  return { ok: true, output: lines.join(`
+`) };
+}
+function runJobNow(slugInput, directory) {
+  const slug = slugify(slugInput);
+  const file = path6.join(jobsDirectory(directory), `${slug}.json`);
+  if (!existsSync4(file)) {
+    return {
+      ok: false,
+      output: `No job "${slug}" in ${jobsDirectory(directory)}`
+    };
+  }
+  const entry = registryEntry(directory);
+  if (entry === undefined) {
+    return {
+      ok: false,
+      output: `Project is not enabled, so no run script exists for "${slug}". Run enable_project first.`
+    };
+  }
+  const script = runScriptPath(entry.scopeId, slug);
+  if (!existsSync4(script)) {
+    return {
+      ok: false,
+      output: `Run script missing for "${slug}". Run enable_project to (re)install units.`
+    };
+  }
+  const log = logFile(entry.scopeId, slug);
+  mkdirSync3(logDirectory(entry.scopeId), { recursive: true });
+  const fd = openSync(log, "a");
+  const child = spawn("/bin/sh", [script], {
+    cwd: path6.resolve(directory),
+    env: { ...process.env, OPENCODE_JOBS_STARTED_BY: "manual" },
+    stdio: ["ignore", fd, fd]
+  });
+  child.unref();
+  closeSync(fd);
+  const tail = tailFile(log, 5, 2000);
+  const parts = [
+    `Started "${slug}" manually (pid ${String(child.pid)})`,
+    `Log: ${log}`
+  ];
+  if (tail?.length)
+    parts.push(`Log tail:
+${tail}`);
+  return { ok: true, output: parts.join(`
+`) };
+}
+
+// src/tools.ts
+function ok(output) {
+  return { output };
+}
+function fail(message) {
+  return { output: `Error: ${message}`, metadata: { error: true } };
+}
+function managementToolResult(result) {
+  return result.ok ? ok(result.output) : fail(result.output);
 }
 function scheduleJobOutput(input, directory) {
   const slug = slugify(input.slug ?? input.name);
@@ -1189,7 +1264,7 @@ function scheduleJobOutput(input, directory) {
   } catch (error) {
     return fail(errorMessage(error));
   }
-  const existing = loadJobFile(path6.join(jobsDirectory(directory), `${slug}.json`), slug);
+  const existing = loadJobFile(path7.join(jobsDirectory(directory), `${slug}.json`), slug);
   const job = {
     slug,
     name: input.name,
@@ -1203,7 +1278,7 @@ function scheduleJobOutput(input, directory) {
     updatedAt: nowIso()
   };
   saveJob(directory, job);
-  const relativePath = `.opencode/scheduler/jobs/${slug}.json`;
+  const relativePath = `.opencode/jobs/${slug}.json`;
   const lines = [
     `${existing.ok ? "Updated" : "Created"} job "${job.name}" (${slug})`,
     `Definition: ${relativePath} (${job.schedule} \u2014 ${describeCron(sets)})`
@@ -1218,7 +1293,7 @@ function scheduleJobOutput(input, directory) {
     return ok(lines.join(`
 `));
   }
-  const abs = path6.resolve(directory);
+  const abs = path7.resolve(directory);
   const opencodeBin = findOpencode();
   const pathEnvironment = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
   const base = writeJobUnits(job, abs, entry.scopeId, opencodeBin, pathEnvironment);
@@ -1244,8 +1319,8 @@ function scheduleJobOutput(input, directory) {
 `));
 }
 function showJobOutput(slugInput, directory) {
-  const file = path6.join(jobsDirectory(directory), `${slugify(slugInput)}.json`);
-  if (!existsSync4(file)) {
+  const file = path7.join(jobsDirectory(directory), `${slugify(slugInput)}.json`);
+  if (!existsSync5(file)) {
     return fail(`No job "${slugInput}" in ${jobsDirectory(directory)}. Use list_jobs to see definitions.`);
   }
   const result = loadJobFile(file);
@@ -1259,7 +1334,7 @@ function showJobOutput(slugInput, directory) {
   const lines = [
     `${job.name} (${job.slug})`,
     `Schedule: ${job.schedule} \u2014 ${describeCron(sets)}`,
-    `Definition: .opencode/scheduler/jobs/${job.slug}.json (updated ${job.updatedAt})`,
+    `Definition: .opencode/jobs/${job.slug}.json (updated ${job.updatedAt})`,
     `Run: ${runDesc}`
   ];
   if (job.guard !== undefined)
@@ -1270,7 +1345,7 @@ function showJobOutput(slugInput, directory) {
   }
   if (job.session !== undefined) {
     const state = sessionStateFile(scopeId, job.slug);
-    const sessionId = existsSync4(state) ? readFileSync4(state, "utf8").trim() : "";
+    const sessionId = existsSync5(state) ? readFileSync4(state, "utf8").trim() : "";
     lines.push(`Session: ${job.session}${sessionId.length > 0 ? ` \u2014 current ${sessionId}` : " \u2014 no session yet"}`);
   }
   if (job.run.agent !== undefined)
@@ -1305,24 +1380,30 @@ function showJobOutput(slugInput, directory) {
 }
 function removeJobDefinitionOutput(slugInput, directory) {
   const slug = slugify(slugInput);
-  const file = path6.join(jobsDirectory(directory), `${slug}.json`);
-  if (!existsSync4(file))
+  const file = path7.join(jobsDirectory(directory), `${slug}.json`);
+  if (!existsSync5(file))
     return fail(`No job "${slug}" in ${jobsDirectory(directory)}`);
+  const abs = path7.resolve(directory);
+  const entry = registryEntry(directory);
+  if (entry?.jobs.includes(slug)) {
+    const removalFailure = removeJobUnits(entry.scopeId, slug);
+    if (removalFailure !== undefined) {
+      return fail(`Failed to remove systemd units: ${removalFailure}`);
+    }
+    const reload = systemctl(["daemon-reload"]);
+    if (!reload.ok) {
+      return fail(`Removed the units but systemd reload failed: ${reload.stderr}${systemdHint(reload.stderr)}`);
+    }
+  }
   rmSync2(file);
-  const lines = [
-    `Deleted job definition .opencode/scheduler/jobs/${slug}.json`
-  ];
-  const scopeId = registryEntry(directory)?.scopeId ?? deriveScopeId(directory);
+  const lines = [`Deleted job definition .opencode/jobs/${slug}.json`];
+  const scopeId = entry?.scopeId ?? deriveScopeId(directory);
   const state = sessionStateFile(scopeId, slug);
-  if (existsSync4(state)) {
+  if (existsSync5(state)) {
     rmSync2(state);
     lines.push(`Removed session state ${state}`);
   }
-  const abs = path6.resolve(directory);
-  const entry = registryEntry(directory);
   if (entry?.jobs.includes(slug)) {
-    removeJobUnits(entry.scopeId, slug);
-    systemctl(["daemon-reload"]);
     const registry = loadRegistry();
     const current = registry.projects[abs];
     if (current !== undefined) {
@@ -1341,40 +1422,6 @@ function omitProject(registry, workdir) {
   const { [workdir]: _omitted, ...remaining } = registry.projects;
   registry.projects = remaining;
 }
-function runJobNowOutput(slugInput, directory) {
-  const slug = slugify(slugInput);
-  const file = path6.join(jobsDirectory(directory), `${slug}.json`);
-  if (!existsSync4(file))
-    return fail(`No job "${slug}" in ${jobsDirectory(directory)}`);
-  const entry = registryEntry(directory);
-  if (entry === undefined) {
-    return fail(`Project is not enabled, so no run script exists for "${slug}". Run enable_project first.`);
-  }
-  const script = runScriptPath(entry.scopeId, slug);
-  if (!existsSync4(script)) {
-    return fail(`Run script missing for "${slug}". Run enable_project to (re)install units.`);
-  }
-  const log = logFile(entry.scopeId, slug);
-  mkdirSync3(logDirectory(entry.scopeId), { recursive: true });
-  const fd = openSync(log, "a");
-  const child = spawn("/bin/sh", [script], {
-    cwd: path6.resolve(directory),
-    env: { ...process.env, OPENCODE_SCHEDULER_STARTED_BY: "manual" },
-    stdio: ["ignore", fd, fd]
-  });
-  child.unref();
-  closeSync(fd);
-  const tail = tailFile(log, 5, 2000);
-  const parts = [
-    `Started "${slug}" manually (pid ${String(child.pid)})`,
-    `Log: ${log}`
-  ];
-  if (tail?.length)
-    parts.push(`Log tail:
-${tail}`);
-  return ok(parts.join(`
-`));
-}
 function jobLogsOutput(slugInput, lineCountInput, directory) {
   const entry = registryEntry(directory);
   const scopeId = entry?.scopeId ?? deriveScopeId(directory);
@@ -1393,21 +1440,21 @@ function listProjectsOutput() {
   const entries = Object.values(registry.projects).toSorted((a, b) => a.workdir.localeCompare(b.workdir));
   if (entries.length === 0)
     return ok("No projects with scheduled jobs are registered.");
-  const lines = ["Registry: ~/.config/opencode/scheduler/registry.json"];
+  const lines = ["Registry: ~/.config/opencode/jobs/registry.json"];
   for (const entry of entries) {
-    const missing = existsSync4(entry.workdir) ? "" : " [WORKDIR MISSING]";
+    const missing = existsSync5(entry.workdir) ? "" : " [WORKDIR MISSING]";
     lines.push(`- ${entry.workdir}${missing}`, `  scope ${entry.scopeId}, ${String(entry.jobs.length)} job(s): ${entry.jobs.join(", ")}`);
   }
   return ok(lines.join(`
 `));
 }
 var listJobsTool = tool({
-  description: "List scheduled job definitions for the current project (from .opencode/scheduler/jobs/), including enabled state, next run, and last run status.",
+  description: "List scheduled job definitions for the current project (from .opencode/jobs/), including enabled state, next run, and last run status.",
   args: {},
-  execute: (_input, context) => Promise.resolve(listJobsOutput(context.directory))
+  execute: (_input, context) => Promise.resolve(managementToolResult(listJobs(context.directory)))
 });
 var scheduleJobTool = tool({
-  description: "Create or update a scheduled job definition in the current project (.opencode/scheduler/jobs/<slug>.json, git-committable). Schedule is a 5-field cron expression. Set either prompt (natural language) or command (custom command name). If the project is enabled, systemd units are re-synced automatically.",
+  description: "Create or update a scheduled job definition in the current project (.opencode/jobs/<slug>.json, git-committable). Schedule is a 5-field cron expression. Set either prompt (natural language) or command (custom command name). If the project is enabled, systemd units are re-synced automatically.",
   args: {
     name: tool.schema.string().describe("Human-readable job name"),
     schedule: tool.schema.string().describe('5-field cron expression, e.g. "0 9 * * *" (daily 9am), "0 */6 * * *" (every 6h), "30 8 * * 1" (Mon 8:30)'),
@@ -1417,7 +1464,7 @@ var scheduleJobTool = tool({
     session: tool.schema.string().optional().describe(`Session continuity between runs: "new" (default, fresh session each run), "persist" (continue the same session), "compact" (continue the same session; after each run the history is compacted into a summary the next run starts from), "compact+last" (like compact, but the run's final result message is re-injected after the summary so the next run starts from summary plus last result)`),
     guard: tool.schema.string().optional().describe('Shell command run before the job; the run only starts if it exits 0, otherwise it is recorded as skipped (applies to run_job too). E.g. "! git diff --quiet" to run only when the repo has changes'),
     worktree: tool.schema.boolean().optional().describe("Run the job in a fresh git worktree instead of the project checkout: the worktree is created from worktreeRef (default HEAD), the job runs inside it, all changes are committed to a per-run branch opencode-jobs/<slug>/\u2026, and the worktree is removed afterwards (kept if the safety commit fails). Requires the project to be a git repository"),
-    worktreeBase: tool.schema.string().optional().describe("Parent directory for the worktree (default: ~/.local/state/opencode/scheduler/worktrees/<scopeId>/<slug>). Relative paths resolve against the project directory; it should be dedicated to scheduler worktrees"),
+    worktreeBase: tool.schema.string().optional().describe("Parent directory for the worktree (default: ~/.local/state/opencode/jobs/worktrees/<scopeId>/<slug>). Relative paths resolve against the project directory; it should be dedicated to job worktrees"),
     worktreeRef: tool.schema.string().optional().describe('Git ref the worktree branch starts from (default: "HEAD")'),
     worktreeCommitMessage: tool.schema.string().optional().describe('Commit message used when saving worktree changes (default: "opencode-jobs: <slug> run <runId>")'),
     agent: tool.schema.string().optional().describe("Agent to use for the run"),
@@ -1446,7 +1493,7 @@ var runJobTool = tool({
   args: {
     slug: tool.schema.string().describe("Job slug to run now")
   },
-  execute: (input, context) => Promise.resolve(runJobNowOutput(input.slug, context.directory))
+  execute: (input, context) => Promise.resolve(managementToolResult(runJobNow(input.slug, context.directory)))
 });
 var jobLogsTool = tool({
   description: "Show the tail of a scheduled job's log file (scheduled and manual runs both append to it).",
@@ -1457,7 +1504,7 @@ var jobLogsTool = tool({
   execute: (input, context) => Promise.resolve(jobLogsOutput(input.slug, input.lines, context.directory))
 });
 var enableProjectTool = tool({
-  description: "Enable scheduled jobs for the current project: installs a systemd user service+timer per job definition in .opencode/scheduler/jobs/, registers the project in the global registry (~/.config/opencode/scheduler/registry.json), and removes stale units for deleted jobs. Idempotent, so it also re-syncs after job definitions change. Linux only.",
+  description: "Enable scheduled jobs for the current project: installs a systemd user service+timer per job definition in .opencode/jobs/, registers the project in the global registry (~/.config/opencode/jobs/registry.json), and removes stale units for deleted jobs. Idempotent, so it also re-syncs after job definitions change. Linux only.",
   args: {},
   execute: (_input, context) => Promise.resolve(enableProjectOutput(context.directory))
 });
@@ -1481,11 +1528,11 @@ function disableProjectOutput(directory) {
   }
 }
 var listProjectsTool = tool({
-  description: "List all projects with enabled scheduled jobs from the global registry (~/.config/opencode/scheduler/registry.json).",
+  description: "List all projects with enabled scheduled jobs from the global registry (~/.config/opencode/jobs/registry.json).",
   args: {},
   execute: () => Promise.resolve(listProjectsOutput())
 });
-var schedulerTools = {
+var jobsTools = {
   schedule_job: scheduleJobTool,
   list_jobs: listJobsTool,
   get_job: showJobTool,
@@ -1497,12 +1544,102 @@ var schedulerTools = {
   list_projects: listProjectsTool
 };
 
+// src/migration.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, renameSync as renameSync2, rmdirSync } from "fs";
+import path8 from "path";
+function legacyJobsStateDirectory() {
+  return path8.join(configRoot(), "opencode", "scheduler");
+}
+function legacyRegistryPath() {
+  return path8.join(legacyJobsStateDirectory(), "registry.json");
+}
+function legacyDefinitionsDirectory(workdir) {
+  return path8.join(workdir, ".opencode", "scheduler", "jobs");
+}
+function migrationMoves(projects) {
+  return [
+    {
+      from: legacyJobsStateDirectory(),
+      to: jobsStateDirectory()
+    },
+    {
+      from: path8.join(configRoot(), "opencode", "logs", "scheduler"),
+      to: path8.join(configRoot(), "opencode", "logs", "jobs")
+    },
+    {
+      from: path8.join(stateRoot(), "opencode", "scheduler", "worktrees"),
+      to: path8.join(stateRoot(), "opencode", "jobs", "worktrees")
+    },
+    ...[...projects].map((workdir) => ({
+      from: legacyDefinitionsDirectory(workdir),
+      to: jobsDirectory(workdir)
+    }))
+  ];
+}
+function removeLegacyProjectDirectory(workdir) {
+  try {
+    rmdirSync(path8.join(workdir, ".opencode", "scheduler"));
+  } catch {}
+}
+function migrateStorage(projectDirectory, shouldResync) {
+  const project = path8.resolve(projectDirectory);
+  const legacyRegistry = legacyRegistryPath();
+  const canonicalRegistry = path8.join(jobsStateDirectory(), "registry.json");
+  const registryFile = existsSync6(legacyRegistry) ? legacyRegistry : canonicalRegistry;
+  const registry = existsSync6(registryFile) ? readRegistryFile(registryFile) : { version: 1, projects: {} };
+  const registeredProjects = new Set(Object.keys(registry.projects));
+  const projects = new Set([project, ...registeredProjects]);
+  const moves = migrationMoves(projects).filter(({ from }) => existsSync6(from));
+  for (const { from, to } of moves) {
+    if (existsSync6(to)) {
+      throw new Error(`Cannot migrate legacy job storage because both paths exist: ${from} and ${to}. Reconcile or back up one path, then retry; neither path was changed.`);
+    }
+  }
+  for (const { from, to } of moves) {
+    mkdirSync4(path8.dirname(to), { recursive: true });
+    renameSync2(from, to);
+  }
+  for (const workdir of projects)
+    removeLegacyProjectDirectory(workdir);
+  const result = {
+    moved: moves,
+    resyncedProjects: [],
+    warnings: []
+  };
+  if (!shouldResync || moves.length === 0)
+    return result;
+  for (const workdir of registeredProjects) {
+    try {
+      enableProject(workdir);
+      result.resyncedProjects.push(workdir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.warnings.push(`${workdir}: ${message}`);
+    }
+  }
+  return result;
+}
+
 // src/index.ts
-var src_default = () => {
+var src_default = (input) => {
+  if (typeof input.directory === "string") {
+    try {
+      const migration = migrateStorage(input.directory, true);
+      if (migration.moved.length > 0) {
+        console.error(`[opencode-jobs] migrated ${String(migration.moved.length)} legacy storage location(s) to jobs paths`);
+      }
+      for (const warning of migration.warnings) {
+        console.error(`[opencode-jobs] migration warning: ${warning}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[opencode-jobs] storage migration failed: ${message}`);
+    }
+  }
   if (process.platform !== "linux") {
     console.error("[opencode-jobs] warning: this is not a Linux host, systemd user timers are unavailable \u2014 scheduling tools will not work here");
   }
-  return Promise.resolve({ tool: schedulerTools });
+  return Promise.resolve({ tool: jobsTools });
 };
 export {
   src_default as default