opencode-jobs 0.1.2 → 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

@@ -145,29 +145,35 @@ import { homedir } from "os";
 function configRoot() {
   return process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
 }
-function schedulerDirectory() {
-  return path.join(configRoot(), "opencode", "scheduler");
+function stateRoot() {
+  return process.env.XDG_STATE_HOME ?? path.join(homedir(), ".local", "state");
+}
+function worktreesDirectory(scopeId) {
+  return path.join(stateRoot(), "opencode", "jobs", "worktrees", scopeId);
+}
+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`);
@@ -176,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}`;
@@ -281,6 +287,24 @@ var sessionSchema = z.enum(SESSION_MODES, {
   error: `must be one of ${SESSION_MODES.map((mode) => `"${mode}"`).join(", ")}`
 });
 var guardSchema = z.string().refine((value) => value.trim().length > 0, "must be a non-empty shell command string");
+var worktreeSchema = z.union([
+  z.literal(true),
+  z.strictObject({
+    base: nonEmptyStringSchema.optional(),
+    ref: nonEmptyStringSchema.optional(),
+    commitMessage: nonEmptyStringSchema.optional()
+  })
+]).transform((value) => {
+  if (value === true)
+    return {};
+  return {
+    ...value.base !== undefined && { base: value.base },
+    ...value.ref !== undefined && { ref: value.ref },
+    ...value.commitMessage !== undefined && {
+      commitMessage: value.commitMessage
+    }
+  };
+});
 var timeoutSchema = z.number().int().nonnegative("must be a non-negative integer");
 var cronSchema = z.string().superRefine((schedule, context) => {
   try {
@@ -296,6 +320,7 @@ var jobFileSchema = z.strictObject({
   run: runSpecSchema,
   session: sessionSchema.default("new"),
   guard: guardSchema.optional(),
+  worktree: worktreeSchema.optional(),
   timeoutSeconds: timeoutSchema.optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional()
@@ -332,6 +357,11 @@ function validateGuard(value, context) {
     return;
   return parseWithContext(guardSchema, value, context);
 }
+function validateWorktree(value, context) {
+  if (value === undefined)
+    return;
+  return parseWithContext(worktreeSchema, value, context);
+}
 function loadJobFile(file, expectedSlug) {
   const stem = path2.basename(file, ".json");
   try {
@@ -362,6 +392,9 @@ function loadJobFile(file, expectedSlug) {
         run: definition.run,
         ...definition.session !== "new" && { session: definition.session },
         ...definition.guard !== undefined && { guard: definition.guard },
+        ...definition.worktree !== undefined && {
+          worktree: definition.worktree
+        },
         ...definition.timeoutSeconds !== undefined && {
           timeoutSeconds: definition.timeoutSeconds
         },
@@ -414,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: {} };
   }
@@ -454,7 +490,9 @@ var runRecordSchema = z3.object({
   status: optionalString,
   exitCode: optionalNumber,
   sessionId: optionalString,
-  startedBy: optionalString
+  startedBy: optionalString,
+  worktreeBranch: optionalString,
+  worktreeCommit: optionalString
 });
 function readRunRecords(scopeId, slug, limit) {
   const file = runsFile(scopeId, slug);
@@ -492,7 +530,8 @@ function formatRunLine(record) {
   const duration = record.durationMs === undefined ? "" : ` (${String(Math.round(record.durationMs / 1000))}s)`;
   const code = record.exitCode === undefined ? "" : ` exit ${String(record.exitCode)}`;
   const session = record.sessionId === undefined || record.sessionId.length === 0 ? "" : ` session ${record.sessionId}`;
-  return `${timestampOf(record)} ${record.status ?? "?"}${code}${duration}${session} via ${record.startedBy ?? "?"}`;
+  const worktree = record.worktreeBranch === undefined || record.worktreeBranch.length === 0 ? "" : ` worktree ${record.worktreeBranch}` + (record.worktreeCommit === undefined || record.worktreeCommit.length === 0 ? "" : `@${record.worktreeCommit.slice(0, 7)}`);
+  return `${timestampOf(record)} ${record.status ?? "?"}${code}${duration}${session}${worktree} via ${record.startedBy ?? "?"}`;
 }
 function tailFile(file, lines, maxChars) {
   if (!existsSync2(file))
@@ -512,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"], {
@@ -544,6 +583,101 @@ function guardScriptLines(guard) {
     "fi"
   ];
 }
+function worktreeDefaultRoot(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/jobs/locks/$scope"',
+    'mkdir -p "$lock_dir"',
+    'exec 9>"$lock_dir/$slug.lock"',
+    "if ! flock -n 9; then",
+    '  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 "opencode-jobs: cannot create worktree base $wt_root"',
+    "  finish failed 1",
+    "  exit 1",
+    "fi",
+    'wt_root="$(cd "$wt_root" && pwd)"',
+    'wt_path="$wt_root/$slug"',
+    'wt_branch="opencode-jobs/$slug/$(date +%Y%m%d-%H%M%S)-$$"',
+    `wt_base_ref=${shQuote(job.worktree?.ref ?? "HEAD")}`,
+    'wt_sub="$(git rev-parse --show-prefix 2>/dev/null)"',
+    'wt_sub="${wt_sub%/}"',
+    'if [ -d "$wt_path" ]; then',
+    '  if git worktree list --porcelain 2>/dev/null | grep -qFx "worktree $wt_path"; then',
+    "    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=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 "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 "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 "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 "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=""',
+    "  finish failed 1",
+    "  exit 1",
+    "fi",
+    'if [ -n "$wt_sub" ]; then',
+    '  cd "$wt_path/$wt_sub" || { finish failed 1; exit 1; }',
+    "else",
+    '  cd "$wt_path" || { finish failed 1; exit 1; }',
+    "fi"
+  ];
+}
+function worktreeEpilogueLines(options) {
+  const message = options.commitMessage === undefined ? '"opencode-jobs: $slug run $run_id"' : shQuote(options.commitMessage);
+  return [
+    'if [ "$wt_enabled" -eq 1 ]; then',
+    `  wt_msg=${message}`,
+    '  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=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 "opencode-jobs: worktree commit failed, keeping worktree at $wt_path"',
+    "      wt_keep=1",
+    "    fi",
+    "  fi",
+    '  wt_commit="$(git -C "$wt_path" rev-parse HEAD 2>/dev/null)"',
+    '  if [ "$wt_keep" -eq 0 ]; then',
+    '    cd "$wt_root" 2>/dev/null',
+    '    git -C "$orig_pwd" worktree remove --force "$wt_path" >/dev/null 2>&1 || rm -rf "$wt_path"',
+    '    git -C "$orig_pwd" worktree prune >/dev/null 2>&1',
+    "  fi",
+    "fi"
+  ];
+}
 var SESSION_ID_SED = String.raw`s/.*"sessionID":"\([^"]*\)".*/\1/p`;
 var DEFAULT_PROVIDER_SED = String.raw`s/.*"default"[[:space:]]*:[[:space:]]*{[^}]*"\([^"]*\)"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p`;
 var DEFAULT_MODEL_SED = String.raw`s/.*"default"[[:space:]]*:[[:space:]]*{[^}]*"\([^"]*\)"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\2/p`;
@@ -557,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)"',
@@ -574,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',
@@ -593,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"',
@@ -613,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',
@@ -649,32 +783,35 @@ 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"',
     "  ended=$(date +%s)",
-    String.raw`  printf '{"runId":"%s","slug":"%s","scopeId":"%s","startedAt":%s,"finishedAt":%s,"durationMs":%s,"status":"%s","exitCode":%s,"sessionId":"%s","startedBy":"%s"}\n' "$run_id" "$slug" "$scope" "$started" "$ended" "$((ended - started))" "$status" "$code" "$new_session" "$started_by" >> "$record_file"`,
+    String.raw`  printf '{"runId":"%s","slug":"%s","scopeId":"%s","startedAt":%s,"finishedAt":%s,"durationMs":%s,"status":"%s","exitCode":%s,"sessionId":"%s","startedBy":"%s","worktreeBranch":"%s","worktreeCommit":"%s"}\n' "$run_id" "$slug" "$scope" "$started" "$ended" "$((ended - started))" "$status" "$code" "$new_session" "$started_by" "$wt_branch" "$wt_commit" >> "$record_file"`,
     "}",
     "trap 'finish timeout 124; exit 124' TERM INT",
     ...job.guard === undefined ? [] : guardScriptLines(job.guard),
     String.raw`printf '{"runId":"%s","slug":"%s","scopeId":"%s","startedAt":%s,"startedBy":"%s","status":"running"}\n' "$run_id" "$slug" "$scope" "$started" "$started_by" >> "$record_file"`,
+    ...job.worktree === undefined ? [] : worktreePrologueLines(job, scopeId),
     `oc_agent=${shQuote(job.run.agent ?? "")}`,
     `oc_model=${shQuote(job.run.model ?? "")}`,
     "prompt" in job.run ? "oc_command_mode=0" : "oc_command_mode=1",
@@ -705,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',
@@ -754,6 +891,7 @@ function runScriptContent(job, scopeId, opencodeBin) {
       "fi"
     ] : ['run_opencode "" 0', "code=$?"],
     "trap - TERM INT",
+    ...job.worktree === undefined ? [] : worktreeEpilogueLines(job.worktree),
     'if [ "$code" -ne 0 ]; then finish failed "$code"; exit "$code"; fi',
     ...isCompact ? ['if [ -n "$new_session" ]; then compact_session "$new_session"; fi'] : [],
     "finish success 0",
@@ -1020,9 +1158,14 @@ function scheduleJobOutput(input, directory) {
   } catch (error) {
     return fail(errorMessage(error));
   }
+  const hasWorktreeOptions = input.worktreeBase !== undefined || input.worktreeRef !== undefined || input.worktreeCommitMessage !== undefined;
+  if (hasWorktreeOptions && input.worktree !== true) {
+    return fail("set worktree: true to enable worktree options (worktreeBase, worktreeRef, worktreeCommitMessage)");
+  }
   let run;
   let session;
   let guard;
+  let worktree;
   let timeoutSeconds;
   try {
     run = validateRunSpec({
@@ -1034,6 +1177,17 @@ function scheduleJobOutput(input, directory) {
     }, "job");
     session = validateSession(input.session, "job");
     guard = validateGuard(input.guard, "job");
+    worktree = validateWorktree(input.worktree === true ? {
+      ...input.worktreeBase !== undefined && {
+        base: input.worktreeBase
+      },
+      ...input.worktreeRef !== undefined && {
+        ref: input.worktreeRef
+      },
+      ...input.worktreeCommitMessage !== undefined && {
+        commitMessage: input.worktreeCommitMessage
+      }
+    } : undefined, "job");
     timeoutSeconds = validateTimeout(input.timeoutSeconds, "job");
   } catch (error) {
     return fail(errorMessage(error));
@@ -1046,18 +1200,21 @@ function scheduleJobOutput(input, directory) {
     run,
     ...session !== "new" && { session },
     ...guard !== undefined && { guard },
+    ...worktree !== undefined && { worktree },
     ...timeoutSeconds !== undefined && { timeoutSeconds },
     createdAt: existing.ok ? existing.job.createdAt : nowIso(),
     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)})`
   ];
   if (session !== "new")
     lines.push(`Session: ${session}`);
+  if (worktree !== undefined)
+    lines.push(`Worktree: yes (base ${worktree.base ?? "default"}, branch opencode-jobs/${slug}/<run>)`);
   const entry = registryEntry(directory);
   if (entry === undefined) {
     lines.push("Project not enabled yet. Run enable_project to install the systemd timer.");
@@ -1105,11 +1262,15 @@ 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)
     lines.push(`Guard: ${job.guard} (must exit 0 for the run to start)`);
+  if (job.worktree !== undefined) {
+    const base = job.worktree.base ?? worktreesDirectory(scopeId);
+    lines.push(`Worktree: fresh per run at ${base} (from ${job.worktree.ref ?? "HEAD"}) \u2014 changes are committed to opencode-jobs/${job.slug}/\u2026 before the worktree is removed`);
+  }
   if (job.session !== undefined) {
     const state = sessionStateFile(scopeId, job.slug);
     const sessionId = existsSync4(state) ? readFileSync4(state, "utf8").trim() : "";
@@ -1151,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)) {
@@ -1201,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();
@@ -1235,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(", ")}`);
@@ -1244,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)'),
@@ -1258,6 +1417,10 @@ var scheduleJobTool = tool({
     arguments: tool.schema.string().optional().describe("Arguments passed to the custom command"),
     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/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"),
     model: tool.schema.string().optional().describe("Model to use for the run"),
     timeoutSeconds: tool.schema.number().optional().describe("Hard timeout in seconds (0 or omitted disables). systemd stops the run with SIGTERM after this"),
@@ -1295,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))
 });
@@ -1319,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,
@@ -1335,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;