@gethmy/agent 1.0.3 → 1.0.4

package/dist/index.js

@@ -87,7 +87,7 @@ async function main() {
     const realtimeCreds = await fetchRealtimeCredentials(client);
     log.info(TAG, "Realtime credentials fetched");
     // Create pool
-    const pool = new Pool(config.agent, client, config.userEmail);
+    const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId);
     // Create reconciler
     const reviewColumns = config.agent.review.enabled
         ? config.agent.review.pickupColumns

package/dist/pool.d.ts

@@ -6,7 +6,7 @@ export declare class Pool {
     private reviewWorkers;
     private implQueue;
     private reviewQueue;
-    constructor(config: AgentConfig, client: HarmonyApiClient, userEmail: string);
+    constructor(config: AgentConfig, client: HarmonyApiClient, userEmail: string, workspaceId: string, projectId: string);
     /**
      * Enqueue a card for processing with the given mode.
      */

package/dist/pool.js

@@ -8,14 +8,14 @@ export class Pool {
     reviewWorkers = [];
     implQueue;
     reviewQueue;
-    constructor(config, client, userEmail) {
+    constructor(config, client, userEmail, workspaceId, projectId) {
         this.implQueue = new PriorityQueue(config);
         this.reviewQueue = new PriorityQueue(config);
         // Create implementation workers
         for (let i = 0; i < config.poolSize; i++) {
             this.implWorkers.push(new Worker(i, config, client, userEmail, () => {
                 this.tryDispatchFor(this.implWorkers, this.implQueue, "impl");
-            }));
+            }, workspaceId, projectId));
         }
         // Create review worker(s) — 1 review worker per pool
         if (config.review.enabled) {

package/dist/prompt.d.ts

@@ -1,5 +1,12 @@
+import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
 import type { EnrichedCard } from "./types.js";
 /**
- * Build the prompt that gets passed to Claude CLI for working on a card.
+ * Build the prompt for a card using the shared prompt generation pipeline.
+ *
+ * This calls `client.generateCardPrompt()` which assembles relevant memories
+ * from the knowledge graph, applies role-based framing, and produces a
+ * context-rich prompt — the same pipeline used by the MCP server.
+ *
+ * Falls back to a minimal local prompt if the API call fails.
  */
-export declare function buildPrompt(enriched: EnrichedCard, branchName: string, worktreePath: string): string;
+export declare function buildPrompt(enriched: EnrichedCard, branchName: string, worktreePath: string, client: HarmonyApiClient, workspaceId: string, projectId?: string): Promise<string>;

package/dist/prompt.js

@@ -1,7 +1,39 @@
+import { log } from "./log.js";
+const TAG = "prompt";
 /**
- * Build the prompt that gets passed to Claude CLI for working on a card.
+ * Build the prompt for a card using the shared prompt generation pipeline.
+ *
+ * This calls `client.generateCardPrompt()` which assembles relevant memories
+ * from the knowledge graph, applies role-based framing, and produces a
+ * context-rich prompt — the same pipeline used by the MCP server.
+ *
+ * Falls back to a minimal local prompt if the API call fails.
  */
-export function buildPrompt(enriched, branchName, worktreePath) {
+export async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId) {
+    const { card } = enriched;
+    try {
+        const result = await client.generateCardPrompt({
+            cardId: card.id,
+            workspaceId,
+            projectId,
+            variant: "execute",
+            customConstraints: `You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
+Do NOT push to main. All your work stays on \`${branchName}\`.
+When finished, call harmony_end_agent_session with status="completed".`,
+        });
+        log.info(TAG, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+        return result.prompt;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.warn(TAG, `Failed to generate prompt via API, using fallback: ${msg}`);
+        return buildFallbackPrompt(enriched, branchName, worktreePath);
+    }
+}
+/**
+ * Minimal fallback prompt when the API-based generation is unavailable.
+ */
+function buildFallbackPrompt(enriched, branchName, worktreePath) {
     const { card, column, labels, subtasks } = enriched;
     const labelStr = labels.length > 0 ? labels.map((l) => l.name).join(", ") : "none";
     const subtaskStr = subtasks.length > 0

package/dist/review-worker.d.ts

@@ -38,9 +38,9 @@ export declare class ReviewWorker {
      * Cancel the current review. Sends escalating signals to both processes.
      */
     cancel(): Promise<void>;
-    private checkDevServer;
     private spawnClaude;
     private waitForExit;
     private killDevServer;
+    private resolveLocalChanges;
     private cleanup;
 }

package/dist/review-worker.js

@@ -63,25 +63,47 @@ export class ReviewWorker {
             // Extract branch name from card description
             this.branchName = extractBranchFromDescription(card.description);
             const localMode = !this.branchName;
+            let localDiff = null;
             if (localMode) {
                 // LOCAL FALLBACK: no branch → review local working tree
                 log.info(this.tag, `No branch found for #${card.short_id}, attempting local review`);
                 // Use repo root as working directory
                 this.worktreePath = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-                    cwd: this.config.worktree.basePath,
                     encoding: "utf-8",
                     timeout: 5_000,
                 }).trim();
-                // Check if dev server is already running on the configured port
-                const serverRunning = await this.checkDevServer(this.reviewPort);
-                if (!serverRunning) {
-                    log.info(this.tag, `No dev server on port ${this.reviewPort} — adding "${NEED_REVIEW_LABEL}" label and moving to "${this.config.review.failColumn}"`);
+                // Try to find reviewable changes
+                const resolved = this.resolveLocalChanges(this.worktreePath, card.short_id);
+                if (!resolved) {
+                    // No changes found — post helpful note on the card and bail
+                    log.info(this.tag, `No local changes found for #${card.short_id} — posting note and moving to "${this.config.review.failColumn}"`);
+                    // Strip any previous agent note before appending a new one
+                    const AGENT_NOTE_SEPARATOR = "\n\n---\n**Agent Note: No branch found**";
+                    const existingDesc = card.description ?? "";
+                    const cleanDesc = existingDesc.includes(AGENT_NOTE_SEPARATOR)
+                        ? existingDesc.slice(0, existingDesc.indexOf(AGENT_NOTE_SEPARATOR))
+                        : existingDesc;
+                    const note = [
+                        cleanDesc,
+                        "",
+                        "---",
+                        "**Agent Note: No branch found**",
+                        "The review agent could not find a branch reference (`Branch: ...`) in this card's description,",
+                        `and no local uncommitted changes or recent commits referencing #${card.short_id} were found.`,
+                        "",
+                        "Please either:",
+                        "- Push the implementation branch and add `Branch: your-branch-name` to the description",
+                        '- Or move this card back to "To Do" for the implement worker to pick up',
+                    ].join("\n");
                     await Promise.all([
+                        this.client.updateCard(card.id, { description: note }),
                         addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR),
                         moveCardToColumn(this.client, card, this.config.review.failColumn),
                     ]);
                     return;
                 }
+                log.info(this.tag, `Found local changes via ${resolved.source} for #${card.short_id}`);
+                localDiff = resolved.diff;
             }
             if (this.branchName) {
                 log.info(this.tag, `Review branch: ${this.branchName}`);
@@ -125,26 +147,8 @@ export class ReviewWorker {
             let diff = "";
             try {
                 if (localMode) {
-                    // Local mode: show uncommitted changes or last commit's diff
-                    const uncommitted = execFileSync("git", ["diff"], {
-                        cwd,
-                        encoding: "utf-8",
-                        timeout: 30_000,
-                    });
-                    const staged = execFileSync("git", ["diff", "--cached"], {
-                        cwd,
-                        encoding: "utf-8",
-                        timeout: 30_000,
-                    });
-                    diff = [staged, uncommitted].filter(Boolean).join("\n");
-                    if (!diff) {
-                        // No uncommitted changes — get last commit's diff
-                        diff = execFileSync("git", ["diff", "HEAD~1..HEAD"], {
-                            cwd,
-                            encoding: "utf-8",
-                            timeout: 30_000,
-                        });
-                    }
+                    // Use pre-computed diff from resolveLocalChanges
+                    diff = localDiff ?? "";
                 }
                 else {
                     diff = execFileSync("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30_000 });
@@ -324,17 +328,6 @@ export class ReviewWorker {
             }
         }
     }
-    async checkDevServer(port) {
-        try {
-            const resp = await fetch(`http://localhost:${port}`, {
-                signal: AbortSignal.timeout(3_000),
-            });
-            return resp.ok;
-        }
-        catch {
-            return false;
-        }
-    }
     spawnClaude(prompt, systemPrompt, tracker) {
         return new Promise((resolve, reject) => {
             const args = [
@@ -413,6 +406,56 @@ export class ReviewWorker {
             log.debug(this.tag, "Killed dev server");
         }
     }
+    resolveLocalChanges(repoRoot, shortId) {
+        // 1. Check uncommitted changes (staged + unstaged combined)
+        try {
+            const localChanges = execFileSync("git", ["diff", "HEAD"], {
+                cwd: repoRoot,
+                encoding: "utf-8",
+                timeout: 5_000,
+            });
+            if (localChanges) {
+                return { diff: localChanges, source: "uncommitted changes" };
+            }
+        }
+        catch {
+            log.warn(this.tag, "Failed to check uncommitted changes");
+        }
+        // 2. Search recent commits for card reference
+        try {
+            const matchingCommits = execFileSync("git", ["log", "--format=%H", "-20", `--grep=#${shortId}`], { cwd: repoRoot, encoding: "utf-8", timeout: 10_000 }).trim();
+            if (matchingCommits) {
+                const hashes = matchingCommits
+                    .split("\n")
+                    .filter((h) => /^[0-9a-f]{4,40}$/i.test(h));
+                if (hashes.length === 0)
+                    return null;
+                log.info(this.tag, `Found ${hashes.length} commit(s) referencing #${shortId}`);
+                // Generate a combined diff from all matching commits
+                const diffs = [];
+                for (const hash of hashes) {
+                    try {
+                        const commitDiff = execFileSync("git", ["diff", `${hash}~1..${hash}`], { cwd: repoRoot, encoding: "utf-8", timeout: 30_000 });
+                        if (commitDiff)
+                            diffs.push(commitDiff);
+                    }
+                    catch {
+                        log.warn(this.tag, `Failed to diff commit ${hash}`);
+                    }
+                }
+                if (diffs.length > 0) {
+                    return {
+                        diff: diffs.join("\n"),
+                        source: `${diffs.length} commit(s) matching #${shortId}`,
+                    };
+                }
+            }
+        }
+        catch {
+            log.warn(this.tag, "Failed to search recent commits");
+        }
+        return null;
+    }
     cleanup() {
         if (this.timeoutTimer) {
             clearTimeout(this.timeoutTimer);

package/dist/worker.d.ts

@@ -5,6 +5,8 @@ export declare class Worker {
     private config;
     private client;
     private onDone;
+    private workspaceId;
+    private projectId;
     id: number;
     state: WorkerState;
     cardId: string | null;
@@ -16,7 +18,7 @@ export declare class Worker {
     private progressTracker;
     private lastSessionStats;
     private aborted;
-    constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: Worker) => void);
+    constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: Worker) => void, workspaceId: string, projectId: string);
     get tag(): string;
     get isIdle(): boolean;
     get isActive(): boolean;

package/dist/worker.js

@@ -14,6 +14,8 @@ export class Worker {
     config;
     client;
     onDone;
+    workspaceId;
+    projectId;
     id;
     state = "idle";
     cardId = null;
@@ -25,10 +27,12 @@ export class Worker {
     progressTracker = null;
     lastSessionStats;
     aborted = false;
-    constructor(id, config, client, _userEmail, onDone) {
+    constructor(id, config, client, _userEmail, onDone, workspaceId, projectId) {
         this.config = config;
         this.client = client;
         this.onDone = onDone;
+        this.workspaceId = workspaceId;
+        this.projectId = projectId;
         this.id = id;
     }
     get tag() {
@@ -84,7 +88,7 @@ export class Worker {
                 subtasks,
                 mode: "implement",
             };
-            const prompt = buildPrompt(enriched, this.branchName, this.worktreePath);
+            const prompt = await buildPrompt(enriched, this.branchName, this.worktreePath, this.client, this.workspaceId, this.projectId);
             await this.client.updateAgentProgress(card.id, {
                 agentIdentifier: agentIdentifier(this.id),
                 agentName: AGENT_NAME,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/agent",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Push-based agent daemon for Harmony — watches board assignments and spawns Claude CLI workers",
   "type": "module",
   "main": "dist/index.js",