@gethmy/agent 1.20.1 → 1.21.0

package/dist/cli.js

@@ -3240,12 +3240,48 @@ ${summary}`,
     agent_identifier: "harmony-agent"
   };
 }
-async function writeEpisode(client, input) {
+async function writeEpisode(client, input, options) {
   const payload = buildEpisodePayload(input, input.card.project_id);
+  let content = payload.content;
+  if (options?.distiller) {
+    try {
+      const distilled = await options.distiller(input, payload.content);
+      if (distilled && distilled.trim().length > 0) {
+        content = distilled.trim();
+      }
+    } catch (err) {
+      log.warn(TAG10, `episode distillation failed for #${input.card.short_id}`, {
+        cardId: input.card.id,
+        event: "episode_distill_failed",
+        kind: input.kind,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const metadata = payload.metadata;
   try {
+    const existingId = await findRollingEpisode(client, input.workspaceId, input.card.project_id, input.card.short_id, input.kind);
+    if (existingId) {
+      await client.updateMemoryEntity(existingId, {
+        title: payload.title,
+        content,
+        metadata,
+        confidence: payload.confidence,
+        tags: payload.tags,
+        type: payload.type
+      });
+      log.info(TAG10, `episode rolled for #${input.card.short_id}`, {
+        cardId: input.card.id,
+        event: "episode_rolled",
+        kind: input.kind,
+        entityId: existingId
+      });
+      return existingId;
+    }
     const { entity } = await client.createMemoryEntity({
       ...payload,
-      metadata: payload.metadata
+      content,
+      metadata
     });
     const id = entity && typeof entity === "object" && "id" in entity ? entity.id ?? null : null;
     log.info(TAG10, `episode written for #${input.card.short_id}`, {
@@ -3264,31 +3300,44 @@ async function writeEpisode(client, input) {
     return null;
   }
 }
-async function findLatestImplementEpisode(client, workspaceId, projectId, cardShortId) {
+async function findRollingEpisode(client, workspaceId, projectId, cardShortId, kind) {
+  const type = kind === "implement" ? ["solution", "error"] : ["decision"];
   try {
     const { entities } = await client.harmonyRecall({
       workspaceId,
       projectId,
-      type: ["solution", "error"],
+      type,
       memory_tier: "episode",
       scope: "project",
       tags: [`card:${cardShortId}`],
-      topK: 1
+      topK: 10,
+      includeEpisodes: true
     });
-    const first = entities[0];
-    if (first && typeof first === "object" && "id" in first && typeof first.id === "string") {
-      return first.id;
+    for (const entity of entities) {
+      if (!entity || typeof entity !== "object")
+        continue;
+      const meta = entity.metadata;
+      if (meta?.episode_kind !== kind || meta?.origin?.source !== "agent-run") {
+        continue;
+      }
+      const id = entity.id;
+      if (typeof id === "string")
+        return id;
     }
     return null;
   } catch (err) {
-    log.warn(TAG10, "implement-episode lookup failed", {
+    log.warn(TAG10, "rolling-episode lookup failed", {
       event: "episode_lookup_failed",
       cardShortId,
+      kind,
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
   }
 }
+async function findLatestImplementEpisode(client, workspaceId, projectId, cardShortId) {
+  return findRollingEpisode(client, workspaceId, projectId, cardShortId, "implement");
+}
 async function backfillReviewVerdict(client, originalEpisodeId, verdict, reviewEpisodeId) {
   try {
     if (verdict === "approved") {
@@ -8937,53 +8986,58 @@ class Pool {
     }
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
-    if (this.implQueue.has(card.id) || this.reviewQueue.has(card.id) || this.isCardActive(card.id)) {
-      log.debug(TAG31, `Card ${card.id} already queued or active, skipping`);
+    if (this.isCardKnown(card.id) || this.reservations.has(card.id)) {
+      log.debug(TAG31, `Card ${card.id} already queued, active, or reserved, skipping`);
       return;
     }
-    if (mode === "implement") {
-      if (this.authPaused) {
-        log.debug(TAG31, `#${card.short_id} held — agent paused (auth error)`);
-        await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
-        return;
-      }
-      const cooldownMs = this.apiCooldownRemainingMs();
-      if (cooldownMs > 0) {
-        log.debug(TAG31, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
-        await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
-        return;
-      }
-      const decision = this.budget.check(card.id);
-      if (!decision.allow) {
-        if (decision.reason === "daily_budget") {
-          log.warn(TAG31, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
-          await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
-        } else {
-          log.debug(TAG31, `#${card.short_id} gave up: ${decision.detail}`);
+    this.reservations.add(card.id);
+    try {
+      if (mode === "implement") {
+        if (this.authPaused) {
+          log.debug(TAG31, `#${card.short_id} held — agent paused (auth error)`);
+          await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
+          return;
+        }
+        const cooldownMs = this.apiCooldownRemainingMs();
+        if (cooldownMs > 0) {
+          log.debug(TAG31, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
+          await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
+          return;
+        }
+        const decision = this.budget.check(card.id);
+        if (!decision.allow) {
+          if (decision.reason === "daily_budget") {
+            log.warn(TAG31, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
+            await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
+          } else {
+            log.debug(TAG31, `#${card.short_id} gave up: ${decision.detail}`);
+          }
+          return;
+        }
+        const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
+        if (blockers === null) {
+          log.warn(TAG31, `#${card.short_id} blocker check failed — deferring to next tick`);
+          return;
+        }
+        if (blockers.length > 0) {
+          const list = blockers.map((b) => `#${b.shortId}`).join(", ");
+          log.info(TAG31, `#${card.short_id} blocked by ${list} — waiting`);
+          await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
+          return;
         }
-        return;
-      }
-      const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
-      if (blockers === null) {
-        log.warn(TAG31, `#${card.short_id} blocker check failed — deferring to next tick`);
-        return;
       }
-      if (blockers.length > 0) {
-        const list = blockers.map((b) => `#${b.shortId}`).join(", ");
-        log.info(TAG31, `#${card.short_id} blocked by ${list} — waiting`);
-        await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
-        return;
+      const queue = mode === "review" ? this.reviewQueue : this.implQueue;
+      queue.enqueue(card, column, labels, mode);
+      this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
+      const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
+      const dispatched = this.tryDispatchFor(workers, queue, mode);
+      if (!dispatched) {
+        const position = queue.cardIds().indexOf(card.id) + 1;
+        const total = queue.length;
+        await this.emitWaiting(card.id, position > 0 ? `Queued (${position}/${total}) — waiting for ${mode} worker` : `Queued — waiting for ${mode} worker`);
       }
-    }
-    const queue = mode === "review" ? this.reviewQueue : this.implQueue;
-    queue.enqueue(card, column, labels, mode);
-    this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
-    const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
-    const dispatched = this.tryDispatchFor(workers, queue, mode);
-    if (!dispatched) {
-      const position = queue.cardIds().indexOf(card.id) + 1;
-      const total = queue.length;
-      await this.emitWaiting(card.id, position > 0 ? `Queued (${position}/${total}) — waiting for ${mode} worker` : `Queued — waiting for ${mode} worker`);
+    } finally {
+      this.reservations.delete(card.id);
     }
   }
   lastWaitingEmit = new Map;
@@ -9025,6 +9079,7 @@ class Pool {
   async removeCard(cardId) {
     await this.stateStore.resetAttempts(cardId);
     this.lastWaitingEmit.delete(cardId);
+    this.reservations.delete(cardId);
     for (const queue of [this.implQueue, this.reviewQueue]) {
       const removed = queue.remove(cardId);
       if (removed) {
@@ -9129,6 +9184,7 @@ class Pool {
     this.sleepGuard.stop();
     log.info(TAG31, "Pool shutdown complete");
   }
+  reservations = new Set;
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
     if (this.shuttingDown)

package/dist/index.js

@@ -3239,12 +3239,48 @@ ${summary}`,
     agent_identifier: "harmony-agent"
   };
 }
-async function writeEpisode(client, input) {
+async function writeEpisode(client, input, options) {
   const payload = buildEpisodePayload(input, input.card.project_id);
+  let content = payload.content;
+  if (options?.distiller) {
+    try {
+      const distilled = await options.distiller(input, payload.content);
+      if (distilled && distilled.trim().length > 0) {
+        content = distilled.trim();
+      }
+    } catch (err) {
+      log.warn(TAG10, `episode distillation failed for #${input.card.short_id}`, {
+        cardId: input.card.id,
+        event: "episode_distill_failed",
+        kind: input.kind,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const metadata = payload.metadata;
   try {
+    const existingId = await findRollingEpisode(client, input.workspaceId, input.card.project_id, input.card.short_id, input.kind);
+    if (existingId) {
+      await client.updateMemoryEntity(existingId, {
+        title: payload.title,
+        content,
+        metadata,
+        confidence: payload.confidence,
+        tags: payload.tags,
+        type: payload.type
+      });
+      log.info(TAG10, `episode rolled for #${input.card.short_id}`, {
+        cardId: input.card.id,
+        event: "episode_rolled",
+        kind: input.kind,
+        entityId: existingId
+      });
+      return existingId;
+    }
     const { entity } = await client.createMemoryEntity({
       ...payload,
-      metadata: payload.metadata
+      content,
+      metadata
     });
     const id = entity && typeof entity === "object" && "id" in entity ? entity.id ?? null : null;
     log.info(TAG10, `episode written for #${input.card.short_id}`, {
@@ -3263,31 +3299,44 @@ async function writeEpisode(client, input) {
     return null;
   }
 }
-async function findLatestImplementEpisode(client, workspaceId, projectId, cardShortId) {
+async function findRollingEpisode(client, workspaceId, projectId, cardShortId, kind) {
+  const type = kind === "implement" ? ["solution", "error"] : ["decision"];
   try {
     const { entities } = await client.harmonyRecall({
       workspaceId,
       projectId,
-      type: ["solution", "error"],
+      type,
       memory_tier: "episode",
       scope: "project",
       tags: [`card:${cardShortId}`],
-      topK: 1
+      topK: 10,
+      includeEpisodes: true
     });
-    const first = entities[0];
-    if (first && typeof first === "object" && "id" in first && typeof first.id === "string") {
-      return first.id;
+    for (const entity of entities) {
+      if (!entity || typeof entity !== "object")
+        continue;
+      const meta = entity.metadata;
+      if (meta?.episode_kind !== kind || meta?.origin?.source !== "agent-run") {
+        continue;
+      }
+      const id = entity.id;
+      if (typeof id === "string")
+        return id;
     }
     return null;
   } catch (err) {
-    log.warn(TAG10, "implement-episode lookup failed", {
+    log.warn(TAG10, "rolling-episode lookup failed", {
       event: "episode_lookup_failed",
       cardShortId,
+      kind,
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
   }
 }
+async function findLatestImplementEpisode(client, workspaceId, projectId, cardShortId) {
+  return findRollingEpisode(client, workspaceId, projectId, cardShortId, "implement");
+}
 async function backfillReviewVerdict(client, originalEpisodeId, verdict, reviewEpisodeId) {
   try {
     if (verdict === "approved") {
@@ -8936,53 +8985,58 @@ class Pool {
     }
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
-    if (this.implQueue.has(card.id) || this.reviewQueue.has(card.id) || this.isCardActive(card.id)) {
-      log.debug(TAG31, `Card ${card.id} already queued or active, skipping`);
+    if (this.isCardKnown(card.id) || this.reservations.has(card.id)) {
+      log.debug(TAG31, `Card ${card.id} already queued, active, or reserved, skipping`);
       return;
     }
-    if (mode === "implement") {
-      if (this.authPaused) {
-        log.debug(TAG31, `#${card.short_id} held — agent paused (auth error)`);
-        await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
-        return;
-      }
-      const cooldownMs = this.apiCooldownRemainingMs();
-      if (cooldownMs > 0) {
-        log.debug(TAG31, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
-        await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
-        return;
-      }
-      const decision = this.budget.check(card.id);
-      if (!decision.allow) {
-        if (decision.reason === "daily_budget") {
-          log.warn(TAG31, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
-          await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
-        } else {
-          log.debug(TAG31, `#${card.short_id} gave up: ${decision.detail}`);
+    this.reservations.add(card.id);
+    try {
+      if (mode === "implement") {
+        if (this.authPaused) {
+          log.debug(TAG31, `#${card.short_id} held — agent paused (auth error)`);
+          await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
+          return;
+        }
+        const cooldownMs = this.apiCooldownRemainingMs();
+        if (cooldownMs > 0) {
+          log.debug(TAG31, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
+          await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
+          return;
+        }
+        const decision = this.budget.check(card.id);
+        if (!decision.allow) {
+          if (decision.reason === "daily_budget") {
+            log.warn(TAG31, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
+            await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
+          } else {
+            log.debug(TAG31, `#${card.short_id} gave up: ${decision.detail}`);
+          }
+          return;
+        }
+        const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
+        if (blockers === null) {
+          log.warn(TAG31, `#${card.short_id} blocker check failed — deferring to next tick`);
+          return;
+        }
+        if (blockers.length > 0) {
+          const list = blockers.map((b) => `#${b.shortId}`).join(", ");
+          log.info(TAG31, `#${card.short_id} blocked by ${list} — waiting`);
+          await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
+          return;
         }
-        return;
-      }
-      const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
-      if (blockers === null) {
-        log.warn(TAG31, `#${card.short_id} blocker check failed — deferring to next tick`);
-        return;
       }
-      if (blockers.length > 0) {
-        const list = blockers.map((b) => `#${b.shortId}`).join(", ");
-        log.info(TAG31, `#${card.short_id} blocked by ${list} — waiting`);
-        await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
-        return;
+      const queue = mode === "review" ? this.reviewQueue : this.implQueue;
+      queue.enqueue(card, column, labels, mode);
+      this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
+      const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
+      const dispatched = this.tryDispatchFor(workers, queue, mode);
+      if (!dispatched) {
+        const position = queue.cardIds().indexOf(card.id) + 1;
+        const total = queue.length;
+        await this.emitWaiting(card.id, position > 0 ? `Queued (${position}/${total}) — waiting for ${mode} worker` : `Queued — waiting for ${mode} worker`);
       }
-    }
-    const queue = mode === "review" ? this.reviewQueue : this.implQueue;
-    queue.enqueue(card, column, labels, mode);
-    this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
-    const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
-    const dispatched = this.tryDispatchFor(workers, queue, mode);
-    if (!dispatched) {
-      const position = queue.cardIds().indexOf(card.id) + 1;
-      const total = queue.length;
-      await this.emitWaiting(card.id, position > 0 ? `Queued (${position}/${total}) — waiting for ${mode} worker` : `Queued — waiting for ${mode} worker`);
+    } finally {
+      this.reservations.delete(card.id);
     }
   }
   lastWaitingEmit = new Map;
@@ -9024,6 +9078,7 @@ class Pool {
   async removeCard(cardId) {
     await this.stateStore.resetAttempts(cardId);
     this.lastWaitingEmit.delete(cardId);
+    this.reservations.delete(cardId);
     for (const queue of [this.implQueue, this.reviewQueue]) {
       const removed = queue.remove(cardId);
       if (removed) {
@@ -9128,6 +9183,7 @@ class Pool {
     this.sleepGuard.stop();
     log.info(TAG31, "Pool shutdown complete");
   }
+  reservations = new Set;
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
     if (this.shuttingDown)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/agent",
-  "version": "1.20.1",
+  "version": "1.21.0",
   "description": "Push-based agent daemon for Harmony — watches board assignments and spawns Claude CLI workers",
   "type": "module",
   "main": "dist/index.js",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.178",
     "@supabase/supabase-js": "2.95.3",
-    "@gethmy/mcp": "^2.16.0"
+    "@gethmy/mcp": "^2.17.0"
   },
   "devDependencies": {
     "@harmony/shared": "workspace:*",