@bojackduy/opencode-loopd 1.6.1 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.7.0 (2026-08-25) — Scheduled Intervals
+
+> Interval requeue for repetitive dialogues — one `/goal` covers `monitor deploy` `periodic tests` `keep going` without manual re-prompt. `5s` `createScheduleWorker` resurrects `complete → active` with `Scheduled tick N/M`.
+
+### Added
+
+- **Scheduled intervals** — `GoalConfig.schedule {everyMs, maxRuns}` (`src/domain/goal.ts:100`), `scheduleEveryMs`/`scheduleMaxRuns` args on `loopd_create_goal` (`src/server/goal-tools.ts:56`), min 1000, `maxRuns` total incl initial (`src/server/goal-tools.ts:83` validation).
+- **Schedule worker** — `src/application/schedule-worker.ts:28` `createScheduleWorker` `intervalMs 5000` scans `complete` scheduled goals, `skip-if-running` (lease/`phase` `running/queued/compacting` + `workspaceWrite` single-writer gate `src/application/goal-service.ts:83`), resurrects `complete→active` `phase=idle` `lastScheduleAt`, injects inbox `Scheduled tick N/M — re-execute objective`, then `continueTurn`.
+- **State v6** — `CURRENT_VERSION 6` `src/infrastructure/state-repository.ts:12`, `scheduleRunCount`/`nextRunAt`/`lastScheduleAt` on `GoalRuntimeState` (`src/domain/runtime.ts:115`), `v5→v6` migration with validation, `createRuntimeState` init `scheduleRunCount 0` (`src/application/goal-service.ts:225`), `complete_goal` counts `scheduleRunCount` and sets `nextRunAt=now+everyMs` while `count < maxRuns` and clears stale lease `leaseExpiresAt`/`activeRunID` (`src/server/goal-tools.ts:377` fix).
+- **Plugin wiring** — `createScheduleWorker` started lazily with `engine`+`worker` in `src/server/plugin.ts:31`, `dispose` stops it.
+- **Owner visibility** — `inspect_background_goal` exposes `config.schedule` + `runtime scheduleRunCount/nextRunAt/lastScheduleAt` (`src/server/owner-tools.ts:105`, `src/server/goal-tools.ts:540`).
+- **Tests** — `test/application/schedule-worker.test.ts:1` 6 tests (resurrect due, skip-if-running, maxRuns, writer serialization, concurrent `workspaceWrite:false`, future `nextRunAt`); `test/infrastructure/state-store.test.ts:42` updated to `version 6`; total `165` pass.
+
+### Fixed
+
+- **Stale lease blocked schedule** — `complete_goal` now clears `leaseExpiresAt`/`turnStartedAt`/`activeRunID`/`activePromptMessageID` on `complete`; previous left `5m` lease valid while `phase idle`, so `schedule.tick` saw `leaseIsValid` and skipped until expiry.
+
+### Live proof
+
+- `sched-live-verify` `09cb837c` `10s` `maxRuns 3` `workspaceWrite:false` → `tick.txt` `3` lines `02:00:56` `02:03:43` `02:05:47` `runCount 3` `scheduleRunCount 3` `nextRunAt None` `165` tests still pass; `schedule.tick` events `02:01:29` `02:04:29`.
+
 ## 1.6.0 (2026-08-24) — Hardened Lifecycle
 
 > Merge `feat/goal-evaluation` (43 files, +5516 / -1001 since `1.5.3` `5461e0d`). Hardens prompt correlation, maintenance recovery, workspace serialization, and evaluator verification.

package/README.md

@@ -19,13 +19,14 @@
 - **Codex-style engine-driven loop** — idle detection → continuation steering with accumulated context (progress history, transcript tail, inbox). No prompt spam in the parent.
 - **Parent ↔ child visibility** — `list/inspect/read_transcript/send_input` give the parent full observability. Bidirectional inbox lets you steer mid-run.
 - **Safe by default** — per-goal artifact isolation (`.opencode/loopd/goals/<id>/`), `maxTurns`/`maxFailures`/`maxNoProgress`, force-finish → semantic `complete_goal` summary → parent notification via wake-up injection.
+- **Scheduled intervals** — `scheduleEveryMs`/`scheduleMaxRuns` auto-requeues the same goal every N ms (e.g., `10s` monitor, `1h` report) without manual `/goal` spam — `5s` poll, `skip-if-running`, `workspaceWrite` serialization, inbox `Scheduled tick N/M`.
 - **Modal TUI dashboard** — `<leader>d` or `/loop` opens a focused dialog (no leak to chat prompt). Vim-style navigation, live running indicator, per-status borders.
 
 Keywords: `opencode` `opencode-plugin` `background-agent` `autonomous` `subagent` `loop` `goal` `tui` `codex` `claude-code` `worker`
 
 ## What it is
 
-opencode-loopd is an **OpenCode plugin** (server + TUI) that adds **background goals** to OpenCode. Each goal owns a **worker (child) subagent** that loops autonomously; the **loop engine** drives continuations; the **dashboard** and **owner tools** keep the parent in control. Think *Codex goals* or *Claude Code loop*, but native to OpenCode's session model.
+opencode-loopd is an **OpenCode plugin** (server + TUI) that adds **background goals** to OpenCode. Each goal owns a **worker (child) subagent** that loops autonomously; the **loop engine** drives continuations; the **schedule worker** requeues the same goal on an interval (`scheduleEveryMs`); the **dashboard** and **owner tools** keep the parent in control. Think *Codex goals* or *Claude Code loop*, but native to OpenCode's session model — with scheduled intervals for repetitive dialogues.
 
 ## Install
 
@@ -211,6 +212,7 @@ Completion is semantic: the child writes the summary; the plugin forwards it to
 ```
 
 - **Engine-driven loop** (like Codex): `session.idle` → lease + retry + polling → re-prompt child. Not a parent-driven re-prompt machine.
+- **Scheduled requeue** (1.7): `createScheduleWorker` `5s` scans `complete` goals with `scheduleEveryMs`/`maxRuns`; `complete→active` resurrect with `Scheduled tick N/M` inbox, `skip-if-running` and `workspaceWrite` gate.
 - **Accumulated context**: each continuation includes progress history, transcript tail, inbox messages, and artifact dir (unless objective names another dir).
 - **Parent wake-up**: when the child calls `complete_goal`/`block_goal`, `tool.execute.after` injects the child's semantic summary into the owner's session — you see "Loop goal … completed: …" without polling.
 
@@ -245,6 +247,8 @@ Goals accept:
 | `maxNoProgress` | `3` | Turns without progress before force-finish |
 | `timeoutMs` | `300000` | Per-turn lease (5 min) |
 | `compactEvery` | — | Compact child every N turns |
+| `scheduleEveryMs` | — | Interval in ms to auto-requeue the same goal after each completion. Minimum 1000. Enables repetitive dialogue reduction without manual re-prompt |
+| `scheduleMaxRuns` | — | Maximum total runs including the initial run. Undefined = unlimited. Requires `scheduleEveryMs` |
 | `checks` | `[]` | Shell commands that must pass for `complete_goal` |
 | `checkCwd` | artifact directory | Directory where completion checks run; workspace writes default to project root |
 | `workspaceWrite` | `true` | Marks shared-workspace mutation; only one active workspace writer is allowed. Set `false` explicitly for artifact-only/read-only work |
@@ -259,6 +263,29 @@ prevent concurrent agents or `git stash` operations from overwriting each
 other. Artifact-only research goals may run concurrently by setting
 `workspaceWrite: false` explicitly.
 
+## Scheduled goals — repetitive dialogues without manual re-prompt
+
+One `/goal` can now loop on an interval — the engine requeues the **same goal** after each `complete`:
+
+```
+loopd_create_goal({
+  name: "hourly-report",
+  objective: "Append date -u to tick.txt each run",
+  agent: "smart-agent",
+  checks: ["test -f tick.txt"],
+  scheduleEveryMs: 3600000, // 1h, min 1000
+  scheduleMaxRuns: 24,      // total incl initial, omit for unlimited
+  workspaceWrite: false
+})
+```
+
+- **Poll:** `5s` `createScheduleWorker` scans `complete` scheduled goals; `skip-if-running` (lease/`phase`/`workspaceWrite` gate).
+- **Resurrect:** `complete → active` `phase=idle`, injects inbox `Scheduled tick N/M — re-execute objective`, then `continueTurn`.
+- **State:** `scheduleRunCount`/`nextRunAt`/`lastScheduleAt` (`v6` `state.json`), `schedule.tick` events, `schedule.resurrected` server log.
+- **Live proof:** `sched-live-verify` `09cb837c` `10s` `maxRuns 3` → `tick.txt` `3` lines `02:00:56` `02:03:43` `02:05:47` with `runCount 3`.
+
+Without schedule you’d send `/goal` 3× manually; with schedule one creation covers `monitor deploy`, `periodic tests`, `keep going until done`.
+
 ## Dashboard tips
 
 - Press `:` then type bare text → sent as `send_goal_input` to the selected goal.

package/dist/server.js

@@ -147,7 +147,7 @@ import { randomUUID } from "crypto";
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
-var CURRENT_VERSION = 5;
+var CURRENT_VERSION = 6;
 function emptyState() {
   return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [] };
 }
@@ -310,6 +310,32 @@ function migrate(state) {
       workerUnreachableNotifiedAt: rt.workerUnreachableNotifiedAt ?? undefined
     }));
   }
+  if (result.version < 6) {
+    result.version = 6;
+    result.goals = result.goals.map((goal) => ({
+      ...goal,
+      config: {
+        ...goal.config,
+        schedule: goal.config?.schedule ?? undefined
+      }
+    }));
+    result.goals = result.goals.map((goal) => {
+      const s = goal.config?.schedule;
+      if (s && typeof s.everyMs === "number" && s.everyMs >= 1000)
+        return goal;
+      if (s) {
+        const { schedule: _s, ...restConfig } = goal.config;
+        return { ...goal, config: restConfig };
+      }
+      return goal;
+    });
+    result.runtimes = result.runtimes.map((rt) => ({
+      ...rt,
+      scheduleRunCount: typeof rt.scheduleRunCount === "number" ? rt.scheduleRunCount : 0,
+      nextRunAt: rt.nextRunAt ?? undefined,
+      lastScheduleAt: rt.lastScheduleAt ?? undefined
+    }));
+  }
   return result;
 }
 async function writeAtomic(target, contents) {
@@ -470,14 +496,7 @@ function resolveGoalCreationConfig(input) {
   const defaults = input.defaults || {};
   const explicitAgent = cleanText(requested.agent);
   const defaultAgent = cleanText(defaults.defaultAgent);
-  const agent = explicitAgent || defaultAgent;
-  if (!agent) {
-    return {
-      ok: false,
-      errorCode: "missing_agent",
-      message: "An agent is required. Pass agent explicitly or configure plugin option defaultAgent."
-    };
-  }
+  const agent = explicitAgent || defaultAgent || undefined;
   const workspaceWrite = requested.workspaceWrite ?? true;
   const explicitChecks = cleanList(requested.checks);
   const defaultChecks = workspaceWrite ? cleanList(defaults.defaultChecks) : [];
@@ -1799,7 +1818,13 @@ function createGoalService(host) {
     const state1 = await mutateState(directory, `goal.create:${id}`, async (state) => {
       assertWorkspaceWriteAvailable(state, goal);
       state.goals.push(goal);
-      state.runtimes.push(createRuntimeState(id));
+      const rt = createRuntimeState(id);
+      if (goal.config.schedule) {
+        rt.scheduleRunCount = 0;
+        rt.nextRunAt = undefined;
+        rt.lastScheduleAt = undefined;
+      }
+      state.runtimes.push(rt);
       const runtime2 = state.runtimes.find((r) => r.goalID === id);
       if (runtime2)
         runtime2.phase = "queued";
@@ -2281,6 +2306,119 @@ function createGoalService(host) {
   return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile };
 }
 
+// src/application/schedule-worker.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function createScheduleWorker(options) {
+  const { directory, goalService } = options;
+  const intervalMs = options.intervalMs ?? 5000;
+  let running = false;
+  let timer;
+  function start() {
+    if (running)
+      return;
+    running = true;
+    timer = setInterval(() => {
+      tick().catch(() => {});
+    }, intervalMs);
+  }
+  function stop() {
+    running = false;
+    if (timer)
+      clearInterval(timer);
+    timer = undefined;
+  }
+  function isRunning() {
+    return running;
+  }
+  async function tick() {
+    const state = await readState(directory);
+    let resurrected = 0;
+    for (const goal of state.goals) {
+      const schedule = goal.config.schedule;
+      if (!schedule || typeof schedule.everyMs !== "number" || schedule.everyMs < 1000)
+        continue;
+      const runtime = state.runtimes.find((r) => r.goalID === goal.id);
+      if (!runtime)
+        continue;
+      if (goal.status !== "complete")
+        continue;
+      const count = runtime.scheduleRunCount ?? 0;
+      const max = schedule.maxRuns;
+      if (typeof max === "number" && count >= max)
+        continue;
+      const nextAt = runtime.nextRunAt;
+      if (!nextAt)
+        continue;
+      if (Date.now() < Date.parse(nextAt))
+        continue;
+      const activeWriter = state.goals.find((g) => g.id !== goal.id && g.status === "active" && g.config.workspaceWrite);
+      if (goal.config.workspaceWrite && activeWriter) {
+        await logServerEvent(directory, "schedule.skipped-writer-active", {
+          goalID: goal.id,
+          activeWriter: activeWriter.id
+        });
+        continue;
+      }
+      if (runtime.phase === "running" || runtime.phase === "queued" || runtime.phase === "compacting")
+        continue;
+      if (leaseIsValid(runtime))
+        continue;
+      const didResurrect = await mutateState(directory, `schedule.tick:${goal.id}`, async (s) => {
+        const g = s.goals.find((x) => x.id === goal.id);
+        const rt = s.runtimes.find((x) => x.goalID === goal.id);
+        if (!g || !rt)
+          return s;
+        if (g.status !== "complete")
+          return s;
+        const curCount = rt.scheduleRunCount ?? 0;
+        if (typeof max === "number" && curCount >= max)
+          return s;
+        const curNext = rt.nextRunAt;
+        if (!curNext || Date.now() < Date.parse(curNext))
+          return s;
+        g.status = "active";
+        g.updatedAt = new Date().toISOString();
+        g.blocker = undefined;
+        rt.phase = "idle";
+        rt.consecutiveFailures = 0;
+        rt.noProgressCount = 0;
+        rt.progressDuringTurn = false;
+        rt.forceFinishRequested = undefined;
+        rt.lastError = undefined;
+        rt.lastScheduleAt = new Date().toISOString();
+        rt.updatedAt = new Date().toISOString();
+        return s;
+      });
+      const after = didResurrect.goals.find((g) => g.id === goal.id);
+      if (!after || after.status !== "active")
+        continue;
+      await appendEvent(directory, {
+        version: 1,
+        eventID: randomUUID4(),
+        goalID: goal.id,
+        type: "schedule.tick",
+        scheduleRunCount: count,
+        nextRunAt: nextAt,
+        timestamp: new Date().toISOString(),
+        revision: didResurrect.revision
+      });
+      await logServerEvent(directory, "schedule.resurrected", {
+        goalID: goal.id,
+        scheduleRunCount: count,
+        nextRunAt: nextAt
+      });
+      const maxLabel = typeof max === "number" ? `/${max}` : "";
+      await appendGoalInbox(directory, goal.id, "user", `Scheduled tick ${count + 1}${maxLabel} \u2014 re-execute the objective now. Previous completion: ${runtime.scheduleRunCount ?? 0} runs. Ensure artifact checks pass for this tick (e.g., append timestamp to tick.txt).`);
+      try {
+        await goalService.continueTurn(directory, goal.id);
+        resurrected++;
+      } catch {}
+    }
+    return resurrected;
+  }
+  return { start, stop, isRunning, tick };
+}
+
 // src/server/host-adapter.ts
 var recentParentNotifies = new Map;
 function shouldDedupParentNotify(ownerSessionID, message) {
@@ -2431,7 +2569,7 @@ async function withTimeout(promise, timeoutMs, operation) {
 }
 
 // src/server/goal-tools.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { tool } from "@opencode-ai/plugin/tool";
 // src/domain/verification.ts
 var MAX_RECENT_ATTEMPTS = 10;
@@ -2450,11 +2588,11 @@ var execAsync = promisify(execChild);
 function goalTools(dir, goalService, hostSessionID, defaults = {}) {
   return {
     loopd_create_goal: tool({
-      description: "Create a new background loop goal (contract: objective + checks + agent + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "Specify 'agent' or configure plugin defaultAgent.",
+      description: "Create a new background loop goal (contract: objective + checks + agent + workspaceWrite). " + "The engine spawns a dedicated worker session that does the work autonomously \u2014 it never runs in this chat. " + "Call this after clarifying the contract with the user. " + "Host is the acceptance authority: checks must pass for complete_goal (free retry if rejected <3, blocked after 3). " + "Workspace-writing goals are serialized (only one active writer) and require checks. " + "agent is optional \u2014 uses the parent session's agent if omitted, or configure plugin defaultAgent in opencode.jsonc.",
       args: {
         name: tool.schema.string().describe("Short goal name (used in the dashboard)."),
         objective: tool.schema.string().describe("What the goal should accomplish, in detail."),
-        agent: tool.schema.string().optional().describe("Agent to run the worker as. Required unless the plugin has defaultAgent configured."),
+        agent: tool.schema.string().optional().describe("Agent to run the worker as. Optional \u2014 uses parent session's agent if omitted, or configure plugin defaultAgent in opencode.jsonc."),
         checks: tool.schema.array(tool.schema.string()).optional().describe('Shell commands that must pass for completion to be accepted. E.g. ["npm test"].'),
         checkCwd: tool.schema.string().optional().describe("Directory where completion checks run. Workspace-writing goals default to the project root."),
         workspaceWrite: tool.schema.boolean().optional().describe("Whether this goal edits the shared project workspace. Defaults to true; explicitly set false for artifact-only/read-only work."),
@@ -2463,7 +2601,9 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
         maxNoProgress: tool.schema.number().optional().describe("Block after N turns without progress."),
         maxFailures: tool.schema.number().optional().describe("Block after N consecutive failures."),
         compactEvery: tool.schema.number().optional().describe("Compact the worker session every N turns."),
-        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms.")
+        timeoutMs: tool.schema.number().optional().describe("Per-turn timeout in ms."),
+        scheduleEveryMs: tool.schema.number().optional().describe("Interval in ms to auto-requeue the same goal after each completion. Minimum 1000. Enables repetitive dialogue reduction."),
+        scheduleMaxRuns: tool.schema.number().optional().describe("Maximum total runs including the initial run. Undefined = unlimited. Requires scheduleEveryMs.")
       },
       execute: async (args, context) => {
         const sessionID = context?.sessionID || hostSessionID;
@@ -2499,6 +2639,28 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
           config.compactEvery = args.compactEvery;
         if (args.timeoutMs !== undefined)
           config.timeoutMs = args.timeoutMs;
+        if (args.scheduleEveryMs !== undefined) {
+          const everyMs = args.scheduleEveryMs;
+          if (typeof everyMs !== "number" || !Number.isFinite(everyMs) || everyMs < 1000) {
+            return {
+              title: "Goal not created",
+              output: JSON.stringify({ ok: false, message: "scheduleEveryMs must be a number >= 1000", errorCode: "invalid_schedule" })
+            };
+          }
+          const maxRuns = args.scheduleMaxRuns;
+          if (maxRuns !== undefined && (typeof maxRuns !== "number" || !Number.isFinite(maxRuns) || maxRuns < 1 || Math.floor(maxRuns) !== maxRuns)) {
+            return {
+              title: "Goal not created",
+              output: JSON.stringify({ ok: false, message: "scheduleMaxRuns must be an integer >= 1", errorCode: "invalid_schedule" })
+            };
+          }
+          config.schedule = { everyMs, ...maxRuns !== undefined ? { maxRuns } : {} };
+        } else if (args.scheduleMaxRuns !== undefined) {
+          return {
+            title: "Goal not created",
+            output: JSON.stringify({ ok: false, message: "scheduleMaxRuns requires scheduleEveryMs", errorCode: "invalid_schedule" })
+          };
+        }
         const resolution = resolveGoalCreationConfig({
           directory: dir,
           objective: args.objective,
@@ -2604,7 +2766,7 @@ function goalTools(dir, goalService, hostSessionID, defaults = {}) {
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID4(),
+          eventID: randomUUID5(),
           goalID: goal.id,
           type: "goal.progress",
           summary: args.summary,
@@ -2662,7 +2824,7 @@ Exit code: ${f.exitCode}${stdoutSnippet}${stderrSnippet}`;
 Working directory: ${cwd}
 
 ${failureDetails}`;
-              const attemptID = randomUUID4();
+              const attemptID = randomUUID5();
               const verificationAttempt = {
                 id: attemptID,
                 sequence: runtime2.evaluatorRejectionCount,
@@ -2684,7 +2846,7 @@ ${failureDetails}`;
               runtime2.recentVerificationAttempts = appendVerificationAttempt(runtime2.recentVerificationAttempts || [], verificationAttempt);
               const rejectEvent = {
                 version: 1,
-                eventID: randomUUID4(),
+                eventID: randomUUID5(),
                 goalID: goal.id,
                 type: "goal.completion_rejected",
                 attemptID,
@@ -2708,7 +2870,7 @@ ${failureDetails.slice(0, 500)}`,
                 runtime2.forceFinishRequested = undefined;
                 await appendEvent(dir, {
                   version: 1,
-                  eventID: randomUUID4(),
+                  eventID: randomUUID5(),
                   goalID: goal.id,
                   type: "goal.blocked",
                   reason: goal.blocker.reason,
@@ -2745,8 +2907,33 @@ ${failureDetails.slice(0, 500)}`,
         const runtime = state.runtimes.find((r) => r.goalID === goal.id);
         if (runtime) {
           runtime.phase = "idle";
+          runtime.leaseExpiresAt = undefined;
+          runtime.turnStartedAt = undefined;
+          runtime.activeRunID = undefined;
+          runtime.activePromptMessageID = undefined;
+          runtime.activePromptObservedAt = undefined;
+          runtime.activeAssistantMessageID = undefined;
+          runtime.activeAssistantCompletedAt = undefined;
+          runtime.idleCandidateAt = undefined;
+          runtime.idleCandidateGeneration = undefined;
+          runtime.activeToolCallIDs = [];
           runtime.lastError = undefined;
-          const attemptID = randomUUID4();
+          const schedule = goal.config.schedule;
+          if (schedule && typeof schedule.everyMs === "number" && schedule.everyMs >= 1000) {
+            const cur = typeof runtime.scheduleRunCount === "number" ? runtime.scheduleRunCount : 0;
+            const nextCount = cur + 1;
+            runtime.scheduleRunCount = nextCount;
+            const max = schedule.maxRuns;
+            const hasMore = typeof max === "number" ? nextCount < max : true;
+            if (hasMore) {
+              runtime.nextRunAt = new Date(Date.now() + schedule.everyMs).toISOString();
+              runtime.lastScheduleAt = new Date().toISOString();
+            } else {
+              runtime.nextRunAt = undefined;
+            }
+            runtime.updatedAt = new Date().toISOString();
+          }
+          const attemptID = randomUUID5();
           const cwd = goal.config.checkCwd || goal.config.artifactDir || dir;
           const checks = (goal.config.checks || []).map((cmd) => ({
             command: cmd,
@@ -2770,7 +2957,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID4(),
+          eventID: randomUUID5(),
           goalID: goal.id,
           type: "goal.completed",
           summary: args.summary,
@@ -2822,7 +3009,7 @@ ${failureDetails.slice(0, 500)}`,
         await writeState(dir, state);
         const event = {
           version: 1,
-          eventID: randomUUID4(),
+          eventID: randomUUID5(),
           goalID: goal.id,
           type: "goal.blocked",
           reason: args.reason,
@@ -2870,7 +3057,8 @@ function formatGoalStructured(goal, runtime) {
       maxNoProgress: goal.config.maxNoProgress,
       maxFailures: goal.config.maxFailures,
       compactEvery: goal.config.compactEvery,
-      timeoutMs: goal.config.timeoutMs
+      timeoutMs: goal.config.timeoutMs,
+      schedule: goal.config.schedule
     },
     lastProgress: goal.lastProgress,
     completionEvidence: goal.completionEvidence,
@@ -2902,7 +3090,10 @@ function formatGoalStructured(goal, runtime) {
       lastUnknownStatusAt: runtime.lastUnknownStatusAt,
       workerUnreachableNotifiedAt: runtime.workerUnreachableNotifiedAt,
       lastVerificationAttempt: runtime.lastVerificationAttempt,
-      recentVerificationAttempts: runtime.recentVerificationAttempts
+      recentVerificationAttempts: runtime.recentVerificationAttempts,
+      scheduleRunCount: runtime.scheduleRunCount,
+      nextRunAt: runtime.nextRunAt,
+      lastScheduleAt: runtime.lastScheduleAt
     };
   }
   return JSON.stringify(output, null, 2);
@@ -3008,7 +3199,8 @@ function ownerTools(options) {
               checks: goal.config.checks,
               checkCwd: goal.config.checkCwd,
               workspaceWrite: goal.config.workspaceWrite,
-              agent: goal.config.agent
+              agent: goal.config.agent,
+              schedule: goal.config.schedule
             },
             lastProgress: goal.lastProgress,
             completionEvidence: goal.completionEvidence,
@@ -3025,7 +3217,10 @@ function ownerTools(options) {
               consecutiveFailures: runtime.consecutiveFailures,
               lastError: runtime.lastError,
               lastProgressAt: runtime.lastProgressAt,
-              lastRunAt: runtime.lastRunAt
+              lastRunAt: runtime.lastRunAt,
+              scheduleRunCount: runtime.scheduleRunCount,
+              nextRunAt: runtime.nextRunAt,
+              lastScheduleAt: runtime.lastScheduleAt
             } : undefined
           }, null, 2)
         };
@@ -3294,6 +3489,11 @@ var server = async ({ client, directory }, pluginOptions) => {
     goalService,
     pollIntervalMs: 30000
   });
+  const scheduleWorker = createScheduleWorker({
+    directory,
+    goalService,
+    intervalMs: 5000
+  });
   let started = false;
   let reconciliationStarted = false;
   function ensureStarted() {
@@ -3302,6 +3502,7 @@ var server = async ({ client, directory }, pluginOptions) => {
     started = true;
     engine.start();
     worker.start();
+    scheduleWorker.start();
   }
   function reconcileInBackground() {
     if (reconciliationStarted)
@@ -3400,6 +3601,7 @@ var server = async ({ client, directory }, pluginOptions) => {
     dispose: async () => {
       engine.stop();
       await worker.stop();
+      scheduleWorker.stop();
     }
   };
 };

package/dist/tui.js

@@ -22,7 +22,7 @@ import { useKeyboard } from "@opentui/solid";
 // src/infrastructure/state-repository.ts
 import { promises as fs } from "fs";
 import path from "path";
-var CURRENT_VERSION = 5;
+var CURRENT_VERSION = 6;
 function emptyState() {
   return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [] };
 }
@@ -123,6 +123,32 @@ function migrate(state) {
       workerUnreachableNotifiedAt: rt.workerUnreachableNotifiedAt ?? undefined
     }));
   }
+  if (result.version < 6) {
+    result.version = 6;
+    result.goals = result.goals.map((goal) => ({
+      ...goal,
+      config: {
+        ...goal.config,
+        schedule: goal.config?.schedule ?? undefined
+      }
+    }));
+    result.goals = result.goals.map((goal) => {
+      const s = goal.config?.schedule;
+      if (s && typeof s.everyMs === "number" && s.everyMs >= 1000)
+        return goal;
+      if (s) {
+        const { schedule: _s, ...restConfig } = goal.config;
+        return { ...goal, config: restConfig };
+      }
+      return goal;
+    });
+    result.runtimes = result.runtimes.map((rt) => ({
+      ...rt,
+      scheduleRunCount: typeof rt.scheduleRunCount === "number" ? rt.scheduleRunCount : 0,
+      nextRunAt: rt.nextRunAt ?? undefined,
+      lastScheduleAt: rt.lastScheduleAt ?? undefined
+    }));
+  }
   return result;
 }
 async function writeAtomic(target, contents) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-loopd",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "Codex-inspired background goal engine for OpenCode — autonomous subagents, engine-driven loop, child worker sessions and modal TUI dashboard. Like Claude Code loop for OpenCode.",
   "type": "module",
   "license": "AGPL-3.0-only",