@boxxy/closeout 0.2.4 → 0.2.5

package/README.md

@@ -11,9 +11,9 @@
   </p>
 </div>
 
-boxxy's phase kinds: triage, design, build, review and verify. Each one gives the input of an
-attempt, checks the close-out the agent sends at the end of it, and settles the attempt from that
-close-out.
+boxxy's phase kinds: triage, design, build, review, verify and merge. Each one gives the input of an
+attempt, checks the close-out sent at the end of it, and settles the attempt from that close-out.
+The merge phase kind runs on a job worker, and its drive decides each read of the job.
 
 The package does no I/O: the caller passes in the item, its attempts, the attempt's evidence rows
 and what a close-out may name.
@@ -30,15 +30,17 @@ The package runs on [Bun](https://bun.sh) 1.3 or newer.
 
 ## Features
 
-- `triage`, `design`, `build` and `verify`, and `phaseKinds`, which lists them for the rules loader.
-  Each parser returns the stored close-out, or every problem with it in one pass.
+- `triage`, `design`, `build`, `verify` and `merge`, and `phaseKinds`, which lists them for the
+  rules loader. Each parser returns the stored close-out, or every problem with it in one pass.
+  `merge` drives each read with `decideMerge` from `@boxxy/train`, and a `merged` settle asks for
+  the `record-merge` effect.
 - `createReviewPhase`, which builds the review phase kind on the review gate's `buildCommand`. The
   server adds it to `phaseKinds`.
 - `countUnrelatedLines`, the changed lines of a later review in files that had no open finding.
 - `closeOutLimits`, the byte limit of a close-out, and `measureJsonBytes`, which measures a value as
   stored.
 - `dedupeOpenItems`, which matches each open item the agent reports to an open item with the same
-  title.
+  kind and title.
 
 ## Documentation
 

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { phaseKinds } from './phase-kinds.ts';
 export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
 export { createReviewPhase } from './phases/create-review-phase.ts';
+export { merge } from './phases/merge.ts';
 export { triage } from './phases/triage.ts';
 export { verify } from './phases/verify.ts';
 export { countUnrelatedLines } from './review/count-unrelated-lines.ts';

package/dist/phases/merge.d.ts

@@ -0,0 +1 @@
+export declare const merge: import("@boxxy/model").PhaseKind<unknown, import("@boxxy/content-hash").JsonValue, readonly string[]>;

package/dist/utils/build-criteria.d.ts

@@ -0,0 +1,4 @@
+import type { Criterion } from '@boxxy/model';
+export declare function buildCriteria(acceptance: readonly {
+    readonly text: string;
+}[]): Criterion[];

package/dist/utils/collect-open-item-problems.d.ts

@@ -0,0 +1,2 @@
+import type { CloseOutContext, CloseOutProblem, OpenItem } from '@boxxy/model';
+export declare function collectOpenItemProblems(openItems: readonly OpenItem[], ctx: CloseOutContext): CloseOutProblem[];

package/dist/utils/collect-relation-problems.d.ts

@@ -0,0 +1,2 @@
+import type { CloseOutContext, CloseOutProblem, RelationDraft } from '@boxxy/model';
+export declare function collectRelationProblems(relations: readonly RelationDraft[], implied: readonly RelationDraft[], ctx: CloseOutContext): CloseOutProblem[];

package/dist/utils/find-latest-conclusion.d.ts

@@ -0,0 +1,2 @@
+import type { AttemptRow } from '@boxxy/model';
+export declare function findLatestConclusion(history: readonly AttemptRow[]): string | null;

package/dist/utils/find-stopped-reason.d.ts

@@ -0,0 +1,3 @@
+import type { AttemptRow } from '@boxxy/model';
+import type { z } from 'zod';
+export declare function findStoppedReason<Body>(history: readonly AttemptRow[], phase: string, schema: z.ZodType<Body>, pickReason: (body: Body) => string | null): string | null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@boxxy/closeout",
-  "version": "0.2.4",
-  "description": "boxxy's phase kinds: the input, the close-out parser and the settle rule of triage, design, build and review",
+  "version": "0.2.5",
+  "description": "boxxy's phase kinds: the input, the close-out parser and the settle rule of triage, design, build, review, verify and merge",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/modules/closeout#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
   "license": "MIT",
@@ -30,14 +30,15 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/model": "0.2.4",
+    "@boxxy/model": "0.2.5",
+    "@boxxy/train": "0.2.5",
     "tiny-invariant": "1.3.3",
     "ts-pattern": "5.9.2",
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@boxxy/planning": "0.2.4",
-    "@boxxy/rules": "0.2.4",
+    "@boxxy/planning": "0.2.5",
+    "@boxxy/rules": "0.2.5",
     "@faker-js/faker": "10.6.0"
   },
   "peerDependencies": {

package/src/dedupe-open-items.ts

@@ -1,46 +1,56 @@
-import type { ItemId, ItemView, OpenItem } from '@boxxy/model';
+import type { ItemId, ItemKindName, ItemView, OpenItem } from '@boxxy/model';
 import { normaliseTitle } from './normalise-title.ts';
 
+// An entry matches an open item of its own kind whose title is equal after normalising.
 export function dedupeOpenItems(
   entries: readonly OpenItem[],
   open: readonly ItemView[],
 ): { readonly file: readonly OpenItem[]; readonly matched: readonly ItemId[] } {
-  const openByTitle = collectOpenByTitle(open);
-  const matched = entries.flatMap((entry) => openByTitle.get(normaliseTitle(entry.title)) ?? []);
+  const openByKey = collectOpenByKey(open);
+  const matched = entries.flatMap((entry) => openByKey.get(toDedupeKey(entry)) ?? []);
 
-  return { file: collectNewEntries(entries, openByTitle), matched: [...new Set(matched)] };
+  return { file: collectNewEntries(entries, openByKey), matched: [...new Set(matched)] };
 }
 
-function collectOpenByTitle(open: readonly ItemView[]): Map<string, ItemId> {
-  const openByTitle = new Map<string, ItemId>();
+function collectOpenByKey(open: readonly ItemView[]): Map<string, ItemId> {
+  const openByKey = new Map<string, ItemId>();
 
   for (const item of open) {
-    const title = normaliseTitle(item.title);
+    const key = toDedupeKey(item);
 
-    if (!openByTitle.has(title)) {
-      openByTitle.set(title, item.id);
+    if (!openByKey.has(key)) {
+      openByKey.set(key, item.id);
     }
   }
 
-  return openByTitle;
+  return openByKey;
+}
+
+interface Titled {
+  readonly kind: ItemKindName;
+  readonly title: string;
+}
+
+function toDedupeKey(entry: Titled): string {
+  return JSON.stringify([entry.kind, normaliseTitle(entry.title)]);
 }
 
 function collectNewEntries(
   entries: readonly OpenItem[],
-  openByTitle: ReadonlyMap<string, ItemId>,
+  openByKey: ReadonlyMap<string, ItemId>,
 ): OpenItem[] {
   const seen = new Set<string>();
 
   const file: OpenItem[] = [];
 
   for (const entry of entries) {
-    const title = normaliseTitle(entry.title);
+    const key = toDedupeKey(entry);
 
-    if (!openByTitle.has(title) && !seen.has(title)) {
+    if (!openByKey.has(key) && !seen.has(key)) {
       file.push(entry);
     }
 
-    seen.add(title);
+    seen.add(key);
   }
 
   return file;

package/src/index.ts

@@ -5,6 +5,7 @@ export { phaseKinds } from './phase-kinds.ts';
 export { build } from './phases/build.ts';
 export { design } from './phases/design.ts';
 export { createReviewPhase } from './phases/create-review-phase.ts';
+export { merge } from './phases/merge.ts';
 export { triage } from './phases/triage.ts';
 export { verify } from './phases/verify.ts';
 export { countUnrelatedLines } from './review/count-unrelated-lines.ts';

package/src/phase-kinds.ts

@@ -1,9 +1,11 @@
 import type { PhaseKind } from '@boxxy/model';
 import { build } from './phases/build.ts';
 import { design } from './phases/design.ts';
+import { merge } from './phases/merge.ts';
 import { triage } from './phases/triage.ts';
 import { verify } from './phases/verify.ts';
 
 // The phase kinds that need no port, in pipeline order. The server adds the review phase kind,
-// which it builds on its review gate.
-export const phaseKinds: readonly PhaseKind[] = [triage, design, build, verify];
+// which it builds on its review gate. The merge phase kind loads only on a server that builds its
+// job worker, because the loader refuses a step whose worker the server did not build.
+export const phaseKinds: readonly PhaseKind[] = [triage, design, build, verify, merge];

package/src/phases/build.ts

@@ -24,9 +24,13 @@ import type { z } from 'zod';
 import { buildSchemaParser } from '../build-schema-parser.ts';
 import { missingCriteria } from '../missing-criteria.ts';
 import { buildCriterionTexts } from '../utils/build-criterion-texts.ts';
+import { collectOpenItemProblems } from '../utils/collect-open-item-problems.ts';
+import { collectRelationProblems } from '../utils/collect-relation-problems.ts';
 import { findLatestCloseOut } from '../utils/find-latest-close-out.ts';
+import { findLatestConclusion } from '../utils/find-latest-conclusion.ts';
 import { findLatestDesign } from '../utils/find-latest-design.ts';
 import { findPullRequestLink } from '../utils/find-pull-request-link.ts';
+import { findStoppedReason } from '../utils/find-stopped-reason.ts';
 
 const buildBodySchema = buildCloseOutSchema.omit({ frictionDropped: true });
 
@@ -67,7 +71,11 @@ function buildBuildInput(ctx: PhaseInputContext): BuildInput {
   return {
     acceptance: buildCriterionTexts(ctx.item),
     design: findLatestDesign(ctx.history),
+    conclusion: findLatestConclusion(ctx.history),
     sentBack: findSentBack(ctx.history),
+    stopped: findStoppedReason(ctx.history, 'build', buildCloseOutSchema, (body) =>
+      body.result.kind === 'blocked' ? body.result.reason : null,
+    ),
     pullRequest: findPullRequestLink(ctx.pullRequests),
   };
 }
@@ -125,13 +133,16 @@ function collectBuildProblems(closeOut: BuildCloseOut, ctx: CloseOutContext): Cl
     ...[...unknownCriteria].map((criterion) => ({ kind: 'unknown-criterion' as const, criterion })),
     ...[...foreignEvidence].map((evidence) => ({ kind: 'foreign-evidence' as const, evidence })),
     ...(missing.length > 0 ? [{ kind: 'built-without-evidence' as const, criteria: missing }] : []),
+    ...collectOpenItemProblems(closeOut.openItems, ctx),
+    ...collectRelationProblems(closeOut.relations ?? [], [], ctx),
   ];
 }
 
 function collectBuildEffects(closeOut: BuildCloseOut, item: ItemView): Effect[] {
   const acceptance = buildCitedAcceptance(item.acceptance, closeOut.criteria);
 
-  // a failed build changes no item: the next build of the item cites its evidence again
+  // a failed build keeps the item's acceptance list: the next build of the item cites its evidence
+  // again
   const isChanged =
     closeOut.result.kind === 'built' &&
     acceptance.some(
@@ -141,6 +152,7 @@ function collectBuildEffects(closeOut: BuildCloseOut, item: ItemView): Effect[]
   return [
     ...closeOut.openItems.map((openItem) => ({ kind: 'file-item' as const, item: openItem })),
     ...(isChanged ? [{ kind: 'set-acceptance' as const, criteria: acceptance }] : []),
+    ...(closeOut.relations ?? []).map((relation) => ({ kind: 'add-relation' as const, relation })),
     ...closeOut.friction.map((friction) => ({ kind: 'record-proposal' as const, friction })),
   ];
 }

package/src/phases/design.ts

@@ -1,9 +1,20 @@
-import type { AcceptanceInput, DesignCloseOut } from '@boxxy/model';
+import type {
+  AcceptanceInput,
+  CloseOutContext,
+  CloseOutProblem,
+  DesignCloseOut,
+  Effect,
+  RelationDraft,
+} from '@boxxy/model';
 import { brandSchemas, definePhase, designCloseOutSchema, toJSONValue } from '@boxxy/model';
 import { match } from 'ts-pattern';
 import type { z } from 'zod';
 import { buildSchemaParser } from '../build-schema-parser.ts';
+import { buildCriteria } from '../utils/build-criteria.ts';
 import { buildCriterionTexts } from '../utils/build-criterion-texts.ts';
+import { collectOpenItemProblems } from '../utils/collect-open-item-problems.ts';
+import { collectRelationProblems } from '../utils/collect-relation-problems.ts';
+import { findStoppedReason } from '../utils/find-stopped-reason.ts';
 
 const designBodySchema = designCloseOutSchema.omit({ frictionDropped: true });
 
@@ -12,17 +23,22 @@ export const design = definePhase({
   version: 1,
   worker: brandSchemas.workerKindName.parse('atc.session'),
   outcomes: ['designed', 'blocked', 'abandoned'],
-  needsAcceptance: true,
+  needsAcceptance: false,
   mode: (item) => (item.fields.designMode === 'attended' ? 'attended' : 'agent'),
   input: (ctx) =>
-    toJSONValue({ acceptance: buildCriterionTexts(ctx.item) } satisfies AcceptanceInput),
+    toJSONValue({
+      acceptance: buildCriterionTexts(ctx.item),
+      stopped: findStoppedReason(ctx.history, 'design', designCloseOutSchema, (body) =>
+        body.result.kind === 'blocked' ? body.result.reason : null,
+      ),
+    } satisfies AcceptanceInput),
   closeOut: buildSchemaParser({
     schema: designBodySchema,
     toBody: (raw: z.output<typeof designBodySchema>, frictionDropped): DesignCloseOut => ({
       ...raw,
       frictionDropped,
     }),
-    check: () => [],
+    check: collectDesignProblems,
   }),
 
   // A blocked or abandoned design did not reach its goal, so its attempt fails. The failure is
@@ -36,7 +52,43 @@ export const design = definePhase({
       }))
       .exhaustive(),
     outcome: input.closeOut.result.kind,
-    effects: input.closeOut.friction.map((friction) => ({ kind: 'record-proposal', friction })),
+    effects: collectDesignEffects(input.closeOut),
     frictionDropped: input.closeOut.frictionDropped,
   }),
 });
+
+function collectDesignProblems(closeOut: DesignCloseOut, ctx: CloseOutContext): CloseOutProblem[] {
+  const openItems = closeOut.result.kind === 'designed' ? (closeOut.result.openItems ?? []) : [];
+
+  return [
+    ...collectOpenItemProblems(openItems, ctx),
+    ...collectRelationProblems(getDesignRelations(closeOut), [], ctx),
+  ];
+}
+
+function getDesignRelations(closeOut: DesignCloseOut): readonly RelationDraft[] {
+  return match(closeOut.result)
+    .with({ kind: 'designed' }, { kind: 'blocked' }, (result) => result.relations ?? [])
+    .with({ kind: 'abandoned' }, () => [])
+    .exhaustive();
+}
+
+function collectDesignEffects(closeOut: DesignCloseOut): Effect[] {
+  const designed = closeOut.result.kind === 'designed' ? closeOut.result : null;
+  const acceptance = designed?.set?.acceptance;
+
+  return [
+    ...(designed?.openItems ?? []).map((openItem) => ({
+      kind: 'file-item' as const,
+      item: openItem,
+    })),
+    ...(acceptance === undefined
+      ? []
+      : [{ kind: 'set-acceptance' as const, criteria: buildCriteria(acceptance) }]),
+    ...getDesignRelations(closeOut).map((relation) => ({
+      kind: 'add-relation' as const,
+      relation,
+    })),
+    ...closeOut.friction.map((friction) => ({ kind: 'record-proposal' as const, friction })),
+  ];
+}

package/src/phases/merge.ts

@@ -0,0 +1,74 @@
+import type { AttemptRow, MergeCloseOut, MergeInput, MergeRequest } from '@boxxy/model';
+import {
+  brandSchemas,
+  definePhase,
+  mergeCloseOutSchema,
+  mergeInputSchema,
+  mergeReadingSchema,
+  toJSONValue,
+} from '@boxxy/model';
+import { decideMerge } from '@boxxy/train';
+import invariant from 'tiny-invariant';
+import { buildSchemaParser } from '../build-schema-parser.ts';
+import { findPullRequestLink } from '../utils/find-pull-request-link.ts';
+
+// No agent decides a merge: the runner calls the pure merge rule on each read of the job, and
+// writes the close-out that the rule finishes with.
+export const merge = definePhase({
+  name: brandSchemas.phaseName.parse('merge'),
+  version: 1,
+  worker: brandSchemas.workerKindName.parse('merge.forge'),
+  outcomes: ['merged', 'repair', 'stale', 'unverified', 'closed', 'stalled', 'refused', 'blocked'],
+  needsAcceptance: true,
+  input: (ctx) => {
+    const input: MergeInput = { pullRequest: findPullRequestLink(ctx.pullRequests) };
+
+    return toJSONValue(input);
+  },
+  drive: (ctx) => {
+    invariant(ctx.rules.merge !== null, 'the loader refuses a merge step with no merge block');
+
+    return decideMerge({
+      observed: mergeReadingSchema.parse(ctx.observed),
+      rules: ctx.rules.merge,
+      deadlinePassed: ctx.deadlinePassed,
+      acted: findMergeRequest(ctx.attempt),
+      now: ctx.now,
+      actRetryMinutes: ctx.actRetryMinutes,
+    });
+  },
+  closeOut: buildSchemaParser({
+    schema: mergeCloseOutSchema,
+    toBody: (raw): MergeCloseOut => raw,
+    check: () => [],
+  }),
+  settle: (input) => {
+    const closeOut = input.closeOut;
+    const isMerged = closeOut.outcome === 'merged';
+    const pullRequest = mergeInputSchema.parse(input.attempt.input).pullRequest;
+
+    return {
+      state: isMerged ? 'succeeded' : 'failed',
+      failure: isMerged ? null : closeOut.outcome,
+      outcome: closeOut.outcome,
+      effects:
+        isMerged && pullRequest !== null
+          ? [
+              {
+                kind: 'record-merge',
+                pullRequest: { repo: pullRequest.repo, number: pullRequest.number },
+                mergeCommit: closeOut.mergeCommit,
+              },
+            ]
+          : [],
+      frictionDropped: 0,
+    };
+  },
+});
+
+// the last request that the runner marked on the attempt row, with the forge's answer once one came
+function findMergeRequest(attempt: AttemptRow): MergeRequest | null {
+  return attempt.actedAt === null || attempt.actedHead === null
+    ? null
+    : { at: attempt.actedAt, head: attempt.actedHead, answer: attempt.actedAnswer };
+}

package/src/phases/triage.ts

@@ -2,7 +2,6 @@ import type {
   AcceptanceInput,
   CloseOutContext,
   CloseOutProblem,
-  Criterion,
   Effect,
   TriageCloseOut,
 } from '@boxxy/model';
@@ -10,7 +9,11 @@ import { brandSchemas, definePhase, toJSONValue, triageCloseOutSchema } from '@b
 import { match } from 'ts-pattern';
 import type { z } from 'zod';
 import { buildSchemaParser } from '../build-schema-parser.ts';
+import { buildCriteria } from '../utils/build-criteria.ts';
 import { buildCriterionTexts } from '../utils/build-criterion-texts.ts';
+import { collectOpenItemProblems } from '../utils/collect-open-item-problems.ts';
+import { collectRelationProblems } from '../utils/collect-relation-problems.ts';
+import { findStoppedReason } from '../utils/find-stopped-reason.ts';
 
 const triageBodySchema = triageCloseOutSchema.omit({ frictionDropped: true });
 
@@ -18,10 +21,15 @@ export const triage = definePhase({
   name: brandSchemas.phaseName.parse('triage'),
   version: 1,
   worker: brandSchemas.workerKindName.parse('atc.session'),
-  outcomes: ['accepted', 'duplicate', 'declined'],
+  outcomes: ['accepted', 'duplicate', 'declined', 'needs-owner', 'split'],
   needsAcceptance: false,
   input: (ctx) =>
-    toJSONValue({ acceptance: buildCriterionTexts(ctx.item) } satisfies AcceptanceInput),
+    toJSONValue({
+      acceptance: buildCriterionTexts(ctx.item),
+      stopped: findStoppedReason(ctx.history, 'triage', triageCloseOutSchema, (body) =>
+        body.result.kind === 'needs-owner' ? body.result.question : null,
+      ),
+    } satisfies AcceptanceInput),
   closeOut: buildSchemaParser({
     schema: triageBodySchema,
     toBody: (raw: z.output<typeof triageBodySchema>, frictionDropped): TriageCloseOut => ({
@@ -43,10 +51,12 @@ function collectTriageProblems(closeOut: TriageCloseOut, ctx: CloseOutContext):
   const acceptance = closeOut.set?.acceptance ?? ctx.item.acceptance;
   const kind = closeOut.set?.kind;
   const duplicateOf = closeOut.result.kind === 'duplicate' ? [closeOut.result.of] : [];
+  const parts = closeOut.result.kind === 'split' ? closeOut.result.openItems : [];
 
-  const named = [...duplicateOf, ...closeOut.relations.map((relation) => relation.target)].filter(
-    (item) => item !== ctx.item.id,
-  );
+  const implied = duplicateOf.map((target) => ({
+    type: brandSchemas.relationTypeName.parse('duplicate-of'),
+    target,
+  }));
 
   return [
     ...(closeOut.result.kind === 'accepted' && acceptance.length === 0
@@ -55,63 +65,17 @@ function collectTriageProblems(closeOut: TriageCloseOut, ctx: CloseOutContext):
     ...(kind !== undefined && !ctx.world.kinds.has(kind)
       ? [{ kind: 'unknown-kind' as const, itemKind: kind }]
       : []),
-    ...[...new Set(named)]
-      .filter((item) => !ctx.world.items.has(item))
-      .map((item) => ({ kind: 'unknown-item' as const, item })),
+    ...collectOpenItemProblems(parts, ctx),
     ...duplicateOf
       .filter((item) => item === ctx.item.id)
       .map(() => ({
         kind: 'phase-rule' as const,
         message: 'an item is not a duplicate of itself',
       })),
-    ...closeOut.relations.flatMap((relation) => collectRelationProblems(relation, ctx)),
-    ...collectRepeatedRelations(closeOut, duplicateOf),
-  ];
-}
-
-function collectRelationProblems(
-  relation: TriageCloseOut['relations'][number],
-  ctx: CloseOutContext,
-): CloseOutProblem[] {
-  const refused = (reason: 'unknown-type' | 'self'): CloseOutProblem => ({
-    kind: 'refused-relation',
-    type: relation.type,
-    target: relation.target,
-    reason,
-  });
-
-  return [
-    ...(ctx.world.relationTypes.has(relation.type) ? [] : [refused('unknown-type')]),
-    ...(relation.target === ctx.item.id ? [refused('self')] : []),
-  ];
-}
-
-// Each relation is one row of the store, so a close-out names each pair of type and target once.
-// A duplicate's `of` names the `duplicate-of` relation already.
-function collectRepeatedRelations(
-  closeOut: TriageCloseOut,
-  duplicateOf: readonly TriageCloseOut['relations'][number]['target'][],
-): CloseOutProblem[] {
-  const named = [
-    ...duplicateOf.map((target) => ({ type: 'duplicate-of', target })),
-    ...closeOut.relations,
+    ...collectRelationProblems(closeOut.relations, implied, ctx),
   ];
-
-  return named.flatMap((relation, index) =>
-    named
-      .slice(0, index)
-      .some((earlier) => earlier.type === relation.type && earlier.target === relation.target)
-      ? [
-          {
-            kind: 'phase-rule' as const,
-            message: `the close-out names ${relation.type} ${relation.target} more than once`,
-          },
-        ]
-      : [],
-  );
 }
 
-// A duplicate closes with `of`, which adds the `duplicate-of` relation in the same change.
 function collectTriageEffects(closeOut: TriageCloseOut): Effect[] {
   const set = closeOut.set ?? {};
 
@@ -123,25 +87,23 @@ function collectTriageEffects(closeOut: TriageCloseOut): Effect[] {
     ...(set.acceptance === undefined
       ? []
       : [{ kind: 'set-acceptance' as const, criteria: buildCriteria(set.acceptance) }]),
+    ...(set.body === undefined ? [] : [{ kind: 'set-body' as const, body: set.body }]),
     ...closeOut.relations.map((relation) => ({ kind: 'add-relation' as const, relation })),
-    ...buildCloseEffects(closeOut.result),
+    ...buildResultEffects(closeOut.result),
     ...closeOut.friction.map((friction) => ({ kind: 'record-proposal' as const, friction })),
   ];
 }
 
-// The list replaces the item's list whole, so its criteria are numbered from `a1`.
-function buildCriteria(acceptance: readonly { readonly text: string }[]): Criterion[] {
-  return acceptance.map((criterion, index) => ({
-    id: brandSchemas.criterionId.parse(`a${index + 1}`),
-    text: criterion.text,
-    evidence: [],
-  }));
-}
-
-function buildCloseEffects(result: TriageCloseOut['result']): Effect[] {
+// A duplicate closes with `of`, which adds the `duplicate-of` relation in the same change. A split
+// files its parts and closes the item; a hold edge withholds the close, and the parts still file.
+function buildResultEffects(result: TriageCloseOut['result']): Effect[] {
   return match(result)
     .returnType<Effect[]>()
-    .with({ kind: 'accepted' }, () => [])
+    .with({ kind: 'accepted' }, { kind: 'needs-owner' }, () => [])
+    .with({ kind: 'split' }, (split) => [
+      ...split.openItems.map((openItem) => ({ kind: 'file-item' as const, item: openItem })),
+      { kind: 'close-item' as const, reason: 'split', of: null },
+    ])
     .with({ kind: 'duplicate' }, (duplicate) => [
       { kind: 'close-item', reason: 'duplicate', of: duplicate.of },
     ])

package/src/utils/build-criteria.ts

@@ -0,0 +1,11 @@
+import type { Criterion } from '@boxxy/model';
+import { brandSchemas } from '@boxxy/model';
+
+// The list replaces the item's list whole, so its criteria are numbered from `a1`.
+export function buildCriteria(acceptance: readonly { readonly text: string }[]): Criterion[] {
+  return acceptance.map((criterion, index) => ({
+    id: brandSchemas.criterionId.parse(`a${index + 1}`),
+    text: criterion.text,
+    evidence: [],
+  }));
+}

package/src/utils/collect-open-item-problems.ts

@@ -0,0 +1,13 @@
+import type { CloseOutContext, CloseOutProblem, OpenItem } from '@boxxy/model';
+
+// An open item files as an item of its kind, so a kind the rules lack is refused, once per kind.
+export function collectOpenItemProblems(
+  openItems: readonly OpenItem[],
+  ctx: CloseOutContext,
+): CloseOutProblem[] {
+  const kinds = new Set(openItems.map((openItem) => openItem.kind));
+
+  return [...kinds]
+    .filter((kind) => !ctx.world.kinds.has(kind))
+    .map((kind) => ({ kind: 'unknown-kind', itemKind: kind }));
+}

package/src/utils/collect-relation-problems.ts

@@ -0,0 +1,68 @@
+import type { CloseOutContext, CloseOutProblem, RelationDraft } from '@boxxy/model';
+import { getRelationEnds } from '@boxxy/model';
+
+// `implied` holds the relations a result names already, such as a duplicate's `duplicate-of`. They
+// count for the unknown items and the repeats only, so a duplicate of itself is one phase rule.
+export function collectRelationProblems(
+  relations: readonly RelationDraft[],
+  implied: readonly RelationDraft[],
+  ctx: CloseOutContext,
+): CloseOutProblem[] {
+  const named = [...implied, ...relations];
+
+  const others = named
+    .map((relation) => getRelationEnds(relation, ctx.item.id).other)
+    .filter((item) => item !== ctx.item.id);
+
+  return [
+    ...[...new Set(others)]
+      .filter((item) => !ctx.world.items.has(item))
+      .map((item) => ({ kind: 'unknown-item' as const, item })),
+    ...relations.flatMap((relation) => collectRefusals(relation, ctx)),
+    ...collectRepeats(named, ctx),
+  ];
+}
+
+// `target` of the problem is the other end, whichever way the draft points.
+function collectRefusals(relation: RelationDraft, ctx: CloseOutContext): CloseOutProblem[] {
+  const other = getRelationEnds(relation, ctx.item.id).other;
+
+  const refused = (reason: 'unknown-type' | 'self'): CloseOutProblem => ({
+    kind: 'refused-relation',
+    type: relation.type,
+    target: other,
+    reason,
+  });
+
+  return [
+    ...(ctx.world.relationTypes.has(relation.type) ? [] : [refused('unknown-type')]),
+    ...(other === ctx.item.id ? [refused('self')] : []),
+  ];
+}
+
+// Each relation is one row of the store, so a close-out names each relation of a type, source and
+// target once.
+function collectRepeats(named: readonly RelationDraft[], ctx: CloseOutContext): CloseOutProblem[] {
+  const keyed = named.map((relation) => {
+    const ends = getRelationEnds(relation, ctx.item.id);
+
+    return { relation, key: JSON.stringify([relation.type, ends.source, ends.target]) };
+  });
+
+  return keyed.flatMap((entry, index) =>
+    keyed.slice(0, index).some((earlier) => earlier.key === entry.key)
+      ? [
+          {
+            kind: 'phase-rule' as const,
+            message: `the close-out names ${formatRelationDraft(entry.relation)} more than once`,
+          },
+        ]
+      : [],
+  );
+}
+
+function formatRelationDraft(relation: RelationDraft): string {
+  return 'source' in relation
+    ? `${relation.type} from ${relation.source}`
+    : `${relation.type} ${relation.target}`;
+}

package/src/utils/find-latest-conclusion.ts

@@ -0,0 +1,9 @@
+import type { AttemptRow } from '@boxxy/model';
+import { designCloseOutSchema } from '@boxxy/model';
+import { findLatestCloseOut } from './find-latest-close-out.ts';
+
+export function findLatestConclusion(history: readonly AttemptRow[]): string | null {
+  const closeOut = findLatestCloseOut(history, 'design', designCloseOutSchema);
+
+  return closeOut?.result.kind === 'designed' ? (closeOut.result.conclusion ?? null) : null;
+}

package/src/utils/find-stopped-reason.ts

@@ -0,0 +1,19 @@
+import type { AttemptRow } from '@boxxy/model';
+import type { z } from 'zod';
+
+// Where the item's latest attempt of a phase that closed out stopped: what `pickReason` gives for
+// its close-out, or null. An attempt that ended with no close-out, such as at its timeout, sent
+// nothing to carry on from, so the one before it counts.
+export function findStoppedReason<Body>(
+  history: readonly AttemptRow[],
+  phase: string,
+  schema: z.ZodType<Body>,
+  pickReason: (body: Body) => string | null,
+): string | null {
+  const latest = history
+    .filter((row) => row.phase === phase)
+    .map((row) => schema.safeParse(row.closeOut))
+    .findLast((parsed) => parsed.success);
+
+  return latest?.data === undefined ? null : pickReason(latest.data);
+}