opencode-jobs 0.2.0 → 1.0.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 import type { Hooks } from "@opencode-ai/plugin";
-declare const _default: () => Promise<Hooks>;
+declare const _default: (input: import("@opencode-ai/plugin").PluginInput) => Promise<Hooks>;
 export default _default;

package/dist/index.js

@@ -149,31 +149,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 +182,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 +447,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 +551,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 +584,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 +616,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 +662,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 +691,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 +708,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 +727,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 +747,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 +783,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 +842,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',
@@ -1203,7 +1206,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)})`
@@ -1259,7 +1262,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)
@@ -1309,9 +1312,7 @@ function removeJobDefinitionOutput(slugInput, directory) {
   if (!existsSync4(file))
     return fail(`No job "${slug}" in ${jobsDirectory(directory)}`);
   rmSync2(file);
-  const lines = [
-    `Deleted job definition .opencode/scheduler/jobs/${slug}.json`
-  ];
+  const lines = [`Deleted job definition .opencode/jobs/${slug}.json`];
   const scopeId = registryEntry(directory)?.scopeId ?? deriveScopeId(directory);
   const state = sessionStateFile(scopeId, slug);
   if (existsSync4(state)) {
@@ -1359,7 +1360,7 @@ function runJobNowOutput(slugInput, directory) {
   const fd = openSync(log, "a");
   const child = spawn("/bin/sh", [script], {
     cwd: path6.resolve(directory),
-    env: { ...process.env, OPENCODE_SCHEDULER_STARTED_BY: "manual" },
+    env: { ...process.env, OPENCODE_JOBS_STARTED_BY: "manual" },
     stdio: ["ignore", fd, fd]
   });
   child.unref();
@@ -1393,7 +1394,7 @@ 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]";
     lines.push(`- ${entry.workdir}${missing}`, `  scope ${entry.scopeId}, ${String(entry.jobs.length)} job(s): ${entry.jobs.join(", ")}`);
@@ -1402,12 +1403,12 @@ function listProjectsOutput() {
 `));
 }
 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))
 });
 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 +1418,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"),
@@ -1457,7 +1458,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 +1482,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 +1498,102 @@ var schedulerTools = {
   list_projects: listProjectsTool
 };
 
+// src/migration.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, renameSync as renameSync2, rmdirSync } from "fs";
+import path7 from "path";
+function legacyJobsStateDirectory() {
+  return path7.join(configRoot(), "opencode", "scheduler");
+}
+function legacyRegistryPath() {
+  return path7.join(legacyJobsStateDirectory(), "registry.json");
+}
+function legacyDefinitionsDirectory(workdir) {
+  return path7.join(workdir, ".opencode", "scheduler", "jobs");
+}
+function migrationMoves(projects) {
+  return [
+    {
+      from: legacyJobsStateDirectory(),
+      to: jobsStateDirectory()
+    },
+    {
+      from: path7.join(configRoot(), "opencode", "logs", "scheduler"),
+      to: path7.join(configRoot(), "opencode", "logs", "jobs")
+    },
+    {
+      from: path7.join(stateRoot(), "opencode", "scheduler", "worktrees"),
+      to: path7.join(stateRoot(), "opencode", "jobs", "worktrees")
+    },
+    ...[...projects].map((workdir) => ({
+      from: legacyDefinitionsDirectory(workdir),
+      to: jobsDirectory(workdir)
+    }))
+  ];
+}
+function removeLegacyProjectDirectory(workdir) {
+  try {
+    rmdirSync(path7.join(workdir, ".opencode", "scheduler"));
+  } catch {}
+}
+function migrateStorage(projectDirectory, shouldResync) {
+  const project = path7.resolve(projectDirectory);
+  const legacyRegistry = legacyRegistryPath();
+  const canonicalRegistry = path7.join(jobsStateDirectory(), "registry.json");
+  const registryFile = existsSync5(legacyRegistry) ? legacyRegistry : canonicalRegistry;
+  const registry = existsSync5(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 }) => existsSync5(from));
+  for (const { from, to } of moves) {
+    if (existsSync5(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(path7.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

package/dist/install.d.ts

@@ -1,3 +1,4 @@
+import { type StorageMigration } from "./migration.js";
 export declare const PACKAGE_NAME = "opencode-jobs";
 export declare const SKILL_NAME = "opencode-jobs";
 export type ConfigInstall = {
@@ -15,6 +16,7 @@ export interface ProjectInstall {
     projectDirectory: string;
     plugin: ConfigInstall;
     skill: SkillInstall;
+    migration?: StorageMigration;
 }
 export declare function installPluginConfig(projectDirectory: string): ConfigInstall;
 export declare function installSkill(projectDirectory: string, packageDirectory: string): SkillInstall;
@@ -39,6 +41,7 @@ export interface ProjectUninstall {
     plugin: ConfigUninstall;
     skill: SkillUninstall;
     purge?: PurgeResult;
+    migration?: StorageMigration;
 }
 export declare function uninstallPluginConfig(projectDirectory: string): ConfigUninstall;
 export declare function uninstallSkill(projectDirectory: string, packageDirectory: string): SkillUninstall;

package/dist/migration.d.ts

@@ -0,0 +1,9 @@
+export interface StorageMigration {
+    moved: {
+        from: string;
+        to: string;
+    }[];
+    resyncedProjects: string[];
+    warnings: string[];
+}
+export declare function migrateStorage(projectDirectory: string, shouldResync: boolean): StorageMigration;

package/dist/paths.d.ts

@@ -2,7 +2,7 @@ export declare function configRoot(): string;
 export declare function stateRoot(): string;
 export declare function worktreesDirectory(scopeId: string): string;
 export declare function locksDirectory(scopeId: string): string;
-export declare function schedulerDirectory(): string;
+export declare function jobsStateDirectory(): string;
 export declare function registryPath(): string;
 export declare function scopeDirectory(scopeId: string): string;
 export declare function runsDirectory(scopeId: string): string;

package/dist/registry.d.ts

@@ -9,6 +9,7 @@ export interface Registry {
     version: 1;
     projects: Record<string, RegistryEntry>;
 }
+export declare function readRegistryFile(file: string): Registry;
 export declare function loadRegistry(): Registry;
 export declare function saveRegistry(registry: Registry): void;
 export declare function registryEntry(workdir: string): RegistryEntry | undefined;

package/dist/tools.d.ts

@@ -1,2 +1,2 @@
 import { type ToolDefinition } from "@opencode-ai/plugin";
-export declare const schedulerTools: Record<string, ToolDefinition>;
+export declare const jobsTools: Record<string, ToolDefinition>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-jobs",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "opencode plugin that schedules recurring agent jobs as systemd user timers, with git-committable job definitions, run history, and session continuity",
   "type": "module",
   "engines": {

package/skill/opencode-jobs/SKILL.md

@@ -7,13 +7,13 @@ compatibility: opencode on Linux with systemd
 
 # OpenCode Jobs
 
-Use the `opencode-jobs` tools instead of editing systemd units or global
-scheduler state directly.
+Use the `opencode-jobs` tools instead of editing systemd units or global job
+state directly.
 
 ## Workflow
 
 1. Create or update a definition with `schedule_job`. Definitions belong in
-   `.opencode/scheduler/jobs/<slug>.json` and should be committed with the
+   `.opencode/jobs/<slug>.json` and should be committed with the
    project.
 2. Inspect definitions with `list_jobs` or `get_job`.
 3. Run `enable_project` after the first job is created. Run it again to
@@ -36,7 +36,7 @@ scheduler state directly.
 - A `guard` is a shell command that must exit zero for the job to run.
 - Set `worktree: true` when the job should not touch the user's checkout:
   each run gets a fresh git worktree (default base
-  `~/.local/state/opencode/scheduler/worktrees/…`, override with
+  `~/.local/state/opencode/jobs/worktrees/…`, override with
   `worktree.base`), all changes are committed to a per-run branch
   `opencode-jobs/<slug>/…`, and the worktree is removed. Overlapping runs
   of the same job are skipped via a lock; subdirectory projects run in