ework-daemon 0.4.22 → 0.4.23

package/package.json

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

package/src/gitea.ts

@@ -63,6 +63,23 @@ export class GiteaClient {
     }, true);
   }
 
+  async updateIssueStatus(
+    owner: string,
+    repo: string,
+    issueNumber: number,
+    status: string,
+    detail?: string
+  ): Promise<void> {
+    try {
+      await this.request("POST", `/repos/${owner}/${repo}/issues/${issueNumber}/status`, {
+        status,
+        detail,
+      }, true);
+    } catch {
+      // Status callback is best-effort — don't block processing on API failure.
+    }
+  }
+
   async editComment(
     owner: string,
     repo: string,

package/src/opencode.ts

@@ -579,6 +579,11 @@ export class Engine {
         return this.handleCommented(ref, scopeKey, issueData, event.comment!, tracker, event.model);
       case "issue_closed":
         return this.handleClosed(ref, scopeKey, tracker);
+      case "status_changed": {
+        const to = event.status?.to;
+        if (to === "halted") return this.handleHalted(ref, scopeKey, tracker);
+        return;
+      }
     }
   }
 
@@ -629,6 +634,7 @@ export class Engine {
     log.info(`engine: session "${session.name}" created for ${k}, workdir=${workdir}`);
 
     await tracker.createComment(ref, `[system] 🔄 **${session.name}** picked up this issue.\n> session: ${this.sessionRef(session)} | workdir: ${this.workdirLink(workdir)}`);
+    void tracker.updateStatus(ref, "processing");
 
     const instructions = tracker.getTrackerInstructions(ref);
     const prompt = this.buildInitialPrompt(
@@ -813,6 +819,36 @@ export class Engine {
     this.senders.delete(gcKey);
 
     log.info(`engine: issue closed, ${sessions.length} sessions paused for ${scopeKey}#${ref.issueId}`);
+    void tracker.updateStatus(ref, "completed");
+  }
+
+  private async handleHalted(
+    ref: TrackerRef,
+    scopeKey: string,
+    tracker: IssueTracker
+  ) {
+    const issue = await this.store.findIssue(ref.trackerType, scopeKey, ref.issueId);
+    if (!issue) return;
+    this.stopObserver(issue.id);
+    const sessions = await this.store.getSessionsForIssue(issue.id);
+    for (const session of sessions) {
+      const k = this.sessionKey(session, issue);
+      const proc = this.processes.get(k);
+      if (proc) {
+        this.stopping.add(k);
+        try { this.killProcessTree(proc.pid, "SIGTERM"); } catch { /* already dead */ }
+      }
+      this.clearRuntimeState(k);
+      const msgs = await this.store.getMessagesForSession(session.id);
+      for (const msg of msgs) {
+        if (msg.status === "pending" || msg.status === "running") {
+          await this.store.updateMessageStatus(msg.id, "interrupted", "halted by user");
+        }
+      }
+      await this.store.updateSession(session.id, { state: "idle", opencodePid: undefined });
+    }
+    log.info(`engine: issue halted, ${sessions.length} sessions killed for ${scopeKey}#${ref.issueId}`);
+    try { await tracker.createComment(ref, "[system] ⏸️ AI processing halted by user."); } catch { /* tracker unavailable */ }
   }
 
   private clearRuntimeState(k: string) {

package/src/trackers/gitea-tracker.ts

@@ -65,6 +65,12 @@ export class GiteaTracker implements IssueTracker {
     );
   }
 
+  async updateStatus(ref: TrackerRef, status: string, detail?: string) {
+    await this.client.updateIssueStatus(
+      this.owner(ref), this.repo(ref), Number(ref.issueId), status, detail
+    );
+  }
+
   async setReaction(ref: TrackerRef, commentId: string, content: string, remove = false) {
     if (remove) {
       await this.client.removeCommentReaction(
@@ -189,6 +195,26 @@ export class GiteaTracker implements IssueTracker {
       };
     }
 
+    if (action === "status_changed") {
+      const status = payload.status as { from?: string; to?: string; detail?: string } | undefined;
+      return {
+        type: "status_changed" as const,
+        ref,
+        issue: {
+          title: issue.title as string,
+          body: (issue.body as string) ?? "",
+          state: (issue.state as string) ?? "open",
+          author: issueUser?.login ?? "",
+        },
+        status: {
+          from: status?.from ?? "",
+          to: status?.to ?? "",
+          detail: status?.detail,
+        },
+        sender,
+      };
+    }
+
     return null;
   }
 

package/src/trackers/types.ts

@@ -13,7 +13,7 @@ export interface TrackerRef {
 }
 
 /** Parsed, tracker-agnostic webhook event */
-export type TrackerEventType = "issue_opened" | "comment_created" | "issue_closed";
+export type TrackerEventType = "issue_opened" | "comment_created" | "issue_closed" | "status_changed";
 
 export interface TrackerEvent {
   type: TrackerEventType;
@@ -39,6 +39,7 @@ export interface TrackerEvent {
   // Webhook sender (who triggered the event). Forwarded to the daemon's
   // task context so the AI knows who it's responding to.
   sender?: string;
+  status?: { from: string; to: string; detail?: string };
 }
 
 /** Tracker-agnostic comment */
@@ -130,6 +131,7 @@ export interface IssueTracker {
   deleteComment(ref: TrackerRef, commentId: string): Promise<void>;
   listComments(ref: TrackerRef): Promise<TrackerComment[]>;
   closeIssue(ref: TrackerRef): Promise<void>;
+  updateStatus(ref: TrackerRef, status: string, detail?: string): Promise<void>;
 
   setReaction(ref: TrackerRef, commentId: string, content: string, remove?: boolean): Promise<void>;