ework-daemon 0.4.69 → 0.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-daemon",
-  "version": "0.4.69",
+  "version": "0.4.71",
   "description": "Issue-driven AI development daemon. Spawns opencode subprocesses to resolve Gitea issues.",
   "module": "src/index.ts",
   "type": "module",

package/src/db.ts

@@ -524,6 +524,14 @@ async function runMigrations(db: AsyncDatabase): Promise<void> {
       : "owner_daemon_id BIGINT NULL"
   );
 
+  // issues.reset_at — last consumed web-side session-reset marker (ms epoch).
+  // Lets the issue-page 🔄 button force a fresh AI session on next trigger.
+  await ensureColumn(
+    tIssues,
+    "reset_at",
+    sqlite ? "reset_at INTEGER NOT NULL DEFAULT 0" : "reset_at BIGINT NOT NULL DEFAULT 0"
+  );
+
   // op_sessions runtime-state columns (previously in-memory Maps; now persisted
   // so a restarted daemon can recover the nudge/generation state).
   await ensureColumn(tSessions, "last_output_at", "last_output_at VARCHAR(40)");

package/src/op.ts

@@ -379,6 +379,22 @@ export class Store {
     const db = getDB();
     const cutoff = new Date(Date.now() - leaseTtlMs).toISOString();
 
+    // Identity reuse first: a fast restart (previous heartbeat still fresh)
+    // must keep the SAME row/id — daemon_id is embedded in web session links,
+    // so a fresh insert per boot orphans every historical link.
+    const mine = await db.get<{ id: number }>(
+      "SELECT id FROM {{daemons}} WHERE display_name = ? AND internal_endpoint = ? LIMIT 1",
+      [displayName, endpoint]
+    );
+    if (mine) {
+      const now = new Date().toISOString();
+      const res = await db.run(
+        "UPDATE {{daemons}} SET last_heartbeat = ?, status = 'active', capacity = ? WHERE id = ?",
+        [now, capacity, mine.id]
+      );
+      if (res.changes === 1) return mine.id;
+    }
+
     const orphan = await db.get<{ id: number }>(
       "SELECT id FROM {{daemons}} WHERE last_heartbeat < ? ORDER BY last_heartbeat LIMIT 1",
       [cutoff]
@@ -447,6 +463,23 @@ export class Store {
     );
   }
 
+  // reset_at stores the last consumed web reset marker; newer markers clear session pointers.
+  async getIssueResetAt(issueUid: string): Promise<number> {
+    const row = await getDB().get<{ reset_at: number | null }>(
+      "SELECT reset_at FROM {{issues}} WHERE uid = ?",
+      [issueUid]
+    );
+    return row?.reset_at ?? 0;
+  }
+
+  async setIssueResetAt(issueUid: string, ms: number): Promise<void> {
+    await getDB().run("UPDATE {{issues}} SET reset_at = ? WHERE uid = ?", [ms, issueUid]);
+  }
+
+  async clearSessionPointers(issueUid: string): Promise<void> {
+    await getDB().run("UPDATE {{op_sessions}} SET opencode_session_id = NULL WHERE issue_id = ?", [issueUid]);
+  }
+
   async markDaemonStatus(daemonId: number, status: "active" | "drained" | "dead"): Promise<void> {
     await getDB().run(
       "UPDATE {{daemons}} SET status = ? WHERE id = ?",

package/src/opencode.ts

@@ -300,7 +300,7 @@ export interface EngineOptions {
   daemonId: number;
   takeover?: TakeoverStrategy;
   backend?: RuntimeBackend;
-  gateChecker?: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
+  gateChecker?: (issue: Issue) => Promise<{ allowed: boolean; reason: string; resetMs?: number }>;
   replyBurst?: { max: number; windowMs: number };
 }
 
@@ -372,7 +372,7 @@ export class Engine {
   private readonly daemonId: number;
   private readonly takeover: TakeoverStrategy;
   private readonly backend: RuntimeBackend;
-  private gateChecker: (issue: Issue) => Promise<{ allowed: boolean; reason: string }>;
+  private gateChecker: (issue: Issue) => Promise<{ allowed: boolean; reason: string; resetMs?: number }>;
   private heartbeatTimer?: ReturnType<typeof setInterval>;
   private maxConcurrent: number;
   private maxConcurrentExplicit: boolean;
@@ -525,7 +525,18 @@ export class Engine {
     }
   }
 
-  private async webGateAllows(issue: Issue): Promise<{ allowed: boolean; reason: string }> {
+  // Consume-once: only a marker NEWER than issues.reset_at triggers the clear,
+  // so repeated triggers reuse the same fresh session until the next button press.
+  private async applySessionReset(session: OpSession, issue: Issue, resetMs: number): Promise<void> {
+    const last = await this.store.getIssueResetAt(issue.id);
+    if (resetMs <= last) return;
+    await this.store.clearSessionPointers(issue.id);
+    await this.store.setIssueResetAt(issue.id, resetMs);
+    session.opencodeSessionId = undefined;
+    log.info(`engine: session reset via web for ${issue.trackerScopeKey}#${issue.trackerIssueId} — pointers cleared, starting fresh session`);
+  }
+
+  private async webGateAllows(issue: Issue): Promise<{ allowed: boolean; reason: string; resetMs?: number }> {
     const parts = issue.trackerScopeKey.split("/");
     const owner = parts[0] ?? "";
     const repo = parts.slice(1).join("/");
@@ -534,10 +545,10 @@ export class Engine {
     try {
       const resp = await fetch(url, { signal: AbortSignal.timeout(5000), headers: { Authorization: `token ${this.cfg.gitea.token}` } });
       if (!resp.ok) return { allowed: false, reason: `web returned ${resp.status}` };
-      const data = await resp.json() as { dispatchOff?: boolean; aiStatus?: string };
+      const data = await resp.json() as { dispatchOff?: boolean; aiStatus?: string; sessionResetMs?: number | null };
       if (data.dispatchOff) return { allowed: false, reason: "dispatch off" };
       if (data.aiStatus === "halted" || data.aiStatus === "dispatch_off") return { allowed: false, reason: `ai_status=${data.aiStatus}` };
-      return { allowed: true, reason: "ok" };
+      return { allowed: true, reason: "ok", resetMs: Number(data.sessionResetMs) || 0 };
     } catch (err) {
       log.warn(`engine: web gate query failed for ${issue.trackerScopeKey}#${issue.trackerIssueId}: ${(err as Error).message} — fail-closed (skipping)`);
       return { allowed: false, reason: `web unreachable: ${(err as Error).message}` };
@@ -1345,6 +1356,9 @@ export class Engine {
 
   private async execProcess(k: string, session: OpSession, issue: Issue, msg: Message) {
     const gate = await this.gateChecker(issue);
+    if (gate.allowed && gate.resetMs && gate.resetMs > 0) {
+      await this.applySessionReset(session, issue, gate.resetMs);
+    }
     if (!gate.allowed) {
       log.info(`engine: execProcess blocked by web gate (${gate.reason}) for ${k}`);
       await this.store.updateMessageStatus(msg.id, "failed", `gate: ${gate.reason}`);