cloving 1.2.0 → 1.4.0

package/templates/review-day/review-day.test.ts

@@ -0,0 +1,362 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { fakeStepBridge } from "cloving/workflows/testing";
+import { reviewDay } from "./review-day.ts";
+import { handoffProposal } from "./review-day/next.ts";
+import {
+  completed,
+  effects,
+  input,
+  report,
+  selection,
+  methods,
+  proposal,
+  proposalEffects,
+} from "./review-day/scenarios.ts";
+
+await test("CLV-200 failed facts block the review before a report or issue", async () => {
+  using bridge = fakeStepBridge({
+    effects: {
+      "command run:report": [
+        { kind: "failed", operationId: "report", reason: "command-exit" },
+      ],
+    },
+  });
+  assert.deepEqual(await reviewDay({ cycleId: "review-1", input: {} }), {
+    kind: "blocked",
+    cycleId: "review-1",
+    evidenceId: "review-day",
+    reason: "command-exit",
+  });
+  assert.deepEqual(
+    bridge.requests.map((request) =>
+      request[0] === "effect" ? request[1].method : request[0],
+    ),
+    ["run:report"],
+  );
+});
+
+await test("CLV-200 approval of proposal two waits for idea-to-issue then labels its issue", async () => {
+  using bridge = fakeStepBridge({
+    effects: proposalEffects(),
+    decisions: [{ decision: "answered", answer: "2" }],
+    waits: [
+      { kind: "handoff_requested", promotionId: "issue-42", reason: null },
+    ],
+  });
+  const outcome = await reviewDay(input);
+  assert.equal(outcome.kind, "handoff_requested");
+  const prefix = [
+    "run:report",
+    "run:reviews",
+    "run:improvements",
+    "run-turn",
+    "run-turn",
+    "discard",
+    ...(selection.post === "privacy" ? ["create-issue", "label"] : []),
+    "waitForDecision",
+  ];
+  assert.deepEqual(methods(bridge.requests), [
+    ...prefix,
+    ...(selection.next === "idea" ? ["handoff", "waitForRun", "label"] : []),
+  ]);
+  const handoffs = bridge.requests.filter(
+    (request) => request[0] === "handoff",
+  );
+  assert.deepEqual(
+    handoffs,
+    selection.next === "idea"
+      ? [
+          [
+            "handoff",
+            { workflowId: "idea-to-issue", input: { idea: proposal.text } },
+          ],
+        ]
+      : [],
+  );
+  const labels = bridge.requests
+    .filter(
+      (request) => request[0] === "effect" && request[1].method === "label",
+    )
+    .map((request) => {
+      assert.ok(request[0] === "effect");
+      const payload: unknown = JSON.parse(request[1].payload);
+      return payload;
+    });
+  assert.deepEqual(labels, [
+    ...(selection.post === "privacy"
+      ? [{ number: 9, add: ["cloving: review"], remove: [] }]
+      : []),
+    ...(selection.next === "idea"
+      ? [{ number: 42, add: ["cloving: improvement"], remove: [] }]
+      : []),
+  ]);
+});
+
+await test("CLV-200 denial, expiry, none and ambiguous approvals never hand off", async () => {
+  for (const decision of [
+    { decision: "denied" as const, answer: "2" },
+    { decision: "expired" as const, answer: "2" },
+    { decision: "answered" as const, answer: "none" },
+    { decision: "answered" as const, answer: "1,2" },
+    { decision: "approved" as const, answer: null },
+    { decision: "approved" as const, answer: "3" },
+  ]) {
+    using bridge = fakeStepBridge({
+      effects: proposalEffects(),
+      decisions: [decision],
+    });
+    assert.equal((await reviewDay(input)).kind, "handoff_requested");
+    assert.equal(
+      methods(bridge.requests).filter((method) => method === "waitForDecision")
+        .length,
+      1,
+    );
+    assert.ok(!methods(bridge.requests).includes("handoff"));
+  }
+});
+
+await test("CLV-200 missing child issue outcomes block without labeling an earlier issue", async () => {
+  for (const promotionId of [
+    null,
+    "issue-0",
+    "issue-4-other",
+    "pull-request-42",
+  ]) {
+    using bridge = fakeStepBridge({
+      effects: proposalEffects(),
+      decisions: [{ decision: "approved", answer: "1" }],
+      waits: [{ kind: "handoff_requested", reason: null, promotionId }],
+    });
+    await assert.rejects(handoffProposal(input, proposal), {
+      message: "improvement-issue-missing",
+    });
+    assert.equal(bridge.requests.at(-1)?.[0], "waitForRun");
+  }
+});
+
+await test("CLV-200 both turns carry all review rules and improvement verdict instructions", async () => {
+  using bridge = fakeStepBridge({ effects: effects() });
+  await reviewDay(input);
+  for (const request of bridge.requests) {
+    if (request[0] !== "effect" || request[1].method !== "run-turn") continue;
+    for (const rule of [
+      "Real changes only",
+      "outside",
+      "7-day band",
+      "3 days",
+      "inside the band",
+      "One constraint",
+      "wait time",
+      "lost runs",
+      "before adding capacity",
+      "Paired metrics",
+      "merged tickets",
+      "reverted or reopened",
+      "main CI failures",
+      "busy lanes",
+      "flaky failures",
+      "fix rounds",
+      "faster CI",
+      "escaped faults",
+      "Evidence",
+      "2 or more occurrences",
+      "trend over 7 days",
+      "links",
+      "single event",
+      "At most 3 proposals",
+      "hypothesis",
+      "one change",
+      "expected effect",
+      "3 to 7 days",
+      "cost",
+      "reverse",
+      "failure",
+      "One change for each loop",
+      "open improvement",
+      "Keep what works",
+      "80%",
+      "lanes",
+      "CI runners",
+      "host",
+      "system, not a person",
+      "before and after",
+      "check date",
+      "keep, reverse or continue",
+    ])
+      assert.ok(request[1].payload.includes(rule), rule);
+  }
+});
+
+await test("CLV-200 critique removes unsupported and already-improving loops even if the turn retains them", async () => {
+  const draft = {
+    ...report,
+    proposals: [
+      {
+        ...proposal,
+        id: "no-evidence",
+        text: "Unsupported proposal.",
+        evidence: [],
+      },
+      {
+        ...proposal,
+        id: "busy-loop",
+        text: "Conflicting proposal.",
+        loop: "develop",
+      },
+    ],
+  };
+  using bridge = fakeStepBridge({
+    effects: {
+      ...effects(),
+      "command run:improvements": [
+        completed([
+          { number: 8, loop: "develop", body: "Existing improvement." },
+        ]),
+      ],
+      "claude run-turn": [
+        completed({ summary: JSON.stringify(draft) }),
+        completed({ summary: JSON.stringify(draft) }),
+      ],
+    },
+  });
+  const outcome = await reviewDay(input);
+  assert.equal(outcome.kind, "handoff_requested");
+  assert.ok("report" in outcome && typeof outcome.report === "string");
+  assert.match(outcome.report, /## Proposals\n\nNone\./);
+  assert.match(outcome.report, /no-evidence: missing evidence/);
+  assert.match(outcome.report, /busy-loop: open improvement/);
+  assert.ok(!methods(bridge.requests).includes("waitForDecision"));
+});
+
+await test("CLV-200 critique cannot add or rewrite proposals and the report has at most three", async () => {
+  const proposals = [1, 2, 3, 4].map((id) => ({
+    ...proposal,
+    id: String(id),
+    text: `Change ${String(id)}.`,
+  }));
+  const draft = { ...report, proposals };
+  const critique = {
+    ...draft,
+    proposals: [...proposals, { ...proposal, id: "invented" }],
+  };
+  using bridge = fakeStepBridge({
+    effects: {
+      ...effects(),
+      "claude run-turn": [
+        completed({ summary: JSON.stringify(draft) }),
+        completed({ summary: JSON.stringify(critique) }),
+      ],
+    },
+    decisions: [{ decision: "denied", answer: null }],
+  });
+  const outcome = await reviewDay(input);
+  assert.ok("report" in outcome && typeof outcome.report === "string");
+  const body =
+    outcome.report.split("## Proposals")[1]?.split("## Watch list")[0] ?? "";
+  assert.match(body, /Change 3\./);
+  assert.doesNotMatch(body, /Change 4\.|invented/);
+  assert.match(outcome.report, /invented: not an unchanged analyzed proposal/);
+  assert.equal(methods(bridge.requests).at(-1), "waitForDecision");
+});
+
+await test("CLV-200 analyzes and critiques facts before posting and opens no decision without proposals", async () => {
+  using bridge = fakeStepBridge({ effects: effects() });
+  const outcome = await reviewDay(input);
+  assert.equal(outcome.kind, "handoff_requested");
+  assert.deepEqual(methods(bridge.requests), [
+    "run:report",
+    "run:reviews",
+    "run:improvements",
+    "run-turn",
+    "run-turn",
+    "discard",
+    ...(selection.post === "privacy" ? ["create-issue", "label"] : []),
+  ]);
+  for (const section of [
+    "Facts",
+    "Went well",
+    "Went badly",
+    "The constraint",
+    "Improvements in progress",
+    "Proposals",
+    "Watch list",
+    "Removed by the critique",
+  ])
+    assert.ok(
+      "report" in outcome &&
+        typeof outcome.report === "string" &&
+        outcome.report.includes(`## ${section}`),
+    );
+  const turns = bridge.requests.filter(
+    (request) => request[0] === "effect" && request[1].method === "run-turn",
+  );
+  assert.equal(turns.length, 2);
+  assert.ok(
+    turns[0]?.[0] === "effect" && turns[0][1].payload.includes('"metrics"'),
+  );
+  assert.ok(
+    turns[1]?.[0] === "effect" &&
+      turns[1][1].payload.includes(report.constraint),
+  );
+});
+
+await test("CLV-200 every failed or invalid JSON command blocks before analysis", async () => {
+  for (const name of ["report", "reviews", "improvements"]) {
+    for (const result of [
+      {
+        kind: "completed" as const,
+        operationId: name,
+        receipt: null,
+        result: "{",
+      },
+      { kind: "failed" as const, operationId: name, reason: "command-exit" },
+    ]) {
+      using bridge = fakeStepBridge({
+        effects: {
+          "command run:report": [
+            {
+              kind: "completed",
+              operationId: "r",
+              receipt: null,
+              result: "{}",
+            },
+          ],
+          "command run:reviews": [
+            {
+              kind: "completed",
+              operationId: "r",
+              receipt: null,
+              result: "[]",
+            },
+          ],
+          "command run:improvements": [
+            {
+              kind: "completed",
+              operationId: "r",
+              receipt: null,
+              result: "[]",
+            },
+          ],
+          [`command run:${name}`]: [result],
+        },
+      });
+      const outcome = await reviewDay({ cycleId: "review-1", input: {} });
+      assert.equal(outcome.kind, "blocked");
+      assert.equal(
+        "reason" in outcome ? outcome.reason : null,
+        result.kind === "failed" ? "command-exit" : "invalid-review-facts",
+      );
+      assert.deepEqual(
+        bridge.requests.map((request) => {
+          assert.equal(request[0], "effect");
+          return request[1].method;
+        }),
+        ["run:report", "run:reviews", "run:improvements"].slice(
+          0,
+          ["report", "reviews", "improvements"].indexOf(name) + 1,
+        ),
+      );
+    }
+  }
+});

package/templates/review-day/review-day.ts

@@ -0,0 +1,37 @@
+import type { CycleOutcome } from "cloving/workflows";
+import { reviewFacts, type ReviewInput } from "./review-day/facts.ts";
+import { reviewTurns } from "./review-day/turn.ts";
+import { renderReport } from "./review-day/report.ts";
+import { postAfterPrivacy as postReport } from "./review-day/post.ts";
+import { enforceCritique } from "./review-day/critique.ts";
+import { chooseProposal } from "./review-day/decision.ts";
+import { handoffProposal as nextProposal } from "./review-day/next.ts";
+
+export async function reviewDay(input: ReviewInput): Promise<CycleOutcome> {
+  "use workflow";
+  try {
+    const facts = await reviewFacts();
+    const { draft, critique } = await reviewTurns(input, facts);
+    const report = enforceCritique(draft, { critique, facts });
+    const text = renderReport(report);
+    await postReport(input, text);
+    const proposal = await chooseProposal(input, report.proposals);
+    if (proposal !== null) await nextProposal(input, proposal);
+    return {
+      kind: "handoff_requested",
+      cycleId: input.cycleId,
+      promotionId: "review-day",
+      report: text,
+    };
+  } catch (error) {
+    return {
+      kind: "blocked",
+      cycleId: input.cycleId,
+      evidenceId: "review-day",
+      reason:
+        error instanceof Error && /^[a-z][a-z0-9-]{0,127}$/.test(error.message)
+          ? error.message
+          : "review-failed",
+    };
+  }
+}

package/templates/review-day/template.json

@@ -0,0 +1,56 @@
+{
+  "version": 1,
+  "name": "review-day",
+  "summary": "Review the loops each day, critique the evidence and ask a person to approve at most one reversible improvement.",
+  "points": [
+    {
+      "id": "post",
+      "question": "Where should the reviewed report go?",
+      "options": [
+        {
+          "id": "privacy",
+          "label": "Post after the privacy check",
+          "summary": "Post the critiqued report and label only that new issue cloving: review.",
+          "change": "Keep postAfterPrivacy as postReport from review-day/post.ts in review-day.ts. Configure privateTexts with at least one nonblank item.",
+          "requires": {},
+          "needs": [
+            "default-harness",
+            "gh-login",
+            "github-origin",
+            "private-texts"
+          ]
+        },
+        {
+          "id": "result",
+          "label": "Keep in the run result",
+          "summary": "Return the report without posting a review issue.",
+          "change": "Remove the postReport import and await postReport(input, text) call from review-day.ts. Remove create-issue from methods.github. If next.nothing is also selected, remove label from methods.github. Keep github in capabilities and discard in methods.github for turn worktree cleanup in every option. Set selection.post to result in review-day/scenarios.ts.",
+          "requires": {},
+          "needs": ["default-harness"]
+        }
+      ]
+    },
+    {
+      "id": "next",
+      "question": "What happens after one proposal is approved?",
+      "options": [
+        {
+          "id": "idea",
+          "label": "Hand to idea-to-issue",
+          "summary": "Wait for the ticket and label only that new issue cloving: improvement.",
+          "change": "Keep handoffProposal as nextProposal from review-day/next.ts in review-day.ts and idea-to-issue in workflow.handoffs. Copy idea-to-issue into the private workflow folder and select its next.nothing option so it neither starts development nor adds cloving: ready.",
+          "requires": {},
+          "needs": ["gh-login", "github-origin", "private-texts"]
+        },
+        {
+          "id": "nothing",
+          "label": "Do nothing after approval",
+          "summary": "Record the decision without starting another workflow or changing any issue.",
+          "change": "Remove the nextProposal import from review-day.ts. Replace the chooseProposal assignment and the conditional nextProposal call with await chooseProposal(input, report.proposals). Set workflow.handoffs to [] and selection.next to nothing in review-day/scenarios.ts. If post.result is selected, remove label from methods.github. Keep github in capabilities and discard in methods.github for turn worktree cleanup in every option.",
+          "requires": {},
+          "needs": []
+        }
+      ]
+    }
+  ]
+}

package/dist/src/chats/analysis-batches.d.ts

@@ -1,42 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-import { type AnalysisSnapshot } from "./analysis-input.ts";
-import { type AnalysisBatchContext } from "./analysis-prompt.ts";
-export interface AnalysisBatchPosition {
-    readonly nextRecordIndex: number;
-    readonly completedBatchCount: number;
-    readonly previousResult: AnalysisResult | null;
-}
-export interface AnalysisBatch {
-    readonly kind: "batch";
-    readonly batchIndex: number;
-    readonly firstRecordIndex: number;
-    readonly nextRecordIndex: number;
-    readonly totalRecords: number;
-    readonly snapshot: AnalysisSnapshot;
-    readonly prompt: string;
-    readonly launchBytes: number;
-    readonly adapterDocument: string;
-    readonly context: AnalysisBatchContext;
-}
-export type AnalysisBatchPreparation = AnalysisBatch | {
-    readonly kind: "refused";
-    readonly code: "analysis-input-refused" | "analysis-too-large" | "analysis-batch-limit";
-};
-export declare const analysisCaptureBytes = 52428800;
-export declare function analysisBatchData(batch: AnalysisBatch, capture: {
-    readonly digest: string;
-    readonly snapshot?: AnalysisSnapshot;
-}): {
-    snapshot: AnalysisSnapshot;
-    context?: never;
-    batch?: never;
-} | {
-    snapshot: AnalysisSnapshot;
-    context: AnalysisBatchContext;
-    batch: {
-        batchIndex: number;
-        nextRecordIndex: number;
-        capturedDigest: string;
-    };
-};
-export declare function prepareAnalysisBatch(snapshot: AnalysisSnapshot, position: AnalysisBatchPosition): AnalysisBatchPreparation;

package/dist/src/chats/analysis-batches.js

@@ -1,97 +0,0 @@
-import { analysisDocumentBytes, analysisEvidence, isAnalysisSnapshot, validAnalysisImportId, } from "./analysis-input.js";
-import { analysisLaunchBytes, analysisPrompt, } from "./analysis-prompt.js";
-export const analysisCaptureBytes = 52_428_800;
-export function analysisBatchData(batch, capture) {
-    if (batch.batchIndex === 0 && batch.nextRecordIndex === batch.totalRecords)
-        return { snapshot: capture.snapshot ?? batch.snapshot };
-    return {
-        snapshot: batch.snapshot,
-        context: batch.context,
-        batch: {
-            batchIndex: batch.batchIndex,
-            nextRecordIndex: batch.nextRecordIndex,
-            capturedDigest: capture.digest,
-        },
-    };
-}
-export function prepareAnalysisBatch(snapshot, position) {
-    if (!isAnalysisSnapshot(snapshot) ||
-        !validAnalysisImportId(snapshot.importId))
-        return { kind: "refused", code: "analysis-input-refused" };
-    if (Buffer.byteLength(snapshot.corpus) > analysisCaptureBytes ||
-        [snapshot.redaction, snapshot.structure].some((text) => Buffer.byteLength(text) > analysisDocumentBytes))
-        return { kind: "refused", code: "analysis-too-large" };
-    try {
-        return preparedBatch(snapshot, position);
-    }
-    catch {
-        return { kind: "refused", code: "analysis-input-refused" };
-    }
-}
-function preparedBatch(snapshot, position) {
-    const lines = snapshot.corpus.match(/[^\n]*\n|[^\n]+$/g) ?? [];
-    if (![position.nextRecordIndex, position.completedBatchCount].every(Number.isSafeInteger) ||
-        position.nextRecordIndex < 0 ||
-        position.nextRecordIndex >= lines.length ||
-        position.completedBatchCount < 0 ||
-        position.completedBatchCount > 4)
-        return { kind: "refused", code: "analysis-input-refused" };
-    if (position.completedBatchCount === 4)
-        return { kind: "refused", code: "analysis-batch-limit" };
-    const structure = analysisEvidence(snapshot).structure;
-    let longest = {
-        kind: "refused",
-        code: "analysis-too-large",
-    };
-    for (let end = position.nextRecordIndex + 1; end <= lines.length; end++) {
-        const batch = batchOf(snapshot, { lines, position, end, structure });
-        if (Math.max(batch.launchBytes, Buffer.byteLength(batch.adapterDocument)) >
-            analysisDocumentBytes)
-            break;
-        longest = batch;
-    }
-    return longest;
-}
-function batchOf(snapshot, input) {
-    const { position, lines, end } = input;
-    const batchSnapshot = {
-        ...snapshot,
-        corpus: lines.slice(position.nextRecordIndex, end).join(""),
-        structure: projectedStructure(snapshot.importId, input),
-    };
-    const context = {
-        batchIndex: position.completedBatchCount,
-        firstRecordIndex: position.nextRecordIndex,
-        previousResult: position.previousResult,
-    };
-    const prompt = analysisPrompt(batchSnapshot, context);
-    return {
-        kind: "batch",
-        batchIndex: context.batchIndex,
-        firstRecordIndex: context.firstRecordIndex,
-        nextRecordIndex: end,
-        totalRecords: lines.length,
-        snapshot: batchSnapshot,
-        prompt,
-        launchBytes: analysisLaunchBytes(prompt),
-        adapterDocument: JSON.stringify({ snapshot: batchSnapshot, context }),
-        context,
-    };
-}
-function projectedStructure(importId, input) {
-    const { structure, position, end } = input;
-    return JSON.stringify({
-        schemaVersion: 1,
-        importId,
-        historyCompleteness: structure.historyCompleteness,
-        occurrences: structure.occurrences.slice(position.nextRecordIndex, end),
-        conflictGroups: structure.conflictGroups
-            .map((group) => ({
-            uuid: group.uuid,
-            variants: group.variants
-                .map((variant) => variant.filter((reference) => reference.recordIndex < end))
-                .filter((variant) => variant.length > 0),
-        }))
-            .filter((group) => group.variants.length > 0),
-    });
-}

package/dist/src/chats/analysis-checkpoint.d.ts

@@ -1,29 +0,0 @@
-import type { AnalysisResult } from "./analysis-contract.ts";
-export interface AnalysisCheckpoint {
-    readonly schemaVersion: 1;
-    readonly runId: string;
-    readonly importId: string;
-    readonly capturedDigest: string;
-    readonly batchIndex: number | null;
-    readonly status: "partial" | "complete";
-    readonly result: AnalysisResult | null;
-    readonly total: number;
-    readonly covered: number;
-    readonly uncovered: number;
-    readonly completedBatchCount: number;
-    readonly nextRecordIndex: number;
-}
-export interface AnalysisCheckpointCapture {
-    readonly runId: string;
-    readonly importId: string;
-    readonly digest: string;
-    readonly totalRecords: number;
-}
-export declare function initialAnalysisCheckpoint(capture: AnalysisCheckpointCapture): AnalysisCheckpoint;
-export declare function batchAnalysisCheckpoint(capture: AnalysisCheckpointCapture, position: {
-    readonly batchIndex: number;
-    readonly nextRecordIndex: number;
-    readonly result: AnalysisResult;
-}): AnalysisCheckpoint & {
-    readonly result: AnalysisResult;
-};

package/dist/src/chats/analysis-checkpoint.js

@@ -1,31 +0,0 @@
-export function initialAnalysisCheckpoint(capture) {
-    return {
-        schemaVersion: 1,
-        runId: capture.runId,
-        importId: capture.importId,
-        capturedDigest: capture.digest,
-        batchIndex: null,
-        status: "partial",
-        result: null,
-        total: capture.totalRecords,
-        covered: 0,
-        uncovered: capture.totalRecords,
-        completedBatchCount: 0,
-        nextRecordIndex: 0,
-    };
-}
-export function batchAnalysisCheckpoint(capture, position) {
-    return {
-        ...initialAnalysisCheckpoint(capture),
-        batchIndex: position.batchIndex,
-        status: position.nextRecordIndex === capture.totalRecords &&
-            position.result.openQuestion === undefined
-            ? "complete"
-            : "partial",
-        result: position.result,
-        covered: position.nextRecordIndex,
-        uncovered: capture.totalRecords - position.nextRecordIndex,
-        completedBatchCount: position.batchIndex + 1,
-        nextRecordIndex: position.nextRecordIndex,
-    };
-}