ework-daemon 0.4.15 → 0.4.17

package/package.json

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

package/src/opencode.ts

@@ -22,7 +22,7 @@ interface TrackerRegistry {
  * the coordination layer.
  */
 export interface TakeoverStrategy {
-  acquireWorkdir(session: OpSession, issue: Issue, cloneUrl?: string): Promise<string>;
+  acquireWorkdir(session: OpSession, issue: Issue, cloneUrl?: string, env?: Record<string, string>): Promise<string>;
   resumeOpenCodeSession(session: OpSession): Promise<string | null>;
 }
 
@@ -91,6 +91,85 @@ export async function runHookScript(script: string | undefined, workdir: string,
   }
 }
 
+const SYSTEM_PREFIX = "[system]";
+const RECENT_BOT_REPLY_THRESHOLD_MS = 5 * 60_000; // 5 minutes
+
+/**
+ * Determine whether any non-system bot reply exists that is causally after
+ * `promptTime` (when provided) or within a 5-minute absolute window (fallback).
+ * Exported for unit testing — the causal vs absolute distinction is the P0
+ * correctness fix for preempt/nudge false-done detection.
+ */
+export function hasRecentBotReply(
+  comments: TrackerComment[],
+  isBotUser: (author: string) => boolean,
+  promptTime?: number,
+): boolean {
+  if (promptTime) {
+    return comments.some(c => {
+      if (!isBotUser(c.author) || c.body.startsWith(SYSTEM_PREFIX)) return false;
+      if (!c.createdAt) return false;
+      return new Date(c.createdAt).getTime() > promptTime;
+    });
+  }
+  const now = Date.now();
+  return comments.some(c => {
+    if (!isBotUser(c.author) || c.body.startsWith(SYSTEM_PREFIX)) return false;
+    if (!c.createdAt) return true;
+    const age = now - new Date(c.createdAt).getTime();
+    return age < RECENT_BOT_REPLY_THRESHOLD_MS;
+  });
+}
+
+/**
+ * Query the opencode SQLite DB for a session's assistant-message output tokens.
+ * Returns `{hasOutput: true}` (safe default) when the DB can't be opened or
+ * the session is undefined — this means the retry path is only triggered when
+ * we have POSITIVE evidence of 0-token output.
+ * Exported for unit testing.
+ */
+export async function checkSessionOutput(
+  dbPath: string,
+  opencodeSessionId: string | undefined,
+): Promise<{ hasOutput: boolean; tokenCount: number }> {
+  if (!opencodeSessionId) return { hasOutput: true, tokenCount: 0 };
+  let db: Database;
+  try {
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return { hasOutput: true, tokenCount: 0 };
+  }
+  try {
+    const row = db.prepare(
+      "SELECT COUNT(*) AS n, COALESCE(SUM(CAST(json_extract(data,'$.tokens.output') AS INT)), 0) AS tokens " +
+      "FROM message WHERE session_id = ? AND json_extract(data,'$.role') = 'assistant'"
+    ).get(opencodeSessionId) as { n: number; tokens: number } | null;
+    if (!row) return { hasOutput: true, tokenCount: 0 };
+    return { hasOutput: row.n > 0 && row.tokens > 0, tokenCount: row.tokens };
+  } catch {
+    return { hasOutput: true, tokenCount: 0 };
+  } finally {
+    db.close();
+  }
+}
+
+export async function opencodeSessionExists(dbPath: string, sessionId: string): Promise<boolean> {
+  let db: Database;
+  try {
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return false;
+  }
+  try {
+    const row = db.prepare("SELECT 1 FROM session WHERE id = ? LIMIT 1").get(sessionId);
+    return !!row;
+  } catch {
+    return false;
+  } finally {
+    db.close();
+  }
+}
+
 /**
  * Default TakeoverStrategy: deterministic per-issue workdir under
  * `<baseWorkdir>/<owner>--<repo>/<issueId>/<sessionName>`, with a best-effort
@@ -100,7 +179,7 @@ export async function runHookScript(script: string | undefined, workdir: string,
 export class RecloneStrategy implements TakeoverStrategy {
   constructor(private cfg: Config) {}
 
-  async acquireWorkdir(session: OpSession, issue: Issue, cloneUrl?: string): Promise<string> {
+  async acquireWorkdir(session: OpSession, issue: Issue, cloneUrl?: string, env?: Record<string, string>): Promise<string> {
     if (session.workdir) {
       let dir = session.workdir;
       if (dir.startsWith("~")) dir = join(homedir(), dir.slice(1));
@@ -126,7 +205,7 @@ export class RecloneStrategy implements TakeoverStrategy {
         const gitArgs = ["git"];
         if (credHelper) gitArgs.push("-c", `credential.helper=${credHelper}`);
         gitArgs.push("clone", url, dir);
-        const r = Bun.spawnSync({ cmd: gitArgs, stdout: "ignore", stderr: "pipe" });
+        const r = Bun.spawnSync({ cmd: gitArgs, stdout: "ignore", stderr: "pipe", env: { ...process.env, ...env } });
         if (r.exitCode !== 0) {
           if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
           if (existsSync(dir) && readdirSync(dir).length === 0) {
@@ -338,7 +417,16 @@ export class Engine {
     }
     const issueMapKey = `${issue.trackerType}:${issue.trackerScopeKey}#${issue.trackerIssueId}`;
     const cloneUrl = this.cloneUrls.get(issueMapKey);
-    return this.takeover.acquireWorkdir(session, issue, cloneUrl);
+    const owner = String(issue.trackerScope["owner"] ?? issue.trackerScopeKey.split("/")[0] ?? "");
+    const repo = String(issue.trackerScope["repo"] ?? issue.trackerScopeKey.split("/").slice(-1)[0] ?? "");
+    const sender = this.senders.get(issueMapKey);
+    const env: Record<string, string> = {
+      EWORK_OWNER: owner,
+      EWORK_REPO: repo,
+      EWORK_ISSUE: String(issue.trackerIssueId),
+    };
+    if (sender) env.EWORK_SENDER = sender;
+    return this.takeover.acquireWorkdir(session, issue, cloneUrl, env);
   }
 
   private hookEnvFor(issue: Issue, session: OpSession, workdir: string): Record<string, string> {
@@ -423,12 +511,8 @@ export class Engine {
     return remainMin > 0 ? `${hours}h ${remainMin}m` : `${hours}h`;
   }
 
-  /** System comments are posted by the daemon itself (acks, progress, reports). They are NOT AI replies. */
-  private static SYSTEM_PREFIX = "[system]";
-  private static RECENT_BOT_REPLY_THRESHOLD_MS = 5 * 60_000; // 5 minutes
-
   private isSystemComment(comment: TrackerComment): boolean {
-    return comment.body.startsWith(Engine.SYSTEM_PREFIX);
+    return comment.body.startsWith(SYSTEM_PREFIX);
   }
 
   private countAIReplies(comments: TrackerComment[], tracker: IssueTracker): number {
@@ -436,25 +520,7 @@ export class Engine {
   }
 
   private hasRecentBotReply(comments: TrackerComment[], tracker: IssueTracker, promptTime?: number): boolean {
-    // Causal check: if we know when this prompt was delivered, look for any
-    // bot reply CREATED AFTER that time. This is the correct signal — "did the
-    // AI reply to THIS prompt?" — and avoids false "done" when a previous
-    // round's reply is still within an absolute time window.
-    if (promptTime) {
-      return comments.some(c => {
-        if (!tracker.isBotUser(c.author) || this.isSystemComment(c)) return false;
-        if (!c.createdAt) return false; // no timestamp → can't confirm it's after prompt
-        return new Date(c.createdAt).getTime() > promptTime;
-      });
-    }
-    // Fallback: absolute 5-minute window (for stuck-check that has no prompt time)
-    const now = Date.now();
-    return comments.some(c => {
-      if (!tracker.isBotUser(c.author) || this.isSystemComment(c)) return false;
-      if (!c.createdAt) return true;
-      const age = now - new Date(c.createdAt).getTime();
-      return age < Engine.RECENT_BOT_REPLY_THRESHOLD_MS;
-    });
+    return hasRecentBotReply(comments, (a) => tracker.isBotUser(a), promptTime);
   }
 
   private lastBotReply(comments: TrackerComment[], tracker: IssueTracker): TrackerComment | undefined {
@@ -462,25 +528,7 @@ export class Engine {
   }
 
   private async checkSessionOutput(opencodeSessionId: string | undefined): Promise<{ hasOutput: boolean; tokenCount: number }> {
-    if (!opencodeSessionId) return { hasOutput: true, tokenCount: 0 };
-    let db: Database;
-    try {
-      db = new Database(this.cfg.opencode.dbPath, { readonly: true });
-    } catch {
-      return { hasOutput: true, tokenCount: 0 };
-    }
-    try {
-      const row = db.prepare(
-        "SELECT COUNT(*) AS n, COALESCE(SUM(CAST(json_extract(data,'$.tokens.output') AS INT)), 0) AS tokens " +
-        "FROM message WHERE session_id = ? AND json_extract(data,'$.role') = 'assistant'"
-      ).get(opencodeSessionId) as { n: number; tokens: number } | null;
-      if (!row) return { hasOutput: true, tokenCount: 0 };
-      return { hasOutput: row.n > 0 && row.tokens > 0, tokenCount: row.tokens };
-    } catch {
-      return { hasOutput: true, tokenCount: 0 };
-    } finally {
-      db.close();
-    }
+    return checkSessionOutput(this.cfg.opencode.dbPath, opencodeSessionId);
   }
 
   // ─── Event Dispatch ───
@@ -854,6 +902,11 @@ export class Engine {
       const fromStrategy = await this.takeover.resumeOpenCodeSession(session);
       if (fromStrategy) resumeSessionId = fromStrategy;
     }
+    if (resumeSessionId && !(await opencodeSessionExists(this.cfg.opencode.dbPath, resumeSessionId))) {
+      log.warn(`stale opencode session ${resumeSessionId} not found in db, starting fresh`);
+      resumeSessionId = undefined;
+      await this.store.updateSession(session.id, { opencodeSessionId: undefined });
+    }
     if (resumeSessionId) {
       args.push("--session", resumeSessionId);
     }

package/src/sync/engine.ts

@@ -0,0 +1,129 @@
+import type { PollingTracker, SyncExternalIssue, SyncExternalComment, TrackerRef, PollResult } from "../trackers/types";
+import { log } from "../logger";
+
+const PROVENANCE_RE = /<!--\s*sync:(\w+):([^\s:]+)(?::([^\s]+))?\s*-->/;
+
+export function withProvenance(sourceType: string, externalId: string, body: string): string {
+  const marker = `<!-- sync:${sourceType}:${externalId} -->`;
+  return body.endsWith("\n") ? `${body}${marker}` : `${body}\n${marker}`;
+}
+
+export function extractProvenance(body: string): { sourceType: string; externalId: string; commentId?: string } | null {
+  const m = body.match(PROVENANCE_RE);
+  if (!m) return null;
+  return { sourceType: m[1]!, externalId: m[2]!, commentId: m[3] };
+}
+
+export function isSyncMirrored(body: string, sourceType: string): boolean {
+  const p = extractProvenance(body);
+  return p?.sourceType === sourceType;
+}
+
+export interface SyncEngineOptions {
+  tracker: PollingTracker;
+  scope: Record<string, string>;
+  webUrl: string;
+  webToken: string;
+  owner: string;
+  repo: string;
+  pollIntervalMs: number;
+  cursorFile: string;
+  botLogin: string;
+}
+
+interface CursorState {
+  issueCursor: string | null;
+  commentCursors: Record<string, string | null>;
+  issueMap: Record<string, number>;
+}
+
+async function loadCursors(path: string): Promise<CursorState> {
+  try {
+    const f = Bun.file(path);
+    if (await f.exists()) return await f.json();
+  } catch { /* first run */ }
+  return { issueCursor: null, commentCursors: {}, issueMap: {} };
+}
+
+async function saveCursors(path: string, state: CursorState): Promise<void> {
+  try {
+    await Bun.write(path, JSON.stringify(state, null, 2));
+  } catch (e) {
+    log.warn(`sync: failed to save cursors: ${(e as Error).message}`);
+  }
+}
+
+export class SyncEngine {
+  private opts: SyncEngineOptions;
+  private running = false;
+  private timer?: ReturnType<typeof setInterval>;
+
+  constructor(opts: SyncEngineOptions) {
+    this.opts = opts;
+  }
+
+  async pollOnce(): Promise<void> {
+    const state = await loadCursors(this.opts.cursorFile);
+    const { tracker, scope, webUrl, webToken, owner, repo } = this.opts;
+
+    const issueResult: PollResult<SyncExternalIssue> = await tracker.listChangedIssues(scope, state.issueCursor);
+    for (const ext of issueResult.items) {
+      const existingLocal = state.issueMap[ext.externalId];
+      if (ext.state === "open" && !existingLocal) {
+        const body = withProvenance(tracker.type, ext.externalId, ext.body);
+        const resp = await fetch(`${webUrl}/api/v1/repos/${owner}/${repo}/issues`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `token ${webToken}` },
+          body: JSON.stringify({ title: ext.title, body, assignee: ext.author }),
+        });
+        if (resp.ok) {
+          const data = await resp.json() as { number: number };
+          state.issueMap[ext.externalId] = data.number;
+          log.info(`sync: created issue #${data.number} from ${tracker.type}:${ext.externalId}`);
+        } else {
+          log.warn(`sync: create issue failed: ${resp.status} ${await resp.text()}`);
+        }
+      }
+    }
+    state.issueCursor = issueResult.nextCursor ?? state.issueCursor;
+
+    for (const [extId, issueNum] of Object.entries(state.issueMap)) {
+      const ref: TrackerRef = { trackerType: tracker.type, scope, issueId: String(issueNum) };
+      const cCursor = state.commentCursors[extId] ?? null;
+      const cResult: PollResult<SyncExternalComment> = await tracker.listChangedComments(ref, cCursor);
+      for (const c of cResult.items) {
+        if (tracker.isBotUser(c.author)) continue;
+        const body = withProvenance(tracker.type, extId, c.body);
+        const resp = await fetch(`${webUrl}/api/v1/repos/${owner}/${repo}/issues/${issueNum}/comments`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `token ${webToken}` },
+          body: JSON.stringify({ body }),
+        });
+        if (resp.ok) {
+          log.info(`sync: created comment on issue #${issueNum} from ${tracker.type}:${extId}:${c.externalId}`);
+        } else {
+          log.warn(`sync: create comment failed: ${resp.status}`);
+        }
+      }
+      state.commentCursors[extId] = cResult.nextCursor ?? cCursor;
+    }
+
+    await saveCursors(this.opts.cursorFile, state);
+  }
+
+  start(): void {
+    if (this.running) return;
+    this.running = true;
+    log.info(`sync: poll loop started (interval=${this.opts.pollIntervalMs}ms, source=${this.opts.tracker.type})`);
+    this.pollOnce().catch(e => log.error(`sync: poll error: ${(e as Error).message}`));
+    this.timer = setInterval(() => {
+      this.pollOnce().catch(e => log.error(`sync: poll error: ${(e as Error).message}`));
+    }, this.opts.pollIntervalMs);
+  }
+
+  stop(): void {
+    this.running = false;
+    if (this.timer) clearInterval(this.timer);
+    log.info("sync: poll loop stopped");
+  }
+}

package/src/trackers/types.ts

@@ -141,6 +141,34 @@ export interface IssueTracker {
   isBotUser(userIdentifier: string): boolean;
 }
 
+// ─── Polling Tracker (Sync Source) ───
+
+export interface SyncExternalIssue {
+  externalId: string;
+  title: string;
+  body: string;
+  state: "open" | "closed";
+  author: string;
+  updatedAt: string;
+}
+
+export interface SyncExternalComment {
+  externalId: string;
+  body: string;
+  author: string;
+  createdAt: string;
+}
+
+export interface PollResult<T> {
+  items: T[];
+  nextCursor: string | null;
+}
+
+export interface PollingTracker extends IssueTracker {
+  listChangedIssues(scope: Record<string, string>, cursor: string | null): Promise<PollResult<SyncExternalIssue>>;
+  listChangedComments(ref: TrackerRef, cursor: string | null): Promise<PollResult<SyncExternalComment>>;
+}
+
 // ─── Runtime Key Format ───
 
 /**