agent-horde 0.1.3 → 0.1.5

package/src/tool/collaboration-actions.ts

@@ -22,12 +22,31 @@ interface CollaborationCommand {
 function evidenceRefs(state: CollaborationState, refs: string[] = []): string[] {
   for (const id of refs) {
     if (state.evidence.some((e) => e.id === id)) continue;
+    // A review is the record members most want to cite; it already names the evidence it rests on.
+    const review = state.reviews.find((r) => r.id === id);
+    if (review) throw new Error(`horde: ${id} is a review, not evidence; cite its evidence instead: ${review.evidence.join(", ") || "none recorded"}`);
+    // Evidence ids share the event counter, so the E# of the event that recorded V#, A# or Q# is
+    // the guess a member makes when it knows the record but not its evidence.
+    const recorded = recordedAtEvent(state, id);
+    if (recorded) throw new Error(`horde: ${id} is the event that recorded ${recorded.id}, not evidence; ${recorded.hint}`);
     const kind = /^[A-Z]\d+$/.test(id) && !id.startsWith("E") ? `; ${id} is not evidence, refs take E# ids (attach evidence first, or name ${id} as the target)` : "";
     throw new Error(`horde: unknown evidence ${id}${kind}`);
   }
   return refs;
 }
 
+function recordedAtEvent(state: CollaborationState, id: string): { id: string; hint: string } | undefined {
+  const seq = /^E(\d+)$/.exec(id)?.[1];
+  if (!seq) return undefined;
+  const review = state.reviews.find((r) => r.id === `V${seq}`);
+  if (review) return { id: review.id, hint: `cite ${review.id}'s evidence instead: ${review.evidence.join(", ") || "none recorded"}` };
+  const artifact = state.artifacts.find((a) => a.id === `A${seq}`);
+  if (artifact) return { id: artifact.id, hint: `attach evidence to ${artifact.id} first, or name ${artifact.id} as the target` };
+  const message = state.messages.find((m) => m.id === `Q${seq}`);
+  if (message) return { id: message.id, hint: `cite the evidence on ${message.id} instead: ${[...message.evidence, ...(message.responseEvidence ?? [])].join(", ") || "none recorded"}` };
+  return undefined;
+}
+
 /** Name the stale ref and both revisions, so a retry does not have to guess which evidence to replace. */
 function staleEvidence(state: CollaborationState, refs: string[], target: string, revision: string): string | undefined {
   const stale = refs.map((id) => state.evidence.find((e) => e.id === id)).find((e) => e && (e.target !== target || e.revision !== revision));
@@ -43,6 +62,8 @@ function newMessage(c: CollaborationCommand): EventDraft {
   const task = path.join(ctx.hordeDir, "runs", ctx.runId, "TASK.md");
   const count = fs.existsSync(task) ? Number(/^Members: (\d+)/m.exec(fs.readFileSync(task, "utf8"))?.[1]) : 0;
   if (!/^member-[1-9]\d*$/.test(to) || (count && Number(to.slice(7)) > count)) throw new Error("horde: recipient must be a member of this run");
+  // The recipient defaults to the target's owner, which is the sender itself on its own work.
+  if (to === ctx.actor) throw new Error(`horde: a message cannot be addressed to its sender; ${target} is yours, name another member with to=member-N`);
   if (p.revision && p.revision !== info.revision) throw new Error("horde: target changed; inspect current revision");
   const message: PeerMessage = {
     id: `Q${seq}`, sender: ctx.actor, to, target, revision: info.revision, kind: p.kind ?? "question",
@@ -175,7 +196,29 @@ function recordReview(c: CollaborationCommand): EventDraft {
     verdict: p.verdict, support: p.support, checked, unchecked: p.unchecked,
     text, evidence: refs },
     ...completeAssignedReview(c, target, `V${seq}`, text, refs),
-    ...(["refutes", "partially-supports"].includes(p.verdict) ? automaticChallenge(c, target, info, text, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
+    ...(["refutes", "partially-supports"].includes(p.verdict) ? automaticChallenge(c, target, info, text, refs) : {}),
+    ...(p.verdict === "supports" && !p.unchecked.trim() ? coverageClearance(c, target, info, `V${seq}`, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
+}
+
+/** The challenge a partially-supports review raised in its own event, as opposed to an objection a member wrote. */
+function coverageChallenge(state: CollaborationState, message: PeerMessage): boolean {
+  return state.reviews.some((r) => r.id === `V${message.id.slice(1)}` && r.actor === message.sender && r.verdict === "partially-supports");
+}
+
+/**
+ * A partial review opens a blocking challenge that only its sender may resolve. When that review
+ * contradicted nothing and another member later supports the whole revision, the unchecked scope
+ * is covered: the full review clears the challenge, and the resolution names both reviews.
+ */
+function coverageClearance(c: CollaborationCommand, target: string, info: { revision: string }, reviewId: string, refs: string[]): Record<string, unknown> {
+  const cleared = c.state.messages.filter((m) =>
+    m.target === target && m.revision === info.revision && m.blocking && m.state !== "resolved" && m.sender !== c.ctx.actor && coverageChallenge(c.state, m));
+  if (!cleared.length) return {};
+  return { clearances: cleared.map((m) => ({
+    id: m.id,
+    text: `cleared by ${reviewId}: ${c.ctx.actor}'s full-scope supporting review of ${target}@${info.revision.slice(0, 12)} covers the scope V${m.id.slice(1)} left unchecked`,
+    refs,
+  })) };
 }
 
 /** The parent's assignment closes with the review id and its evidence, so the thread shows what decided it. */

package/src/tool/collaboration-target.ts

@@ -59,7 +59,12 @@ export function retainArtifact(ctx: EventContext, file: string): { path: string;
   const runDir = path.join(ctx.hordeDir, "runs", ctx.runId);
   const root = fs.realpathSync(path.join(runDir, "artifacts"));
   const candidate = path.isAbsolute(file) ? file : path.join(runDir, file);
-  const real = fs.realpathSync(candidate);
+  let real: string;
+  try {
+    real = fs.realpathSync(candidate);
+  } catch {
+    throw new Error(`horde: artifactPath not found: ${file}; artifacts live under runs/${ctx.runId}/artifacts/`);
+  }
   if (!real.startsWith(root + path.sep) || !fs.statSync(real).isFile()) throw new Error("horde: evidence must be a file inside this run's artifacts directory");
   const bytes = fs.readFileSync(real);
   const hash = hashText(bytes);

package/src/tool/params.ts

@@ -75,7 +75,11 @@ export const HordeParams = Type.Object({
     }),
   ),
   note: Type.Optional(
-    Type.String({ description: "For a resource: a short pointer (path, command, or fact id) others should reuse" }),
+    Type.String({
+      description:
+        "For a resource: a short pointer (path, command, or fact id) others should reuse. For done/drop/rule-out: " +
+        "the result line, when text is not given",
+    }),
   ),
   cleanup: Type.Optional(
     Type.String({