@cueloop/schema 0.1.0-alpha.61 → 0.1.0-alpha.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/schema",
-  "version": "0.1.0-alpha.61",
+  "version": "0.1.0-alpha.63",
   "description": "The ReviewSession primitive: types, markdown block model, quote-primary anchors, feedback serialization",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {

package/src/feedback.test.ts

@@ -65,6 +65,25 @@ describe("renderFeedback", () => {
     expect(feedback).toContain("Apply this exact diff first");
   });
 
+  test("a reply review with no artifact path references reply.md, never plan.md", () => {
+    // Act
+    const feedback = renderFeedback({
+      verdictKind: "request_changes",
+      summary: "",
+      artifactContent: "# Findings\n\nThe cache is fine.\n",
+      artifactType: "reply",
+      annotations: [
+        makeAnnotation({ anchor: { quote: "The cache is fine.", prefix: "", suffix: "" } }),
+      ],
+      sessionId: "ses_reply",
+    });
+
+    // Assert
+    expect(feedback).toContain("Locate each one in reply.md");
+    expect(feedback).toContain("submit-revision ses_reply --content-file reply.md");
+    expect(feedback).not.toContain("plan.md");
+  });
+
   test("a diff working copy is handed back as the curated patch, not a diff of diffs", () => {
     // Arrange
     const submittedPatch = `--- a/src/x.ts

package/src/feedback.ts

@@ -37,7 +37,9 @@ export interface FeedbackInput {
 const quoteLines = (text: string) => "> " + text.replace(/\n/g, "\n> ");
 
 export function renderFeedback(input: FeedbackInput): string {
-  const path = input.artifactPath ?? "plan.md";
+  // The document the agent revises: a reply's feedback references reply.md so
+  // the resubmit instruction never points a reply review at plan.md.
+  const path = input.artifactPath ?? (input.artifactType === "reply" ? "reply.md" : "plan.md");
   // agent notes are the submitter's own context - never echoed back as
   // feedback - and annotations a previous revision already addressed stay out
   // of the next document, so the agent only ever sees the open items

package/src/types.test.ts

@@ -1,5 +1,24 @@
 import { describe, expect, test } from "bun:test";
-import { isMarkdownArtifact, newAnnotationId, verdictAllows } from "./types";
+import {
+  ARTIFACT_TYPES,
+  isArtifactType,
+  isMarkdownArtifact,
+  newAnnotationId,
+  verdictAllows,
+} from "./types";
+
+describe("ARTIFACT_TYPES", () => {
+  test("names every primitive exactly once", () => {
+    expect([...ARTIFACT_TYPES].sort()).toEqual(["diff", "plan", "prototype", "reply"]);
+    expect(new Set(ARTIFACT_TYPES).size).toBe(ARTIFACT_TYPES.length);
+  });
+
+  test("isArtifactType accepts every member and rejects strangers", () => {
+    for (const type of ARTIFACT_TYPES) expect(isArtifactType(type)).toBe(true);
+    expect(isArtifactType("blueprint")).toBe(false);
+    expect(isArtifactType("")).toBe(false);
+  });
+});
 
 describe("verdictAllows", () => {
   test("only approve maps to allow", () => {

package/src/types.ts

@@ -17,8 +17,19 @@ export interface WorkspaceKey {
  * markdown documents (see isMarkdownArtifact) - a plan is a proposal written
  * forward, a reply is the agent's previous message pulled back for review.
  * `diff` is a unified-diff patch; `prototype` is a rendered HTML page.
+ *
+ * One runtime union: every consumer that names the supported set - daemon
+ * wire validation, CLI flag parsing, adapter tool schemas - derives from this
+ * constant, so a new primitive extends them all without another hardcoded list.
  */
-export type ArtifactType = "plan" | "diff" | "prototype" | "reply";
+export const ARTIFACT_TYPES = ["plan", "diff", "prototype", "reply"] as const;
+
+export type ArtifactType = (typeof ARTIFACT_TYPES)[number];
+
+/** Trust-boundary guard: is this string one of the artifact primitives? */
+export function isArtifactType(value: string): value is ArtifactType {
+  return (ARTIFACT_TYPES as readonly string[]).includes(value);
+}
 
 /**
  * Markdown artifacts (plan, reply) are block-parsed and quote-anchored, so they