opencode-jobs 0.1.0

package/dist/index.js

@@ -0,0 +1,1312 @@
+// @bun
+// src/tools.ts
+import {
+  tool
+} from "@opencode-ai/plugin";
+import {
+  closeSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  openSync,
+  readFileSync as readFileSync4,
+  rmSync as rmSync2
+} from "fs";
+import { spawn } from "child_process";
+import path6 from "path";
+
+// src/cron.ts
+var DOW_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var DOW_NAMES = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+var MONTH_NAMES = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+function parseBound(raw, field, min, max, names) {
+  const trimmed = raw.trim().toLowerCase();
+  const named = names?.[trimmed];
+  if (named !== undefined)
+    return named;
+  if (!/^\d+$/.test(trimmed))
+    throw new Error(`Invalid ${field} value "${raw}" in cron expression`);
+  const value = Number(trimmed);
+  if (value < min || value > max)
+    throw new Error(`${field} value ${String(value)} out of range ${String(min)}-${String(max)} in cron expression`);
+  return value;
+}
+function parseCronField(raw, field, min, max, names) {
+  if (raw.length === 0)
+    throw new Error(`Empty ${field} field in cron expression`);
+  const values = new Set;
+  for (const part of raw.split(",")) {
+    if (part.length === 0)
+      throw new Error(`Empty ${field} item in cron expression "${raw}"`);
+    const [rangePart = "", stepPart] = part.split("/", 2);
+    if (stepPart !== undefined && (!/^\d+$/.test(stepPart) || Number(stepPart) < 1)) {
+      throw new Error(`Invalid step "/${stepPart}" in ${field} field`);
+    }
+    const step = stepPart === undefined ? 1 : Number(stepPart);
+    let lo;
+    let hi;
+    if (rangePart === "*") {
+      lo = min;
+      hi = max;
+    } else if (rangePart.includes("-")) {
+      const pieces = rangePart.split("-");
+      if (pieces.length !== 2)
+        throw new Error(`Invalid range "${rangePart}" in ${field} field`);
+      const [loPart = "", hiPart = ""] = pieces;
+      lo = parseBound(loPart, field, min, max, names);
+      hi = parseBound(hiPart, field, min, max, names);
+      if (lo > hi)
+        throw new Error(`Descending range "${rangePart}" in ${field} field`);
+    } else {
+      lo = parseBound(rangePart, field, min, max, names);
+      hi = stepPart === undefined ? lo : max;
+    }
+    for (let v = lo;v <= hi; v += step) {
+      values.add(field === "dow" && v === 7 ? 0 : v);
+    }
+  }
+  return [...values].toSorted((a, b) => a - b);
+}
+function parseCron(expression) {
+  const fields = expression.trim().split(/\s+/);
+  if (fields.length !== 5)
+    throw new Error(`Expected 5-field cron expression, got ${String(fields.length)} fields: "${expression}"`);
+  const [minute = "", hour = "", dom = "", month = "", dow = ""] = fields;
+  return {
+    minute: parseCronField(minute, "minute", 0, 59),
+    hour: parseCronField(hour, "hour", 0, 23),
+    dom: parseCronField(dom, "day of month", 1, 31),
+    month: parseCronField(month, "month", 1, 12, MONTH_NAMES),
+    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/paths.ts
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "fs";
+import { createHash } from "crypto";
+import path from "path";
+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 registryPath() {
+  return path.join(schedulerDirectory(), "registry.json");
+}
+function scopeDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "scopes", scopeId);
+}
+function runsDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "runs", scopeId);
+}
+function runsFile(scopeId, slug) {
+  return path.join(runsDirectory(scopeId), `${slug}.jsonl`);
+}
+function sessionStateDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "sessions", scopeId);
+}
+function sessionStateFile(scopeId, slug) {
+  return path.join(sessionStateDirectory(scopeId), `${slug}.txt`);
+}
+function logDirectory(scopeId) {
+  return path.join(configRoot(), "opencode", "logs", "scheduler", 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", "scheduler", "jobs");
+}
+function unitBase(scopeId, slug) {
+  return `opencode-sched-${scopeId}-${slug}`;
+}
+function timerUnit(base) {
+  return `${base}.timer`;
+}
+function serviceUnit(base) {
+  return `${base}.service`;
+}
+function runScriptPath(scopeId, slug) {
+  return path.join(scopeDirectory(scopeId), `run-${slug}.sh`);
+}
+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);
+  return `${slugify(path.basename(abs))}-${hash}`;
+}
+
+// src/job.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import path2 from "path";
+
+// src/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringProperty(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+function numberProperty(record, key) {
+  const value = record[key];
+  return typeof value === "number" ? value : undefined;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/job.ts
+var SESSION_MODES = [
+  "new",
+  "persist",
+  "compact",
+  "compact+last"
+];
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function validateRunSpec(run, context) {
+  if (!isRecord(run))
+    throw new Error(`${context}: "run" must be an object`);
+  const prompt = nonEmptyString(run.prompt);
+  const command = nonEmptyString(run.command);
+  if (prompt !== undefined === (command !== undefined)) {
+    throw new Error(`${context}: "run" must set exactly one of "prompt" (natural language) or "command" (custom command name)`);
+  }
+  const commandArguments = stringProperty(run, "arguments");
+  const agent = stringProperty(run, "agent");
+  const model = stringProperty(run, "model");
+  if (command !== undefined) {
+    return {
+      command,
+      ...commandArguments !== undefined && { arguments: commandArguments },
+      ...agent !== undefined && { agent },
+      ...model !== undefined && { model }
+    };
+  }
+  if (commandArguments !== undefined) {
+    throw new Error(`${context}: "run.arguments" only applies to command jobs`);
+  }
+  return {
+    prompt: prompt ?? "",
+    ...agent !== undefined && { agent },
+    ...model !== undefined && { model }
+  };
+}
+function validateSession(value, context) {
+  if (value === undefined)
+    return "new";
+  const mode = typeof value === "string" ? SESSION_MODES.find((candidate) => candidate === value) : undefined;
+  if (mode === undefined) {
+    throw new Error(`${context}: "session" must be one of ${SESSION_MODES.map((candidate) => `"${candidate}"`).join(", ")}`);
+  }
+  return mode;
+}
+function validateTimeout(value, context) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${context}: "timeoutSeconds" must be a non-negative integer`);
+  }
+  return value;
+}
+function validateGuard(value, context) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${context}: "guard" must be a non-empty shell command string`);
+  }
+  return value;
+}
+function loadJobFile(file, expectedSlug) {
+  const stem = path2.basename(file).replaceAll(/\.json$/g, "");
+  try {
+    const object = JSON.parse(readFileSync(file, "utf8"));
+    if (!isRecord(object))
+      return { ok: false, error: `${stem}.json: not a job object` };
+    const slug = stringProperty(object, "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 name = nonEmptyString(object.name);
+    if (name === undefined)
+      return { ok: false, error: `${stem}.json: "name" is required` };
+    const schedule = stringProperty(object, "schedule") ?? "";
+    try {
+      parseCron(schedule);
+    } catch (error) {
+      return { ok: false, error: `${stem}.json: ${errorMessage(error)}` };
+    }
+    const run = validateRunSpec(object.run, `${stem}.json`);
+    const session = validateSession(object.session, `${stem}.json`);
+    const guard = validateGuard(object.guard, `${stem}.json`);
+    const timeoutSeconds = validateTimeout(object.timeoutSeconds, `${stem}.json`);
+    return {
+      ok: true,
+      job: {
+        slug,
+        name,
+        schedule,
+        run,
+        ...session !== "new" && { session },
+        ...guard !== undefined && { guard },
+        ...timeoutSeconds !== undefined && { timeoutSeconds },
+        createdAt: stringProperty(object, "createdAt") ?? nowIso(),
+        updatedAt: stringProperty(object, "updatedAt") ?? nowIso()
+      }
+    };
+  } 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
+  };
+}
+function saveJob(workdir, job) {
+  atomicWrite(path2.join(jobsDirectory(workdir), `${job.slug}.json`), `${JSON.stringify(job, undefined, 2)}
+`);
+}
+
+// src/registry.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+function isRegistryEntry(value) {
+  if (!isRecord(value))
+    return false;
+  return stringProperty(value, "scopeId") !== undefined && stringProperty(value, "workdir") !== undefined && stringProperty(value, "enabledAt") !== undefined && stringProperty(value, "updatedAt") !== undefined && Array.isArray(value.jobs) && value.jobs.every((job) => typeof job === "string");
+}
+function loadRegistry() {
+  try {
+    const parsed = JSON.parse(readFileSync2(registryPath(), "utf8"));
+    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.projects)) {
+      return { version: 1, projects: {} };
+    }
+    const projects = {};
+    for (const [key, value] of Object.entries(parsed.projects)) {
+      if (isRegistryEntry(value))
+        projects[key] = value;
+    }
+    return { version: 1, projects };
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+function saveRegistry(registry) {
+  atomicWrite(registryPath(), `${JSON.stringify(registry, undefined, 2)}
+`);
+}
+function registryEntry(workdir) {
+  return loadRegistry().projects[path3.resolve(workdir)];
+}
+
+// src/runs.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+function parseRunRecord(value) {
+  const runId = stringProperty(value, "runId");
+  const slug = stringProperty(value, "slug");
+  const scopeId = stringProperty(value, "scopeId");
+  const startedAt = numberProperty(value, "startedAt");
+  const finishedAt = numberProperty(value, "finishedAt");
+  const durationMs = numberProperty(value, "durationMs");
+  const status = stringProperty(value, "status");
+  const exitCode = numberProperty(value, "exitCode");
+  const sessionId = stringProperty(value, "sessionId");
+  const startedBy = stringProperty(value, "startedBy");
+  return {
+    ...runId !== undefined && { runId },
+    ...slug !== undefined && { slug },
+    ...scopeId !== undefined && { scopeId },
+    ...startedAt !== undefined && { startedAt },
+    ...finishedAt !== undefined && { finishedAt },
+    ...durationMs !== undefined && { durationMs },
+    ...status !== undefined && { status },
+    ...exitCode !== undefined && { exitCode },
+    ...sessionId !== undefined && { sessionId },
+    ...startedBy !== undefined && { startedBy }
+  };
+}
+function readRunRecords(scopeId, slug, limit) {
+  const file = runsFile(scopeId, slug);
+  if (!existsSync2(file))
+    return [];
+  const records = [];
+  for (const line of readFileSync3(file, "utf8").split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    try {
+      const value = JSON.parse(line);
+      if (isRecord(value))
+        records.push(parseRunRecord(value));
+    } 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}`;
+  return `${timestampOf(record)} ${record.status ?? "?"}${code}${duration}${session} via ${record.startedBy ?? "?"}`;
+}
+function tailFile(file, lines, maxChars) {
+  if (!existsSync2(file))
+    return;
+  const content = readFileSync3(file, "utf8").trimEnd();
+  if (content.length === 0)
+    return "";
+  const tail = content.split(`
+`).slice(-lines).join(`
+`);
+  return tail.length > maxChars ? `...${tail.slice(-maxChars)}` : tail;
+}
+
+// src/systemd.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, rmSync } from "fs";
+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;
+  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 (existsSync3(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"
+  ];
+}
+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 "scheduler: 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 "scheduler: 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 "scheduler: 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 "scheduler: 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)"',
+    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"',
+    "  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)"',
+    "    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/scheduler/runs/$scope"',
+    'mkdir -p "$runs"',
+    'record_file="$runs/$slug.jsonl"',
+    ...isTracked ? [
+      'sessions="$config_root/opencode/scheduler/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}"',
+    'run_id="$(date +%s%N)-$$"',
+    "started=$(date +%s)",
+    'new_session=""',
+    `export OPENCODE_PERMISSION='{"question":"deny"}'`,
+    'export OPENCODE_SCHEDULER_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"`,
+    "}",
+    "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"`,
+    `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 "scheduler: 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",
+    '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"
+  });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout.trim(),
+    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 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 [
+    path4.join(systemdUserDirectory(), timerUnit(base)),
+    path4.join(systemdUserDirectory(), serviceUnit(base))
+  ]) {
+    if (existsSync3(file))
+      rmSync(file);
+  }
+  const script = runScriptPath(scopeId, slug);
+  if (existsSync3(script))
+    rmSync(script);
+}
+function removeStaleUnits(scopeId, expectedSlugs) {
+  const prefix = `opencode-sched-${scopeId}-`;
+  const removed = [];
+  if (existsSync3(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 (existsSync3(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
+import path5 from "path";
+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)
+    lines.push(`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 = 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 registry = loadRegistry();
+  const { [abs]: _omitted, ...remainingProjects } = registry.projects;
+  registry.projects = remainingProjects;
+  saveRegistry(registry);
+  return [
+    `Disabled ${String(entry.jobs.length)} job(s) for ${abs}`,
+    `Run history kept at ${runsDirectory(entry.scopeId)}`,
+    `Logs kept at ${logDirectory(entry.scopeId)}`
+  ].join(`
+`);
+}
+
+// src/tools.ts
+function ok(output) {
+  return { output };
+}
+function fail(message) {
+  return { output: `Error: ${message}`, metadata: { error: true } };
+}
+function tryParseCron(schedule) {
+  try {
+    return parseCron(schedule);
+  } catch {
+    return;
+  }
+}
+function listJobsOutput(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(lines.join(`
+`));
+}
+function scheduleJobOutput(input, directory) {
+  const slug = slugify(input.slug ?? input.name);
+  let sets;
+  try {
+    sets = parseCron(input.schedule);
+  } catch (error) {
+    return fail(errorMessage(error));
+  }
+  const run = validateRunSpec(input, "job");
+  const session = validateSession(input.session, "job");
+  const guard = validateGuard(input.guard, "job");
+  const timeoutSeconds = validateTimeout(input.timeoutSeconds, "job");
+  const existing = loadJobFile(path6.join(jobsDirectory(directory), `${slug}.json`), slug);
+  const job = {
+    slug,
+    name: input.name,
+    schedule: input.schedule,
+    run,
+    ...session !== "new" && { session },
+    ...guard !== undefined && { guard },
+    ...timeoutSeconds !== undefined && { timeoutSeconds },
+    createdAt: existing.ok ? existing.job.createdAt : nowIso(),
+    updatedAt: nowIso()
+  };
+  saveJob(directory, job);
+  const relativePath = `.opencode/scheduler/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}`);
+  const entry = registryEntry(directory);
+  if (entry === undefined) {
+    lines.push("Project not enabled yet. Run enable_project to install the systemd timer.");
+    return ok(lines.join(`
+`));
+  }
+  const abs = path6.resolve(directory);
+  const opencodeBin = findOpencode();
+  const pathEnvironment = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  const base = writeJobUnits(job, abs, entry.scopeId, opencodeBin, pathEnvironment);
+  const reload = systemctl(["daemon-reload"]);
+  const enable = systemctl(["enable", "--now", timerUnit(base)]);
+  if (!reload.ok || !enable.ok) {
+    const stderr = reload.ok ? enable.stderr : reload.stderr;
+    return fail(`Saved ${relativePath} but systemd re-sync failed: ${stderr}${systemdHint(stderr)}`);
+  }
+  if (!entry.jobs.includes(slug)) {
+    const registry = loadRegistry();
+    const current = registry.projects[abs];
+    if (current !== undefined) {
+      current.jobs = [...new Set([...current.jobs, slug])];
+      current.updatedAt = nowIso();
+      saveRegistry(registry);
+    }
+  }
+  const next = timerStatus(base).next;
+  const nextDesc = next === undefined ? "" : `, next run: ${next}`;
+  lines.push(`Re-synced systemd units (project enabled)${nextDesc}`);
+  return ok(lines.join(`
+`));
+}
+function showJobOutput(slugInput, directory) {
+  const file = path6.join(jobsDirectory(directory), `${slugify(slugInput)}.json`);
+  if (!existsSync4(file)) {
+    return fail(`No job "${slugInput}" in ${jobsDirectory(directory)}. Use list_jobs to see definitions.`);
+  }
+  const result = loadJobFile(file);
+  if (!result.ok)
+    return fail(result.error);
+  const job = result.job;
+  const sets = parseCron(job.schedule);
+  const entry = registryEntry(directory);
+  const scopeId = entry?.scopeId ?? deriveScopeId(directory);
+  const runDesc = "prompt" in job.run ? `prompt "${job.run.prompt}"` : `command "${job.run.command}"${job.run.arguments === undefined ? "" : ` "${job.run.arguments}"`}`;
+  const lines = [
+    `${job.name} (${job.slug})`,
+    `Schedule: ${job.schedule} \u2014 ${describeCron(sets)}`,
+    `Definition: .opencode/scheduler/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.session !== undefined) {
+    const state = sessionStateFile(scopeId, job.slug);
+    const sessionId = existsSync4(state) ? readFileSync4(state, "utf8").trim() : "";
+    lines.push(`Session: ${job.session}${sessionId.length > 0 ? ` \u2014 current ${sessionId}` : " \u2014 no session yet"}`);
+  }
+  if (job.run.agent !== undefined)
+    lines.push(`Agent: ${job.run.agent}`);
+  if (job.run.model !== undefined)
+    lines.push(`Model: ${job.run.model}`);
+  if (job.timeoutSeconds !== undefined && job.timeoutSeconds > 0) {
+    lines.push(`Timeout: ${String(job.timeoutSeconds)}s (systemd TimeoutStartSec)`);
+  }
+  if (entry === undefined) {
+    lines.push("Enabled: no (run enable_project to install the timer)");
+  } else {
+    const base = unitBase(scopeId, job.slug);
+    const status = timerStatus(base);
+    lines.push(`Enabled: yes (timer ${timerUnit(base)})`);
+    if (status.next !== undefined)
+      lines.push(`Next run: ${status.next}`);
+    if (status.last !== undefined)
+      lines.push(`Last trigger: ${status.last}`);
+    lines.push(`Log: ${logFile(scopeId, job.slug)}`);
+  }
+  const records = readRunRecords(scopeId, job.slug, 10);
+  if (records.length > 0) {
+    lines.push("Recent runs:");
+    for (const record of records.toReversed())
+      lines.push(`  ${formatRunLine(record)}`);
+  } else {
+    lines.push("Recent runs: none");
+  }
+  return ok(lines.join(`
+`));
+}
+function removeJobDefinitionOutput(slugInput, directory) {
+  const slug = slugify(slugInput);
+  const file = path6.join(jobsDirectory(directory), `${slug}.json`);
+  if (!existsSync4(file))
+    return fail(`No job "${slug}" in ${jobsDirectory(directory)}`);
+  rmSync2(file);
+  const lines = [
+    `Deleted job definition .opencode/scheduler/jobs/${slug}.json`
+  ];
+  const scopeId = registryEntry(directory)?.scopeId ?? deriveScopeId(directory);
+  const state = sessionStateFile(scopeId, slug);
+  if (existsSync4(state)) {
+    rmSync2(state);
+    lines.push(`Removed session state ${state}`);
+  }
+  const abs = path6.resolve(directory);
+  const entry = registryEntry(directory);
+  if (entry?.jobs.includes(slug)) {
+    removeJobUnits(entry.scopeId, slug);
+    systemctl(["daemon-reload"]);
+    const registry = loadRegistry();
+    const current = registry.projects[abs];
+    if (current !== undefined) {
+      current.jobs = current.jobs.filter((jobSlug) => jobSlug !== slug);
+      current.updatedAt = nowIso();
+      if (current.jobs.length === 0)
+        omitProject(registry, abs);
+      saveRegistry(registry);
+    }
+    lines.push("Removed systemd units (project was enabled)");
+  }
+  return ok(lines.join(`
+`));
+}
+function omitProject(registry, workdir) {
+  const { [workdir]: _omitted, ...remaining } = registry.projects;
+  registry.projects = remaining;
+}
+function runJobNowOutput(slugInput, directory) {
+  const slug = slugify(slugInput);
+  const file = path6.join(jobsDirectory(directory), `${slug}.json`);
+  if (!existsSync4(file))
+    return fail(`No job "${slug}" in ${jobsDirectory(directory)}`);
+  const entry = registryEntry(directory);
+  if (entry === undefined) {
+    return fail(`Project is not enabled, so no run script exists for "${slug}". Run enable_project first.`);
+  }
+  const script = runScriptPath(entry.scopeId, slug);
+  if (!existsSync4(script)) {
+    return fail(`Run script missing for "${slug}". Run enable_project to (re)install units.`);
+  }
+  const log = logFile(entry.scopeId, slug);
+  mkdirSync3(logDirectory(entry.scopeId), { recursive: true });
+  const fd = openSync(log, "a");
+  const child = spawn("/bin/sh", [script], {
+    cwd: path6.resolve(directory),
+    env: { ...process.env, OPENCODE_SCHEDULER_STARTED_BY: "manual" },
+    stdio: ["ignore", fd, fd]
+  });
+  child.unref();
+  closeSync(fd);
+  const tail = tailFile(log, 5, 2000);
+  const parts = [
+    `Started "${slug}" manually (pid ${String(child.pid)})`,
+    `Log: ${log}`
+  ];
+  if (tail?.length)
+    parts.push(`Log tail:
+${tail}`);
+  return ok(parts.join(`
+`));
+}
+function jobLogsOutput(slugInput, lineCountInput, directory) {
+  const entry = registryEntry(directory);
+  const scopeId = entry?.scopeId ?? deriveScopeId(directory);
+  const log = logFile(scopeId, slugify(slugInput));
+  const lineCount = Math.min(lineCountInput ?? 100, 500);
+  const tail = tailFile(log, lineCount, 20000);
+  if (tail === undefined)
+    return ok(`No log yet for "${slugInput}" (expected at ${log})`);
+  if (tail.length === 0)
+    return ok(`Log is empty: ${log}`);
+  return ok(`${log} (tail):
+${tail}`);
+}
+function listProjectsOutput() {
+  const registry = loadRegistry();
+  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"];
+  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(", ")}`);
+  }
+  return ok(lines.join(`
+`));
+}
+var listJobsTool = tool({
+  description: "List scheduled job definitions for the current project (from .opencode/scheduler/jobs/), including enabled state, next run, and last run status.",
+  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.",
+  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)'),
+    prompt: tool.schema.string().optional().describe("Natural language prompt the job runs via `opencode run`"),
+    command: tool.schema.string().optional().describe("Custom command name to run instead of a prompt"),
+    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'),
+    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"),
+    slug: tool.schema.string().optional().describe("URL-safe identifier; defaults to a slugified name")
+  },
+  execute: (input, context) => Promise.resolve(scheduleJobOutput(input, context.directory))
+});
+var showJobTool = tool({
+  description: "Show full details for one scheduled job: definition, cron description, systemd install state, and recent run history.",
+  args: {
+    slug: tool.schema.string().describe("Job slug (see list_jobs)")
+  },
+  execute: (input, context) => Promise.resolve(showJobOutput(input.slug, context.directory))
+});
+var jobDeletionTool = tool({
+  description: "Delete a scheduled job definition from the current project. If the project is enabled, its systemd units are removed too. Run history and logs are kept.",
+  args: {
+    slug: tool.schema.string().describe("Job slug to delete")
+  },
+  execute: (input, context) => Promise.resolve(removeJobDefinitionOutput(input.slug, context.directory))
+});
+var runJobTool = tool({
+  description: "Run a scheduled job immediately, fire-and-forget, using the exact frozen run script the timer would use. Appends to the same log and run history. The job's project must be enabled.",
+  args: {
+    slug: tool.schema.string().describe("Job slug to run now")
+  },
+  execute: (input, context) => Promise.resolve(runJobNowOutput(input.slug, context.directory))
+});
+var jobLogsTool = tool({
+  description: "Show the tail of a scheduled job's log file (scheduled and manual runs both append to it).",
+  args: {
+    slug: tool.schema.string().describe("Job slug"),
+    lines: tool.schema.number().optional().describe("Number of lines to show (default 100)")
+  },
+  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.",
+  args: {},
+  execute: (_input, context) => Promise.resolve(enableProjectOutput(context.directory))
+});
+function enableProjectOutput(directory) {
+  try {
+    return ok(enableProject(directory));
+  } catch (error) {
+    return fail(errorMessage(error));
+  }
+}
+var disableProjectTool = tool({
+  description: "Disable scheduled jobs for the current project: stops and removes its systemd timers/services and removes the registry entry. Job definitions stay in the repo, and run history/logs are kept.",
+  args: {},
+  execute: (_input, context) => Promise.resolve(disableProjectOutput(context.directory))
+});
+function disableProjectOutput(directory) {
+  try {
+    return ok(disableProject(directory));
+  } catch (error) {
+    return fail(errorMessage(error));
+  }
+}
+var listProjectsTool = tool({
+  description: "List all projects with enabled scheduled jobs from the global registry (~/.config/opencode/scheduler/registry.json).",
+  args: {},
+  execute: () => Promise.resolve(listProjectsOutput())
+});
+var schedulerTools = {
+  schedule_job: scheduleJobTool,
+  list_jobs: listJobsTool,
+  get_job: showJobTool,
+  delete_job: jobDeletionTool,
+  run_job: runJobTool,
+  job_logs: jobLogsTool,
+  enable_project: enableProjectTool,
+  disable_project: disableProjectTool,
+  list_projects: listProjectsTool
+};
+
+// src/index.ts
+var src_default = () => {
+  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 });
+};
+export {
+  src_default as default
+};