app/demo/greenfield.ts

// Driving real, forward-going development through the actual zz
// protocol -- scenario 1 of the greenfield test (me as the developer).
// Every increment: propose a Lane, claim it, submit a changeset (real
// file content as the ask's payload, committed via engine/changeset.ts
// with no working-tree file ever written), then merge the real Ladder
// content describing what just landed. No shortcuts around the
// protocol -- this is the same claim/submit/merge shape ladder-build.ts
// and ladder-replay-commits.ts already use, just authoring new content
// instead of describing history.
import { ensureCloned, resolveRepo } from "../cli/lib/repo.js";
import { registerLocalBackendFactory } from "../engine/backend.js";
import { createLocalBackend } from "../engine/localBackend.js";
import { ask, answer, mergeLaneLadder, proposeLane } from "../engine/lane.js";

registerLocalBackendFactory(createLocalBackend);
import { commitChangeset, type ChangesetFile } from "../engine/changeset.js";
import { readAnchor, writeLadder } from "../engine/ladderNotes.js";
import { readLane } from "../engine/store.js";
import type { Rung } from "../engine/ladder.js";
import { REPO_RUNG_PATH } from "../engine/ladder.js";
import type { LaneRef } from "../engine/types.js";

export const AUTHOR = { name: "zz-dev", email: "zz-dev@local" };
const COORDINATOR = "zz-coordinator";

export async function ensureRepoLane(slug: string) {
  const repo = resolveRepo(slug);
  ensureCloned(repo);
  let repoLane = readLane(repo.stateDir, REPO_RUNG_PATH);
  if (!repoLane) {
    repoLane = await proposeLane(repo.slug, { id: REPO_RUNG_PATH, repo: slug, name: slug, objective: `the ${slug} repository`, scope: ["**"], proposedBy: COORDINATOR, coordinators: [COORDINATOR] });
    const review = await ask(repo.slug, repoLane.id, { kind: "review_request", from: COORDINATOR });
    await answer(repo.slug, repoLane.id, review, { from: COORDINATOR, action: "grant" });
  }
  return { repo, repoLane };
}

export interface IncrementInput {
  laneId: string;
  name: string;
  objective: string;
  scope: string[];
  files: ChangesetFile[];
  message: string;
  /** Top-level rungs to land in the Ladder, built from the real commit oid (sources need the real sha). */
  buildLadderRungs: (commitOid: string) => Rung[];
  /** Overrides the default origin (this repo's own _repo Lane) -- set this to a Lane in a different repo when the work exists because of that upstream Lane, a real cross-repo dependency, not just this repo's own history. */
  origin?: LaneRef;
}

export async function submitIncrement(slug: string, input: IncrementInput): Promise<{ commitOid: string }> {
  const { repo, repoLane } = await ensureRepoLane(slug);
  const origin: LaneRef = input.origin ?? { repo: slug, lane: repoLane.id };

  const lane = await proposeLane(repo.slug, {
    id: input.laneId,
    repo: slug,
    name: input.name,
    objective: input.objective,
    scope: input.scope,
    origin,
    proposedBy: AUTHOR.name,
    coordinators: [AUTHOR.name],
  });

  const claim = await ask(repo.slug, lane.id, { kind: "claim_request", from: AUTHOR.name });
  await answer(repo.slug, lane.id, claim, { from: AUTHOR.name, action: "grant" });

  const submit = await ask(repo.slug, lane.id, { kind: "submit_changeset", from: AUTHOR.name, payload: { files: input.files, message: input.message } });
  const commitOid = await commitChangeset(repo.repoDir, { files: input.files, message: input.message, author: AUTHOR });
  await answer(repo.slug, lane.id, submit, { from: AUTHOR.name, action: "grant", payload: { commit: commitOid } });

  const rungs = input.buildLadderRungs(commitOid);
  const mergeRequest = await ask(repo.slug, lane.id, { kind: "merge_request", from: AUTHOR.name, payload: { ladder: rungs.map((r) => ({ path: r.path, kind: r.kind })) } });

  // _repo's own note doesn't exist until after the repo's first real
  // commit (it anchors to the root tree); writing it for the first
  // time means wrapping the new rungs as its children directly, the
  // same bootstrap ladder-build.ts does, rather than calling
  // appendRepoChildren on a note that doesn't exist yet.
  const repoAnchor = await readAnchor(repo.repoDir, repo.stateDir, REPO_RUNG_PATH);
  if (!repoAnchor) {
    const root: Rung = { path: REPO_RUNG_PATH, kind: "repo", summary: `${slug}, built from scratch through the zz protocol.`, sources: [], children: rungs };
    await writeLadder(repo.repoDir, repo.stateDir, root);
  } else {
    await mergeLaneLadder(repo.slug, rungs);
  }
  await answer(repo.slug, lane.id, mergeRequest, { from: AUTHOR.name, action: "grant" });

  return { commitOid };
}