opencode-jobs 0.2.0 → 1.1.0

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path6 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/install.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2, rmdirSync, statSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync as rmSync2, rmdirSync as rmdirSync2, statSync } from "node:fs";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import path5 from "node:path";
+import path7 from "node:path";
 import { z as z3 } from "zod";
 
 // src/paths.ts
@@ -22,32 +22,41 @@ 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 locksDirectory(scopeId) {
-  return path.join(schedulerDirectory(), "locks", scopeId);
+  return path.join(jobsStateDirectory(), "locks", 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 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`);
 }
 function systemdUserDirectory() {
   return path.join(configRoot(), "systemd", "user");
 }
+function jobsDirectory(workdir) {
+  return path.join(workdir, ".opencode", "jobs");
+}
 function unitBase(scopeId, slug) {
   return `opencode-sched-${scopeId}-${slug}`;
 }
@@ -64,12 +73,30 @@ function slugify(input) {
   const slug = input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, 64);
   return slug.length > 0 ? slug : "job";
 }
+function shQuote(value) {
+  return `'${value.replaceAll("'", String.raw`'\''`)}'`;
+}
+function unitQuote(value) {
+  if (/^[A-Za-z0-9_@:=./-]*$/.test(value))
+    return value;
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`;
+}
+function escapeUnitText(value) {
+  return value.replaceAll("%", "%%").replaceAll(/\s+/g, " ").trim();
+}
 function atomicWrite(file, content) {
   mkdirSync(path.dirname(file), { recursive: true });
   const temporary = `${file}.tmp`;
   writeFileSync(temporary, content);
   renameSync(temporary, file);
 }
+function atomicWriteExecutable(file, content) {
+  atomicWrite(file, content);
+  chmodSync(file, 493);
+}
+function nowIso() {
+  return new Date().toISOString();
+}
 function deriveScopeId(workdir) {
   const abs = path.resolve(workdir);
   const hash = createHash("sha256").update(abs).digest("hex").slice(0, 12);
@@ -77,12 +104,15 @@ function deriveScopeId(workdir) {
 }
 
 // src/project.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/job.ts
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path2 from "node:path";
 import { z } from "zod";
 
 // src/cron.ts
+var DOW_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 var DOW_NAMES = {
   sun: 0,
   mon: 1,
@@ -167,6 +197,42 @@ function parseCron(expression) {
     dow: parseCronField(dow, "dow", 0, 7, DOW_NAMES)
   };
 }
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function fmtList(values) {
+  return values.map((v) => pad2(v)).join(",");
+}
+function cronToOnCalendar(sets) {
+  const timePart = `${fmtList(sets.hour)}:${fmtList(sets.minute)}:00`;
+  const months = sets.month.length === 12 ? "*" : fmtList(sets.month);
+  const doms = sets.dom.length === 31 ? "*" : fmtList(sets.dom);
+  const dows = sets.dow.length === 7 ? "" : `${sets.dow.map((d) => DOW_LABELS[d]).join(",")} `;
+  if (sets.dow.length === 7)
+    return [`*-${months}-${doms} ${timePart}`];
+  if (sets.dom.length === 31 && sets.month.length === 12)
+    return [`${dows}*-*-* ${timePart}`];
+  return [
+    `${dows}*-${months}-* ${timePart}`,
+    `*-${months}-${doms} ${timePart}`
+  ];
+}
+function describeCron(sets) {
+  const timeDesc = sets.minute.length === 1 && sets.hour.length === 1 ? `at ${pad2(sets.hour[0] ?? 0)}:${pad2(sets.minute[0] ?? 0)}` : `at minute ${sets.minute.join(",")} of hour ${sets.hour.join(",")}`;
+  const isDowAll = sets.dow.length === 7;
+  const isDomAll = sets.dom.length === 31;
+  let dayDesc;
+  if (isDowAll && isDomAll)
+    dayDesc = "every day";
+  else if (isDowAll)
+    dayDesc = `on day ${sets.dom.join(",")} of the month`;
+  else if (isDomAll)
+    dayDesc = `on ${sets.dow.map((d) => DOW_LABELS[d]).join(",")}`;
+  else
+    dayDesc = `on ${sets.dow.map((d) => DOW_LABELS[d]).join(",")} or day ${sets.dom.join(",")}`;
+  const monthDesc = sets.month.length === 12 ? "" : ` in month ${sets.month.join(",")}`;
+  return `${timeDesc} ${dayDesc}${monthDesc}`;
+}
 
 // src/json.ts
 function errorMessage(error) {
@@ -258,10 +324,82 @@ var jobFileSchema = z.strictObject({
   createdAt: z.string().optional(),
   updatedAt: z.string().optional()
 });
+function formatValidationError(error) {
+  const issue = error.issues[0];
+  if (issue === undefined)
+    return "invalid job definition";
+  const field = issue.path.join(".");
+  return field.length === 0 ? issue.message : `"${field}": ${issue.message}`;
+}
+function loadJobFile(file, expectedSlug) {
+  const stem = path2.basename(file, ".json");
+  try {
+    const object = JSON.parse(readFileSync(file, "utf8"));
+    const result = jobFileSchema.safeParse(object);
+    if (!result.success) {
+      return {
+        ok: false,
+        error: `${stem}.json: ${formatValidationError(result.error)}`
+      };
+    }
+    const definition = result.data;
+    const slug = definition.slug ?? stem;
+    if (slug !== stem)
+      return {
+        ok: false,
+        error: `${stem}.json: "slug" ("${slug}") must match filename`
+      };
+    if (expectedSlug !== undefined && slug !== expectedSlug)
+      return { ok: false, error: `${stem}.json: unexpected slug` };
+    const timestamp = nowIso();
+    return {
+      ok: true,
+      job: {
+        slug,
+        name: definition.name,
+        schedule: definition.schedule,
+        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
+        },
+        createdAt: definition.createdAt ?? timestamp,
+        updatedAt: definition.updatedAt ?? timestamp
+      }
+    };
+  } catch (error) {
+    return { ok: false, error: `${stem}.json: ${errorMessage(error)}` };
+  }
+}
+function loadJobs(workdir) {
+  const directory = jobsDirectory(workdir);
+  if (!existsSync(directory))
+    return { jobs: [], errors: [] };
+  const jobs = [];
+  const errors = [];
+  const entries = readdirSync(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json"))
+      continue;
+    const result = loadJobFile(path2.join(directory, entry.name));
+    if (result.ok)
+      jobs.push(result.job);
+    else
+      errors.push(result.error);
+  }
+  return {
+    jobs: jobs.toSorted((a, b) => a.slug.localeCompare(b.slug)),
+    errors
+  };
+}
 
 // src/registry.ts
-import { readFileSync } from "node:fs";
-import path2 from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
 import { z as z2 } from "zod";
 var registryEntrySchema = z2.looseObject({
   scopeId: z2.string(),
@@ -274,19 +412,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(readFileSync(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: {} };
   }
@@ -296,16 +437,398 @@ function saveRegistry(registry) {
 `);
 }
 function registryEntry(workdir) {
-  return loadRegistry().projects[path2.resolve(workdir)];
+  return loadRegistry().projects[path3.resolve(workdir)];
 }
 
 // src/systemd.ts
-import { existsSync, mkdirSync as mkdirSync2, readdirSync, rmSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import path3 from "node:path";
+import path4 from "node:path";
+import { homedir as homedir2 } from "node:os";
+function findOpencode() {
+  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"], {
+    encoding: "utf8"
+  });
+  const onPath = which.stdout.trim();
+  if (which.status === 0 && onPath.length > 0)
+    return onPath;
+  const candidates = [
+    path4.join(homedir2(), ".opencode/bin/opencode"),
+    "/usr/local/bin/opencode",
+    "/usr/bin/opencode"
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate))
+      return candidate;
+  }
+  return "opencode";
+}
+function guardScriptLines(guard) {
+  return [
+    `guard=${shQuote(guard)}`,
+    'sh -c "$guard"',
+    "guard_code=$?",
+    'if [ "$guard_code" -ne 0 ]; then',
+    '  echo "guard exited $guard_code, skipping run"',
+    '  finish skipped "$guard_code"',
+    "  exit 0",
+    "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`;
+function extractSessionIdLines(target, indent = "") {
+  return [
+    `${indent}${target}="$(sed -n '${SESSION_ID_SED}' "$json_out" | head -n 1)"`
+  ];
+}
+function compactSessionLines() {
+  return [
+    "compact_session() {",
+    '  csid="$1"',
+    "  if ! command -v curl >/dev/null 2>&1; then",
+    '    echo "opencode-jobs: curl not available, skipping compaction"',
+    "    return 0",
+    "  fi",
+    '  serve_out="$(mktemp)"',
+    '  serve_err="$(mktemp)"',
+    `  OPENCODE_CONFIG_CONTENT='{"compaction":{"tail_turns":0}}' "$oc_bin" serve --port 0 >"$serve_out" 2>"$serve_err" &`,
+    "  serve_pid=$!",
+    '  serve_port=""',
+    "  tries=0",
+    '  while [ "$tries" -lt 100 ]; do',
+    String.raw`    serve_port="$(sed -n 's/.*listening on http:\/\/127\.0\.0\.1:\([0-9][0-9]*\).*/\1/p' "$serve_out" | head -n 1)"`,
+    '    if [ -n "$serve_port" ]; then break; fi',
+    '    if ! kill -0 "$serve_pid" 2>/dev/null; then break; fi',
+    "    sleep 0.1",
+    "    tries=$((tries + 1))",
+    "  done",
+    '  if [ -z "$serve_port" ]; then',
+    '    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',
+    '    rm -f "$serve_out" "$serve_err"',
+    "    return 0",
+    "  fi",
+    "  healthy=0",
+    "  tries=0",
+    '  while [ "$tries" -lt 50 ]; do',
+    '    if curl -s -o /dev/null --max-time 2 "http://127.0.0.1:$serve_port/global/health"; then',
+    "      healthy=1",
+    "      break",
+    "    fi",
+    '    if ! kill -0 "$serve_pid" 2>/dev/null; then break; fi',
+    "    sleep 0.2",
+    "    tries=$((tries + 1))",
+    "  done",
+    '  if [ "$healthy" -ne 1 ]; then',
+    '    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"',
+    "    return 0",
+    "  fi",
+    '  cs_provider=""',
+    '  cs_model=""',
+    '  case "$oc_model" in',
+    "    */*)",
+    '      cs_provider="${oc_model%%/*}"',
+    '      cs_model="${oc_model#*/}"',
+    "      ;;",
+    "  esac",
+    '  if [ -z "$cs_provider" ]; then',
+    '    defaults="$(curl -s --max-time 10 "http://127.0.0.1:$serve_port/config/providers")"',
+    String.raw`    cs_provider="$(printf '%s\n' "$defaults" | sed -n '${DEFAULT_PROVIDER_SED}' | head -n 1)"`,
+    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 "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 "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 "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 "opencode-jobs: keeping last result failed (HTTP $http)"',
+    "    fi",
+    "  fi",
+    '  kill "$serve_pid" 2>/dev/null',
+    '  wait "$serve_pid" 2>/dev/null',
+    '  rm -f "$serve_out" "$serve_err"',
+    "}"
+  ];
+}
+function runScriptContent(job, scopeId, opencodeBin) {
+  const mode = job.session ?? "new";
+  const isTracked = mode !== "new";
+  const isCompact = mode === "compact" || mode === "compact+last";
+  const isKeepLast = mode === "compact+last";
+  return [
+    "#!/bin/sh",
+    "set -u",
+    `slug=${shQuote(job.slug)}`,
+    `scope=${shQuote(scopeId)}`,
+    `oc_bin=${shQuote(opencodeBin)}`,
+    'config_root="${XDG_CONFIG_HOME:-$HOME/.config}"',
+    'runs="$config_root/opencode/jobs/runs/$scope"',
+    'mkdir -p "$runs"',
+    'record_file="$runs/$slug.jsonl"',
+    ...isTracked ? [
+      '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_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_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","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",
+    `oc_command=${shQuote("command" in job.run ? job.run.command : "")}`,
+    `oc_args=${shQuote("command" in job.run ? job.run.arguments ?? "" : "")}`,
+    `oc_prompt=${shQuote("prompt" in job.run ? job.run.prompt : "")}`,
+    `oc_keep_last=${String(isKeepLast ? 1 : 0)}`,
+    "run_opencode() {",
+    '  sess="$1"',
+    '  use_json="$2"',
+    "  set -- run",
+    '  if [ -n "$oc_agent" ]; then set -- "$@" --agent "$oc_agent"; fi',
+    '  if [ -n "$oc_model" ]; then set -- "$@" --model "$oc_model"; fi',
+    '  if [ -n "$sess" ]; then set -- "$@" --session "$sess"; fi',
+    '  if [ "$use_json" -eq 1 ]; then set -- "$@" --format json; fi',
+    '  if [ "$oc_command_mode" -eq 1 ]; then',
+    '    set -- "$@" --command "$oc_command" -- "$oc_args"',
+    "  else",
+    '    set -- "$@" -- "$oc_prompt"',
+    "  fi",
+    '  "$oc_bin" "$@"',
+    "}",
+    ...isCompact ? compactSessionLines() : [],
+    ...isTracked ? [
+      'json_out="$(mktemp)"',
+      'run_opencode "$prev_session" 1 >"$json_out" 2>&1',
+      "code=$?",
+      '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 "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',
+      "  code=$?",
+      '  cat "$json_out"',
+      ...extractSessionIdLines("new_session", "  "),
+      "fi",
+      'cs_text=""',
+      'if [ "$oc_keep_last" -eq 1 ]; then',
+      `  cs_text="$(awk '`,
+      '    /"type":"text"/ {',
+      "      line = $0",
+      String.raw`      i = index(line, "\042text\042:\042")`,
+      "      if (i == 0) next",
+      "      i = i + 8",
+      '      out = ""',
+      "      len = length(line)",
+      "      while (i <= len) {",
+      "        c = substr(line, i, 1)",
+      String.raw`        if (c == "\\") {`,
+      "          out = out substr(line, i, 2)",
+      "          i = i + 2",
+      "          continue",
+      "        }",
+      String.raw`        if (c == "\042") break`,
+      "        out = out c",
+      "        i = i + 1",
+      "      }",
+      "      result = out",
+      "      n = n + 1",
+      "    }",
+      "    END {",
+      "      if (n > 0) {",
+      "        if (length(result) > 16000) {",
+      "          result = substr(result, 1, 16000)",
+      String.raw`          if (substr(result, 16000, 1) == "\\") result = substr(result, 1, 15999)`,
+      "        }",
+      "        print result",
+      "      }",
+      "    }",
+      `  ' "$json_out")"`,
+      "fi",
+      'rm -f "$json_out"',
+      'if [ -n "$new_session" ]; then',
+      String.raw`  printf '%s\n' "$new_session" >"$state_file"`,
+      "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",
+    "exit 0",
+    ""
+  ].join(`
+`);
+}
+function serviceContent(job, options) {
+  const timeout = job.timeoutSeconds !== undefined && job.timeoutSeconds > 0 ? `TimeoutStartSec=${String(job.timeoutSeconds)}s` : "TimeoutStartSec=infinity";
+  const lines = [
+    "[Unit]",
+    `Description=OpenCode job: ${escapeUnitText(job.name)} (${job.slug})`,
+    "",
+    "[Service]",
+    "Type=oneshot",
+    `WorkingDirectory=${unitQuote(options.workdir)}`,
+    `Environment=${unitQuote(`PATH=${options.pathEnvironment}`)}`,
+    `ExecStart=/bin/sh ${unitQuote(options.runScript)}`,
+    timeout,
+    `StandardOutput=append:${unitQuote(options.log)}`,
+    `StandardError=append:${unitQuote(options.log)}`
+  ];
+  return `${lines.join(`
+`)}
+`;
+}
+function timerContent(job, onCalendars) {
+  return [
+    "[Unit]",
+    `Description=OpenCode job timer: ${escapeUnitText(job.name)} (${job.slug})`,
+    "",
+    "[Timer]",
+    ...onCalendars.map((calendar) => `OnCalendar=${calendar}`),
+    "Persistent=true",
+    "",
+    "[Install]",
+    "WantedBy=timers.target",
+    ""
+  ].join(`
+`);
+}
 function systemctl(systemctlArguments) {
   const result = spawnSync("systemctl", ["--user", ...systemctlArguments], {
     encoding: "utf8"
@@ -316,30 +839,188 @@ function systemctl(systemctlArguments) {
     stderr: result.stderr.trim()
   };
 }
+function systemdHint(stderr) {
+  if (/failed to connect|not connected|dbus/i.test(stderr)) {
+    return `
+Hint: no systemd user session is reachable. Over SSH try enabling lingering: loginctl enable-linger $USER`;
+  }
+  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",
+    timerUnit(base),
+    "-p",
+    "NextElapseUSecRealtime",
+    "-p",
+    "LastTriggerUSec",
+    "--value"
+  ]);
+  if (!result.ok)
+    return { next: undefined, last: undefined };
+  const [next = "n/a", last = "n/a"] = result.stdout.split(`
+`, 2);
+  return {
+    next: next === "n/a" ? undefined : next,
+    last: last === "n/a" ? undefined : last
+  };
+}
+function writeJobUnits(job, workdir, scopeId, opencodeBin, pathEnvironment) {
+  const script = runScriptPath(scopeId, job.slug);
+  const base = unitBase(scopeId, job.slug);
+  mkdirSync2(logDirectory(scopeId), { recursive: true });
+  mkdirSync2(runsDirectory(scopeId), { recursive: true });
+  atomicWriteExecutable(script, runScriptContent(job, scopeId, opencodeBin));
+  const onCalendars = cronToOnCalendar(parseCron(job.schedule));
+  atomicWrite(path4.join(systemdUserDirectory(), timerUnit(base)), timerContent(job, onCalendars));
+  atomicWrite(path4.join(systemdUserDirectory(), serviceUnit(base)), serviceContent(job, {
+    workdir: path4.resolve(workdir),
+    runScript: script,
+    log: logFile(scopeId, job.slug),
+    pathEnvironment
+  }));
+  return base;
+}
 function removeJobUnits(scopeId, slug) {
   const base = unitBase(scopeId, slug);
-  systemctl(["disable", "--now", timerUnit(base)]);
-  for (const file of [
-    path3.join(systemdUserDirectory(), timerUnit(base)),
-    path3.join(systemdUserDirectory(), serviceUnit(base))
-  ]) {
-    if (existsSync(file))
+  const files = [
+    path4.join(systemdUserDirectory(), timerUnit(base)),
+    path4.join(systemdUserDirectory(), serviceUnit(base))
+  ];
+  const script = runScriptPath(scopeId, slug);
+  if ([...files, script].every((file) => !existsSync2(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 (existsSync2(file))
       rmSync(file);
   }
-  const script = runScriptPath(scopeId, slug);
-  if (existsSync(script))
+  if (existsSync2(script))
     rmSync(script);
+  return;
+}
+function removeStaleUnits(scopeId, expectedSlugs) {
+  const prefix = `opencode-sched-${scopeId}-`;
+  const removed = [];
+  if (existsSync2(systemdUserDirectory())) {
+    for (const entry of readdirSync2(systemdUserDirectory())) {
+      if (!entry.startsWith(prefix))
+        continue;
+      if (!entry.endsWith(".service") && !entry.endsWith(".timer"))
+        continue;
+      const slug = entry.slice(prefix.length).replaceAll(/\.(service|timer)$/g, "");
+      if (!expectedSlugs.has(slug)) {
+        rmSync(path4.join(systemdUserDirectory(), entry));
+        removed.push(slug);
+      }
+    }
+  }
+  if (existsSync2(scopeDirectory(scopeId))) {
+    const entries = readdirSync2(scopeDirectory(scopeId));
+    for (const entry of entries) {
+      const match = /^run-(.+)\.sh$/.exec(entry);
+      if (match === null)
+        continue;
+      const [, slug = ""] = match;
+      if (!expectedSlugs.has(slug))
+        rmSync(path4.join(scopeDirectory(scopeId), entry));
+    }
+  }
+  return removed;
 }
 
 // src/project.ts
+function enableProject(workdir) {
+  if (process.platform !== "linux")
+    throw new Error("Scheduled jobs are only supported on Linux (systemd user units)");
+  const { jobs, errors } = loadJobs(workdir);
+  if (errors.length > 0)
+    throw new Error(`Invalid job definitions:
+${errors.join(`
+`)}`);
+  if (jobs.length === 0) {
+    throw new Error(`No job definitions found in ${jobsDirectory(workdir)}. Create one with schedule_job first.`);
+  }
+  const abs = path5.resolve(workdir);
+  const scopeId = deriveScopeId(abs);
+  const opencodeBin = findOpencode();
+  const pathEnvironment = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  const bases = jobs.map((job) => writeJobUnits(job, abs, scopeId, opencodeBin, pathEnvironment));
+  const removed = removeStaleUnits(scopeId, new Set(jobs.map((job) => job.slug)));
+  const reload = systemctl(["daemon-reload"]);
+  if (!reload.ok)
+    throw new Error(`systemctl --user daemon-reload failed: ${reload.stderr}${systemdHint(reload.stderr)}`);
+  const failures = [];
+  for (const base of bases) {
+    const enable = systemctl(["enable", "--now", timerUnit(base)]);
+    if (!enable.ok)
+      failures.push(`${timerUnit(base)}: ${enable.stderr}${systemdHint(enable.stderr)}`);
+  }
+  const registry = loadRegistry();
+  const previous = registry.projects[abs];
+  registry.projects[abs] = {
+    scopeId,
+    workdir: abs,
+    enabledAt: previous?.enabledAt ?? nowIso(),
+    updatedAt: nowIso(),
+    jobs: jobs.map((job) => job.slug)
+  };
+  saveRegistry(registry);
+  const lines = [
+    `Enabled ${String(jobs.length)} job(s) for ${abs} (scope ${scopeId})`
+  ];
+  if (removed.length > 0)
+    lines.push(`Removed stale units for deleted jobs: ${removed.join(", ")}`);
+  lines.push(...describeJobSchedules(jobs, scopeId));
+  if (failures.length > 0)
+    throw new Error(`Timer activation failures:
+${failures.join(`
+`)}`);
+  return lines.join(`
+`);
+}
+function describeJobSchedules(jobs, scopeId) {
+  const lines = [];
+  for (const job of jobs) {
+    const sets = parseCron(job.schedule);
+    const next = timerStatus(unitBase(scopeId, job.slug)).next;
+    const nextDesc = next === undefined ? "" : `, next: ${next}`;
+    lines.push(`- ${job.slug}: ${job.schedule} (${describeCron(sets)})${nextDesc}`);
+  }
+  return lines;
+}
 function disableProject(workdir) {
-  const abs = path4.resolve(workdir);
+  const abs = path5.resolve(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;
@@ -352,6 +1033,82 @@ function disableProject(workdir) {
 `);
 }
 
+// src/migration.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync2, rmdirSync } from "node:fs";
+import path6 from "node:path";
+function legacyJobsStateDirectory() {
+  return path6.join(configRoot(), "opencode", "scheduler");
+}
+function legacyRegistryPath() {
+  return path6.join(legacyJobsStateDirectory(), "registry.json");
+}
+function legacyDefinitionsDirectory(workdir) {
+  return path6.join(workdir, ".opencode", "scheduler", "jobs");
+}
+function migrationMoves(projects) {
+  return [
+    {
+      from: legacyJobsStateDirectory(),
+      to: jobsStateDirectory()
+    },
+    {
+      from: path6.join(configRoot(), "opencode", "logs", "scheduler"),
+      to: path6.join(configRoot(), "opencode", "logs", "jobs")
+    },
+    {
+      from: path6.join(stateRoot(), "opencode", "scheduler", "worktrees"),
+      to: path6.join(stateRoot(), "opencode", "jobs", "worktrees")
+    },
+    ...[...projects].map((workdir) => ({
+      from: legacyDefinitionsDirectory(workdir),
+      to: jobsDirectory(workdir)
+    }))
+  ];
+}
+function removeLegacyProjectDirectory(workdir) {
+  try {
+    rmdirSync(path6.join(workdir, ".opencode", "scheduler"));
+  } catch {}
+}
+function migrateStorage(projectDirectory, shouldResync) {
+  const project = path6.resolve(projectDirectory);
+  const legacyRegistry = legacyRegistryPath();
+  const canonicalRegistry = path6.join(jobsStateDirectory(), "registry.json");
+  const registryFile = existsSync3(legacyRegistry) ? legacyRegistry : canonicalRegistry;
+  const registry = existsSync3(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 }) => existsSync3(from));
+  for (const { from, to } of moves) {
+    if (existsSync3(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) {
+    mkdirSync3(path6.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/install.ts
 var PACKAGE_NAME = "opencode-jobs";
 var SKILL_NAME = "opencode-jobs";
@@ -362,20 +1119,20 @@ var configSchema = z3.looseObject({
 var CONFIG_LOCATIONS = [
   "opencode.json",
   "opencode.jsonc",
-  path5.join(".opencode", "opencode.json"),
-  path5.join(".opencode", "opencode.jsonc")
+  path7.join(".opencode", "opencode.json"),
+  path7.join(".opencode", "opencode.jsonc")
 ];
 function existingConfigPath(projectDirectory) {
   for (const relativePath of CONFIG_LOCATIONS) {
-    const configPath = path5.join(projectDirectory, relativePath);
-    if (existsSync2(configPath))
+    const configPath = path7.join(projectDirectory, relativePath);
+    if (existsSync4(configPath))
       return configPath;
   }
   return;
 }
 function readConfig(configPath) {
   try {
-    const value = JSON.parse(readFileSync2(configPath, "utf8"));
+    const value = JSON.parse(readFileSync3(configPath, "utf8"));
     const result = configSchema.safeParse(value);
     return result.success ? result.data : undefined;
   } catch {
@@ -392,7 +1149,7 @@ function isPackageReference(entry) {
 }
 function installPluginConfig(projectDirectory) {
   const existingPath = existingConfigPath(projectDirectory);
-  const configPath = existingPath ?? path5.join(projectDirectory, "opencode.json");
+  const configPath = existingPath ?? path7.join(projectDirectory, "opencode.json");
   if (existingPath === undefined) {
     atomicWrite(configPath, `${JSON.stringify({
       $schema: CONFIG_SCHEMA,
@@ -414,34 +1171,36 @@ function installPluginConfig(projectDirectory) {
   return { status: "added", configPath };
 }
 function installSkill(projectDirectory, packageDirectory) {
-  const sourcePath = path5.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
-  const skillPath = path5.join(projectDirectory, ".opencode", "skills", SKILL_NAME, "SKILL.md");
-  const content = readFileSync2(sourcePath, "utf8");
-  if (existsSync2(skillPath) && readFileSync2(skillPath, "utf8") === content) {
+  const sourcePath = path7.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
+  const skillPath = path7.join(projectDirectory, ".opencode", "skills", SKILL_NAME, "SKILL.md");
+  const content = readFileSync3(sourcePath, "utf8");
+  if (existsSync4(skillPath) && readFileSync3(skillPath, "utf8") === content) {
     return { status: "unchanged", skillPath };
   }
   atomicWrite(skillPath, content);
   return { status: "written", skillPath };
 }
 function installProject(projectDirectory, packageDirectory) {
-  const resolvedProject = path5.resolve(projectDirectory);
-  if (!existsSync2(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
+  const resolvedProject = path7.resolve(projectDirectory);
+  if (!existsSync4(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
     throw new Error(`Project directory does not exist: ${resolvedProject}`);
   }
+  const migration = migrateStorage(resolvedProject, true);
   return {
     projectDirectory: resolvedProject,
     plugin: installPluginConfig(resolvedProject),
-    skill: installSkill(resolvedProject, packageDirectory)
+    skill: installSkill(resolvedProject, packageDirectory),
+    ...migration.moved.length > 0 && { migration }
   };
 }
 function removeDirectoryIfEmpty(directory) {
   try {
-    rmdirSync(directory);
+    rmdirSync2(directory);
   } catch {}
 }
 function uninstallPluginConfig(projectDirectory) {
   const existingPath = existingConfigPath(projectDirectory);
-  const configPath = existingPath ?? path5.join(projectDirectory, "opencode.json");
+  const configPath = existingPath ?? path7.join(projectDirectory, "opencode.json");
   if (existingPath === undefined)
     return { status: "absent", configPath };
   const config = readConfig(configPath);
@@ -465,21 +1224,21 @@ function uninstallPluginConfig(projectDirectory) {
   return { status: "removed", configPath };
 }
 function uninstallSkill(projectDirectory, packageDirectory) {
-  const sourcePath = path5.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
-  const skillDirectory = path5.join(projectDirectory, ".opencode", "skills", SKILL_NAME);
-  const skillPath = path5.join(skillDirectory, "SKILL.md");
-  if (!existsSync2(skillPath))
+  const sourcePath = path7.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
+  const skillDirectory = path7.join(projectDirectory, ".opencode", "skills", SKILL_NAME);
+  const skillPath = path7.join(skillDirectory, "SKILL.md");
+  if (!existsSync4(skillPath))
     return { status: "absent", skillPath };
-  if (readFileSync2(skillPath, "utf8") !== readFileSync2(sourcePath, "utf8")) {
+  if (readFileSync3(skillPath, "utf8") !== readFileSync3(sourcePath, "utf8")) {
     return { status: "kept-modified", skillPath };
   }
   rmSync2(skillDirectory, { recursive: true, force: true });
-  removeDirectoryIfEmpty(path5.dirname(skillDirectory));
-  removeDirectoryIfEmpty(path5.join(projectDirectory, ".opencode"));
+  removeDirectoryIfEmpty(path7.dirname(skillDirectory));
+  removeDirectoryIfEmpty(path7.join(projectDirectory, ".opencode"));
   return { status: "removed", skillPath };
 }
 function purgeProjectData(projectDirectory) {
-  const abs = path5.resolve(projectDirectory);
+  const abs = path7.resolve(projectDirectory);
   const scopeId = deriveScopeId(abs);
   const targets = [
     scopeDirectory(scopeId),
@@ -488,11 +1247,11 @@ function purgeProjectData(projectDirectory) {
     logDirectory(scopeId),
     locksDirectory(scopeId),
     worktreesDirectory(scopeId),
-    path5.join(abs, ".opencode", "scheduler")
+    path7.join(abs, ".opencode", "jobs")
   ];
   const paths = [];
   for (const target of targets) {
-    if (!existsSync2(target))
+    if (!existsSync4(target))
       continue;
     rmSync2(target, { recursive: true, force: true });
     paths.push(target);
@@ -500,14 +1259,15 @@ function purgeProjectData(projectDirectory) {
   if (paths.includes(worktreesDirectory(scopeId))) {
     spawnSync2("git", ["-C", abs, "worktree", "prune"], { stdio: "ignore" });
   }
-  removeDirectoryIfEmpty(path5.join(abs, ".opencode"));
+  removeDirectoryIfEmpty(path7.join(abs, ".opencode"));
   return { paths };
 }
 function uninstallProject(projectDirectory, packageDirectory, shouldPurge) {
-  const resolvedProject = path5.resolve(projectDirectory);
-  if (!existsSync2(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
+  const resolvedProject = path7.resolve(projectDirectory);
+  if (!existsSync4(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
     throw new Error(`Project directory does not exist: ${resolvedProject}`);
   }
+  const migration = migrateStorage(resolvedProject, false);
   const wasEnabled = registryEntry(resolvedProject) !== undefined;
   if (wasEnabled)
     disableProject(resolvedProject);
@@ -515,30 +1275,213 @@ function uninstallProject(projectDirectory, packageDirectory, shouldPurge) {
     projectDirectory: resolvedProject,
     disabled: wasEnabled,
     plugin: uninstallPluginConfig(resolvedProject),
-    skill: uninstallSkill(resolvedProject, packageDirectory)
+    skill: uninstallSkill(resolvedProject, packageDirectory),
+    ...migration.moved.length > 0 && { migration }
   };
   if (shouldPurge)
     uninstall.purge = purgeProjectData(resolvedProject);
   return uninstall;
 }
 
+// src/management.ts
+import { spawn } from "node:child_process";
+import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync } from "node:fs";
+import path8 from "node:path";
+
+// src/runs.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { z as z4 } from "zod";
+var optionalString = z4.string().optional().catch(undefined);
+var optionalNumber = z4.number().optional().catch(undefined);
+var runRecordSchema = z4.object({
+  runId: optionalString,
+  slug: optionalString,
+  scopeId: optionalString,
+  startedAt: optionalNumber,
+  finishedAt: optionalNumber,
+  durationMs: optionalNumber,
+  status: optionalString,
+  exitCode: optionalNumber,
+  sessionId: optionalString,
+  startedBy: optionalString,
+  worktreeBranch: optionalString,
+  worktreeCommit: optionalString
+});
+function readRunRecords(scopeId, slug, limit) {
+  const file = runsFile(scopeId, slug);
+  if (!existsSync5(file))
+    return [];
+  const records = [];
+  for (const line of readFileSync4(file, "utf8").split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    try {
+      const value = JSON.parse(line);
+      const result = runRecordSchema.safeParse(value);
+      if (result.success)
+        records.push(result.data);
+    } catch {}
+  }
+  return records.slice(-limit);
+}
+function lastFinishedRun(records) {
+  for (const record of records.toReversed()) {
+    if (record.status !== undefined && record.status !== "running")
+      return record;
+  }
+  return;
+}
+function timestampOf(record) {
+  if (record.finishedAt !== undefined)
+    return new Date(record.finishedAt * 1000).toISOString();
+  if (record.startedAt !== undefined)
+    return new Date(record.startedAt * 1000).toISOString();
+  return "?";
+}
+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}`;
+  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 (!existsSync5(file))
+    return;
+  const content = readFileSync4(file, "utf8").trimEnd();
+  if (content.length === 0)
+    return "";
+  const tail = content.split(`
+`).slice(-lines).join(`
+`);
+  return tail.length > maxChars ? `...${tail.slice(-maxChars)}` : tail;
+}
+
+// src/management.ts
+function tryParseCron(schedule) {
+  try {
+    return parseCron(schedule);
+  } catch {
+    return;
+  }
+}
+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)}`;
+  const lines = [header];
+  if (jobs.length === 0)
+    lines.push("No job definitions. Create one with schedule_job.");
+  for (const job of jobs) {
+    const scopeId = entry?.scopeId ?? deriveScopeId(directory);
+    const sets = tryParseCron(job.schedule);
+    if (sets === undefined) {
+      lines.push(`- ${job.slug}: INVALID schedule "${job.schedule}"`);
+      continue;
+    }
+    const records = readRunRecords(scopeId, job.slug, 20);
+    const last = lastFinishedRun(records);
+    const lastDesc = last === undefined ? ", last: never" : `, last: ${last.status ?? "?"} ${formatRunLine(last)}`;
+    const next = entry === undefined ? undefined : timerStatus(unitBase(scopeId, job.slug)).next;
+    const nextDesc = next === undefined ? "" : `, next: ${next}`;
+    lines.push(`- ${job.slug}: ${job.schedule} (${describeCron(sets)})${nextDesc}${lastDesc}`);
+  }
+  lines.push(...errors.map((error) => `! ${error}`));
+  return { ok: true, output: lines.join(`
+`) };
+}
+function runJobNow(slugInput, directory) {
+  const slug = slugify(slugInput);
+  const file = path8.join(jobsDirectory(directory), `${slug}.json`);
+  if (!existsSync6(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 (!existsSync6(script)) {
+    return {
+      ok: false,
+      output: `Run script missing for "${slug}". Run enable_project to (re)install units.`
+    };
+  }
+  const log = logFile(entry.scopeId, slug);
+  mkdirSync4(logDirectory(entry.scopeId), { recursive: true });
+  const fd = openSync(log, "a");
+  const child = spawn("/bin/sh", [script], {
+    cwd: path8.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/cli.ts
 var USAGE = `Usage: opencode-jobs <command> [projectDir]
 
 Commands:
   install [projectDir]            Add the plugin and bundled skill to a project (default: current directory)
   uninstall [projectDir] [--purge]  Remove the plugin entry, skill, and systemd units from a project;
-                                  --purge also deletes job definitions and scheduler data
+                                  --purge also deletes job definitions and job data
+  list [projectDir]               List jobs and their enabled, next-run, and last-run state
+  enable [projectDir]             Enable or re-sync all jobs in a project
+  disable [projectDir]            Disable all jobs in a project while keeping definitions and history
+  run <slug> [projectDir]         Run one enabled job immediately
   help                            Show this help`;
 function packageDirectory() {
-  return path6.resolve(path6.dirname(fileURLToPath(import.meta.url)), "..");
+  return path9.resolve(path9.dirname(fileURLToPath(import.meta.url)), "..");
 }
 function printError(message) {
-  console.error(`Error: ${message}
-
-${USAGE}`);
+  console.log(JSON.stringify({ ok: false, output: `Error: ${message}` }, undefined, 2));
+  console.error(USAGE);
   process.exitCode = 1;
 }
+function projectArgument(command, arguments_) {
+  if (arguments_.some((argument) => argument.startsWith("--"))) {
+    throw new Error(`${command} does not accept options`);
+  }
+  if (arguments_.length > 1) {
+    throw new Error(`${command} accepts at most one project directory`);
+  }
+  return arguments_[0] ?? process.cwd();
+}
+function runArguments(arguments_) {
+  if (arguments_.some((argument) => argument.startsWith("--"))) {
+    throw new Error("run does not accept options");
+  }
+  if (arguments_.length === 0 || arguments_.length > 2) {
+    throw new Error("run requires a job slug and accepts one project directory");
+  }
+  return {
+    slug: arguments_[0] ?? "",
+    project: arguments_[1] ?? process.cwd()
+  };
+}
+function printManagementResult(result) {
+  console.log(JSON.stringify(result, undefined, 2));
+  if (!result.ok)
+    process.exitCode = 1;
+}
 function parseUninstallArguments(arguments_) {
   let project;
   let shouldPurge = false;
@@ -588,6 +1531,43 @@ if ([undefined, "help", "--help"].includes(command)) {
   } catch (error) {
     printError(errorMessage(error));
   }
+} else if (command !== undefined && ["list", "enable", "disable", "run"].includes(command)) {
+  try {
+    let slug;
+    let project;
+    if (command === "run") {
+      ({ slug, project } = runArguments(rest));
+    } else {
+      project = projectArgument(command, rest);
+    }
+    const migration = migrateStorage(project, true);
+    for (const warning of migration.warnings) {
+      console.error(`storage migration warning: ${warning}`);
+    }
+    switch (command) {
+      case "list": {
+        printManagementResult(listJobs(project));
+        break;
+      }
+      case "enable": {
+        printManagementResult({ ok: true, output: enableProject(project) });
+        break;
+      }
+      case "disable": {
+        printManagementResult({ ok: true, output: disableProject(project) });
+        break;
+      }
+      case "run": {
+        printManagementResult(runJobNow(slug ?? "", project));
+        break;
+      }
+      default: {
+        throw new Error(`unknown management command: ${command}`);
+      }
+    }
+  } catch (error) {
+    printError(errorMessage(error));
+  }
 } else {
   printError(`unknown command: ${command ?? "(missing)"}`);
 }