@agentsfleet/orly 0.10.13 → 0.10.14

package/dispatch/lifecycle.md

@@ -258,7 +258,12 @@ and every spec criterion runs against it; skip-pass is only for genuinely
 spec-less branches. A deliberately folded spec retains the exact branch header
 and adds `**Folded-into:** \`M178_001\`` naming the owning spec. Discovery
 validates that relation and gates the sole non-folded owner; two non-folded
-specs on one branch remain a hard error. Mechanical criteria: `spec.moved`
+specs on one branch remain a hard error. **The same relation holds in
+`active/`, from the moment the fold is decided.** A second workstream may sit
+beside an open stream while it names that stream through `Folded-into`, and the
+gates run against the owner — a fold is not a second stream, and it was decided
+when the scope was, not when the spec moved. Extra `active/` specs without the
+header are still the hard error they were: one stream per worktree. Mechanical criteria: `spec.moved`
 (`Status: DONE` ⇒ the spec sits under `done/` and was moved on this branch) · `spec.baseline`
 (`Test Baseline:` recorded) · `spec.ordering` (the branch's first commit
 carries the spec — no code before CHORE(open)) · `spec.deferrals` (a deferral

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsfleet/orly",
-  "version": "0.10.13",
+  "version": "0.10.14",
   "description": "Repository-scoped engineering harness: renders agent rules, materialises the gates that enforce them, and proves the PR boundary \u2014 for any coding agent.",
   "license": "MIT",
   "type": "module",

package/src/gates.ts

@@ -39,7 +39,7 @@ export type GateReport = {
 };
 
 export type Override = { criterion: string; reason: string };
-type ClosedSpec = {
+type SpecMetadata = {
   path: string;
   identifier: string | undefined;
   branch: string | undefined;
@@ -105,11 +105,34 @@ export function branchOverrides(root: string): Override[] {
   return overrides;
 }
 
+// One stream per worktree, and a fold is not a second stream. Extra specs in
+// active/ are allowed only when each names the one non-folded owner through
+// Folded-into — the same relation closedSpecPath enforces in done/. Without
+// this, folding a workstream into an open stream was impossible during the
+// work and legal only after the close, which is the wrong way round: the fold
+// is decided when the scope is, not when the spec moves.
 export function activeSpecPath(root: string): string | undefined {
-  const specs = specPathsUnder(root, ACTIVE_DIRECTORY);
+  const specs = specPathsUnder(root, ACTIVE_DIRECTORY).map(specMetadata)
+    .filter((spec): spec is SpecMetadata => spec !== undefined);
   if (specs.length === 0) return undefined;
-  if (specs.length > 1) throw new OrlyError(`more than one active spec — one stream per worktree:${NEWLINE}${specs.join(NEWLINE)}`);
-  return specs[0];
+  return owningSpec(specs, "active spec", "active specs").path;
+}
+
+// The fold relation, shared by both discovery paths: exactly one non-folded
+// owner, every other spec naming it, and no spec naming itself.
+function owningSpec(specs: SpecMetadata[], one: string, many: string): SpecMetadata {
+  const owners = specs.filter((spec) => spec.foldedInto === undefined);
+  if (owners.length === 0) throw new OrlyError(`every ${one} is folded — one owning stream is required:${NEWLINE}${specs.map((spec) => spec.path).join(NEWLINE)}`);
+  if (owners.length > 1) throw new OrlyError(`more than one ${one} — one stream per worktree:${NEWLINE}${owners.map((spec) => spec.path).join(NEWLINE)}`);
+  const owner = owners[0];
+  if (!owner) throw new OrlyError(`${one} ownership could not be resolved`);
+  const folded = specs.filter((spec) => spec.foldedInto !== undefined);
+  if (folded.length > 0 && !owner.identifier) throw new OrlyError(`the owning ${one} has no milestone and workstream identifier: ${owner.path}`);
+  const selfFolds = folded.filter((spec) => spec.identifier === spec.foldedInto);
+  if (selfFolds.length > 0) throw new OrlyError(`folded ${many} cannot fold into themselves:${NEWLINE}${selfFolds.map((spec) => spec.path).join(NEWLINE)}`);
+  const invalidFolds = folded.filter((spec) => spec.foldedInto !== owner.identifier);
+  if (invalidFolds.length > 0) throw new OrlyError(`folded ${many} must name their owner ${owner.identifier}:${NEWLINE}${invalidFolds.map((spec) => spec.path).join(NEWLINE)}`);
+  return owner;
 }
 
 // Closed-spec follow-through: CHORE(close) moves the spec to done/, and the
@@ -120,21 +143,10 @@ export function closedSpecPath(root: string): string | undefined {
   const branch = gitOutput(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!branch || DEFAULT_BRANCHES.includes(branch)) return undefined;
   const specs = specPathsUnder(root, DONE_DIRECTORY)
-    .map(closedSpec)
-    .filter((spec): spec is ClosedSpec => spec !== undefined && spec.branch === branch);
+    .map(specMetadata)
+    .filter((spec): spec is SpecMetadata => spec !== undefined && spec.branch === branch);
   if (specs.length === 0) return undefined;
-  const owners = specs.filter((spec) => spec.foldedInto === undefined);
-  if (owners.length === 0) throw new OrlyError(`every done/ spec naming branch ${branch} is folded — one owning stream is required:${NEWLINE}${specs.map((spec) => spec.path).join(NEWLINE)}`);
-  if (owners.length > 1) throw new OrlyError(`more than one done/ spec names branch ${branch} — one stream per worktree:${NEWLINE}${owners.map((spec) => spec.path).join(NEWLINE)}`);
-  const owner = owners[0];
-  if (!owner) throw new OrlyError(`done/ spec ownership could not be resolved for branch ${branch}`);
-  const folded = specs.filter((spec) => spec.foldedInto !== undefined);
-  if (folded.length > 0 && !owner.identifier) throw new OrlyError(`the owning done/ spec for branch ${branch} has no milestone and workstream identifier: ${owner.path}`);
-  const selfFolds = folded.filter((spec) => spec.identifier === spec.foldedInto);
-  if (selfFolds.length > 0) throw new OrlyError(`folded done/ specs naming branch ${branch} cannot fold into themselves:${NEWLINE}${selfFolds.map((spec) => spec.path).join(NEWLINE)}`);
-  const invalidFolds = folded.filter((spec) => spec.foldedInto !== owner.identifier);
-  if (invalidFolds.length > 0) throw new OrlyError(`folded done/ specs naming branch ${branch} must name their owner ${owner.identifier}:${NEWLINE}${invalidFolds.map((spec) => spec.path).join(NEWLINE)}`);
-  return owner.path;
+  return owningSpec(specs, `done/ spec naming branch ${branch}`, `done/ specs naming branch ${branch}`).path;
 }
 
 // An in-flight (active/) spec wins; otherwise the branch's closed spec gates.
@@ -145,9 +157,9 @@ export function specPathFor(root: string): { path: string; closed: boolean } | u
   return closed ? { path: closed, closed: true } : undefined;
 }
 
-function closedSpec(path: string): ClosedSpec | undefined {
+function specMetadata(path: string): SpecMetadata | undefined {
   try {
-    const metadata: ClosedSpec = {
+    const metadata: SpecMetadata = {
       path,
       identifier: basename(path).match(SPEC_IDENTIFIER_PATTERN)?.[1],
       branch: undefined,

package/src/gates_spec.test.ts

@@ -38,6 +38,66 @@ describe("spec discovery", () => {
 
     expect(() => activeSpecPath(project)).toThrow("one stream per worktree");
   });
+
+  test("a folded active spec yields ownership to the spec it names", async () => {
+    const project = newSpecRepository();
+    mkdirSync(join(project, "docs/v2/active"), { recursive: true });
+    await Bun.write(
+      join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M99_001`"]),
+    );
+
+    expect(activeSpecPath(project)).toEndWith("M99_001_P2_CLI_FIXTURE.md");
+  });
+
+  test("a folded active spec must name the exact owner", async () => {
+    const project = newSpecRepository();
+    mkdirSync(join(project, "docs/v2/active"), { recursive: true });
+    await Bun.write(
+      join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M404_001`"]),
+    );
+
+    expect(() => activeSpecPath(project)).toThrow("must name their owner M99_001");
+  });
+
+  test("a folded active spec cannot name itself", async () => {
+    const project = newSpecRepository();
+    mkdirSync(join(project, "docs/v2/active"), { recursive: true });
+    await Bun.write(
+      join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M100_001`"]),
+    );
+
+    expect(() => activeSpecPath(project)).toThrow("cannot fold into themselves");
+  });
+
+  test("every active spec folded leaves no owning stream", async () => {
+    const project = newRepository();
+    mkdirSync(join(project, "docs/v2/active"), { recursive: true });
+    await Bun.write(
+      join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M99_001`"]),
+    );
+    await Bun.write(
+      join(project, "docs/v2/active/M101_001_P2_CLI_ALSO_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M99_001`"]),
+    );
+
+    expect(() => activeSpecPath(project)).toThrow("one owning stream is required");
+  });
+
+  test("a folded active spec still gates through its owner", async () => {
+    const project = newSpecRepository();
+    const model = await modelFor(project);
+    mkdirSync(join(project, "docs/v2/active"), { recursive: true });
+    await Bun.write(
+      join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
+      specFixture(undefined, undefined, ["**Folded-into:** `M99_001`"]),
+    );
+
+    expect(runGate(model, project, "work").results.find((result) => result.name === "cmd.conform")?.ok).toBeTrue();
+  });
 });
 
 describe("closed-spec follow-through", () => {