#[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// Edit a project board's title, description, state, or archive

    Edit {

        #[arg(help = "Project number")]

        number: u64,

        #[arg(long, help = "New project title")]

        title: Option<String>,

        #[arg(long, help = "Markdown project description")]

        description: Option<String>,

        #[arg(long, help = "New project state: open or closed")]

        state: Option<String>,

        #[arg(long, help = "Move the board out of the working set")]

        archive: bool,

        #[arg(long, help = "Return the board to the working set")]

        unarchive: bool,

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// Permanently delete a project board (archive it first with project edit --archive)

    Delete {

        #[arg(help = "Project number")]

        number: u64,

        #[arg(long, help = "Confirm permanent project deletion")]

        yes: bool,

        #[arg(short = 'R', long, help = "Repository as owner/repo")]

        repo: Option<String>,

    },

    /// List the fields of a project board

    Fields {

        #[arg(help = "Project number")]

                )],

            );

        }

        ProjectAction::Edit {

            number,

            title,

            description,

            state,

            archive,

            unarchive,

            repo,

        } => {

            if archive && unarchive {

                fail("Pass either --archive or --unarchive, not both.");

            }

            if let Some(value) = state.as_deref() {

                if value != "open" && value != "closed" {

                    fail("--state accepts open or closed.");

                }

            }

            let archived = if archive {

                Some(true)

            } else if unarchive {

                Some(false)

            } else {

                None

            };

            if title.is_none() && description.is_none() && state.is_none() && archived.is_none() {

                fail("Pass --title, --description, --state, --archive, or --unarchive.");

            }

            let target = target_or_fail(repo);

            let project = or_fail(

                tracker

                    .edit_project(

                        &target,

                        number,

                        title.as_deref(),

                        description.as_deref(),

                        state.as_deref(),

                        archived,

                    )

                    .await,

            );

            emit(

                json,

                &project,

                &[format!(

                    "Updated project #{} {}",

                    number_or_question(&project, "number"),

                    field(&project, "title")

                )],

            );

        }

        ProjectAction::Delete { number, yes, repo } => {

            if !yes {

                fail("Project deletion requires --yes confirmation.");

            }

            let target = target_or_fail(repo);

            or_fail(tracker.delete_project(&target, number).await);

            emit(

                json,

                &serde_json::json!({ "number": number, "deleted": true }),

                &[format!("Deleted project #{number}.")],

            );

        }

        ProjectAction::Fields { number, repo } => {

            let target = target_or_fail(repo);

            let value = or_fail(tracker.project_fields(&target, number).await);

    ) -> Result<Repository, AuthError> {

        let name = validate_repository_name(name)?;

        let owner = owner.map(validate_owner).transpose()?;

        // `OWNER/NAME` says an owner was named, not that the owner is an

        // organization. Sending a named owner to the organization route on the

        // strength of a slash is what made `repo create AtlantisPleb/thing` ask

        // the org route to create under a person. The owner travels in the body

        // and the server resolves which kind it is.

        let mut body = serde_json::json!({

            "name": name,

            "private": private,

            "default_branch": default_branch,

        });

        if let Some(owner) = &owner {

            body["owner"] = serde_json::Value::String(owner.clone());

        }

        if let Some(description) = description {

            body["description"] = serde_json::Value::String(description.to_string());

        }

        let path = match &owner {

            None => "/api/v1/user/repos".to_string(),

            Some(owner) => format!("/api/v1/orgs/{}/repos", urlencode(owner)),

        };

        let value = self

            .request(

                "create the repository",

                reqwest::Method::POST,

                &path,

                "/api/v1/repos",

                Some(body),

                Some(&idempotency_key()),

                &[200, 201, 202],

        .await

    }

    /// Edits a board's title, description, state, or archive standing.

    ///

    /// The payload is built from whichever fields the caller set. The API

    /// refuses an empty edit, so the command validates before it gets here.

    pub async fn edit_project(

        &self,

        target: &RepoTarget,

        number: u64,

        title: Option<&str>,

        description: Option<&str>,

        state: Option<&str>,

        archived: Option<bool>,

    ) -> Result<Value, ApiError> {

        let mut payload = json!({});

        if let Some(text) = title {

            payload["title"] = json!(text);

        }

        if let Some(text) = description {

            payload["description"] = json!(text);

        }

        if let Some(text) = state {

            payload["state"] = json!(text);

        }

        if let Some(flag) = archived {

            payload["archived"] = json!(flag);

        }

        self.request(

            "edit a project",

            "PATCH",

            &Self::project_path(target, number),

            Some(payload),

            &[200],

        )

        .await

    }

    /// Deletes a board. The API refuses one that is not archived, so archiving

    /// is the deliberate step that stands in for a prompt an API caller has no

    /// way to see.

    pub async fn delete_project(&self, target: &RepoTarget, number: u64) -> Result<Value, ApiError> {

        self.request(

            "delete a project",

            "DELETE",

            &Self::project_path(target, number),

            None,

            &[200, 204],

        )

        .await

    }

    pub async fn project_fields(&self, target: &RepoTarget, number: u64) -> Result<Value, ApiError> {

        self.request(

            "list project fields",

//! What `oa project edit`, `oa project delete`, and `oa repo create` put on

//! the wire, asserted by running the binary against a server this test owns.

//!

//! Asserting that a subcommand parses would pass against a binary that parsed

//! it and sent nothing, so every test here reads the request the stub actually

//! received: method, path, and body. The delete test lists the board before

//! and after, because a delete that answers `204` without removing anything

//! would otherwise look identical to one that worked.

use std::io::{BufRead, BufReader, Read, Write};

use std::net::{TcpListener, TcpStream};

use std::process::Command;

use std::sync::mpsc;

use std::thread;

/// One request the stub received.

#[derive(Debug, Clone)]

struct Hit {

    method: String,

    path: String,

    body: String,

}

impl Hit {

    fn route(&self) -> String {

        format!("{} {}", self.method, self.path)

    }

    fn json(&self) -> serde_json::Value {

        serde_json::from_str(&self.body).unwrap_or(serde_json::Value::Null)

    }

}

/// A server that answers from a script and records every request.

///

/// The script is a list of `(status, body)` answered in order, with the last

/// entry repeating. Ordering matters here: the board list has to answer

/// differently before and after the delete, which a single canned body cannot

/// do.

struct StubServer {

    port: u16,

    hits: mpsc::Receiver<Hit>,

}

impl StubServer {

    fn start(script: Vec<(u16, String)>) -> Self {

        let listener = TcpListener::bind("127.0.0.1:0").expect("bind a port");

        let port = listener.local_addr().expect("read the port").port();

        let (tx, hits) = mpsc::channel();

        thread::spawn(move || {

            for (answered, stream) in listener.incoming().enumerate() {

                let Ok(stream) = stream else { break };

                let index = answered.min(script.len().saturating_sub(1));

                let (code, body) = script[index].clone();

                serve_one(stream, code, &body, tx.clone());

            }

        });

        Self { port, hits }

    }

    fn origin(&self) -> String {

        format!("http://127.0.0.1:{}", self.port)

    }

    fn hits(&self) -> Vec<Hit> {

        self.hits.try_iter().collect()

    }

}

fn serve_one(mut stream: TcpStream, code: u16, body: &str, hits: mpsc::Sender<Hit>) {

    let mut reader = BufReader::new(stream.try_clone().expect("clone the stream"));

    let mut request_line = String::new();

    if reader.read_line(&mut request_line).is_err() {

        return;

    }

    let mut parts = request_line.split_whitespace();

    let method = parts.next().unwrap_or("").to_string();

    let path = parts.next().unwrap_or("").to_string();

    let mut length = 0usize;

    loop {

        let mut header = String::new();

        if reader.read_line(&mut header).unwrap_or(0) == 0 {

            break;

        }

        if header.trim().is_empty() {

            break;

        }

        if let Some(value) = header.to_lowercase().strip_prefix("content-length:") {

            length = value.trim().parse().unwrap_or(0);

        }

    }

    let mut payload = vec![0u8; length];

    if length > 0 && reader.read_exact(&mut payload).is_err() {

        return;

    }

    let _ = hits.send(Hit {

        method,

        path,

        body: String::from_utf8_lossy(&payload).into_owned(),

    });

    let reason = if code == 204 { "No Content" } else { "OK" };

    let response = format!(

        "HTTP/1.1 {code} {reason}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",

        body.len(),

        body

    );

    let _ = stream.write_all(response.as_bytes());

    let _ = stream.flush();

}

struct Run {

    stdout: String,

    stderr: String,

    status: Option<i32>,

}

fn oa(origin: &str, args: &[&str]) -> Run {

    let mut full = vec!["--api-url", origin];

    full.extend(args.iter().copied());

    let result = Command::new(env!("CARGO_BIN_EXE_oa"))

        .args(&full)

        .env("NO_COLOR", "")

        // `repo create` refuses without a credential rather than sending an

        // unauthenticated request, so the stub needs one to be reached at all.

        .env("OPENAGENTS_TOKEN", "oa_pat_stub")

        .output()

        .expect("run oa");

    Run {

        stdout: String::from_utf8_lossy(&result.stdout).into_owned(),

        stderr: String::from_utf8_lossy(&result.stderr).into_owned(),

        status: result.status.code(),

    }

}

fn board_list(archived: bool) -> String {

    if archived {

        r#"{"projects":[{"number":5,"title":"Scratch","state":"open","archived":true}]}"#

            .to_string()

    } else {

        r#"{"projects":[]}"#.to_string()

    }

}

const ARCHIVED_BOARD: &str = r#"{"number":5,"title":"Scratch","state":"open","archived":true,"archived_at":"2026-08-26T00:00:00Z"}"#;

/// The board is listed, archived, deleted, and then gone from the list.

///

/// The two listings are the proof. The `DELETE` on its own only shows that the

/// CLI asked; the second listing shows the board is no longer there to ask

/// about.

#[test]

fn a_board_is_archived_deleted_and_absent_from_the_list_afterwards() {

    let server = StubServer::start(vec![

        (200, board_list(true)),

        (200, ARCHIVED_BOARD.to_string()),

        (204, String::new()),

        (200, board_list(false)),

    ]);

    let origin = server.origin();

    let before = oa(

        &origin,

        &[

            "--json",

            "project",

            "list",

            "--archived",

            "-R",

            "owner/repo",

        ],

    );

    assert_eq!(before.status, Some(0), "stderr: {}", before.stderr);

    assert!(

        before.stdout.contains("Scratch"),

        "the board was not listed before the delete: {}",

        before.stdout

    );

    let archive = oa(

        &origin,

        &["project", "edit", "5", "--archive", "-R", "owner/repo"],

    );

    assert_eq!(archive.status, Some(0), "stderr: {}", archive.stderr);

    let removed = oa(

        &origin,

        &["project", "delete", "5", "--yes", "-R", "owner/repo"],

    );

    assert_eq!(removed.status, Some(0), "stderr: {}", removed.stderr);

    assert!(

        removed.stdout.contains("Deleted project #5"),

        "unexpected output: {}",

        removed.stdout

    );

    let after = oa(

        &origin,

        &[

            "--json",

            "project",

            "list",

            "--archived",

            "-R",

            "owner/repo",

        ],

    );

    assert_eq!(after.status, Some(0), "stderr: {}", after.stderr);

    assert!(

        !after.stdout.contains("Scratch"),

        "the board was still listed after the delete: {}",

        after.stdout

    );

    let hits = server.hits();

    assert_eq!(

        hits.iter().map(Hit::route).collect::<Vec<_>>(),

        vec![

            "GET /api/v1/repos/owner/repo/projectsV2?archived=true".to_string(),

            "PATCH /api/v1/repos/owner/repo/projectsV2/5".to_string(),

            "DELETE /api/v1/repos/owner/repo/projectsV2/5".to_string(),

            "GET /api/v1/repos/owner/repo/projectsV2?archived=true".to_string(),

        ]

    );

    assert_eq!(hits[1].json(), serde_json::json!({ "archived": true }));

}

/// Deleting without `--yes` refuses before anything is sent.

#[test]

fn deleting_a_board_without_confirmation_sends_nothing() {

    let server = StubServer::start(vec![(204, String::new())]);

    let origin = server.origin();

    let run = oa(&origin, &["project", "delete", "5", "-R", "owner/repo"]);

    assert_ne!(run.status, Some(0));

    assert!(run.stderr.contains("--yes"), "stderr: {}", run.stderr);

    assert!(

        server.hits().is_empty(),

        "an unconfirmed delete reached the server"

    );

}

/// An edit that names no field refuses before anything is sent.

#[test]

fn editing_a_board_with_no_field_sends_nothing() {

    let server = StubServer::start(vec![(200, ARCHIVED_BOARD.to_string())]);

    let origin = server.origin();

    let run = oa(&origin, &["project", "edit", "5", "-R", "owner/repo"]);

    assert_ne!(run.status, Some(0));

    assert!(run.stderr.contains("--title"), "stderr: {}", run.stderr);

    assert!(server.hits().is_empty(), "an empty edit reached the server");

}

/// Title, description, and state travel together in one PATCH.

#[test]

fn an_edit_sends_every_field_the_caller_named() {

    let server = StubServer::start(vec![(200, ARCHIVED_BOARD.to_string())]);

    let origin = server.origin();

    let run = oa(

        &origin,

        &[

            "project",

            "edit",

            "5",

            "--title",

            "Renamed",

            "--description",

            "Why it exists",

            "--state",

            "closed",

            "-R",

            "owner/repo",

        ],

    );

    assert_eq!(run.status, Some(0), "stderr: {}", run.stderr);

    let hits = server.hits();

    assert_eq!(

        hits[0].route(),

        "PATCH /api/v1/repos/owner/repo/projectsV2/5"

    );

    assert_eq!(

        hits[0].json(),

        serde_json::json!({

            "title": "Renamed",

            "description": "Why it exists",

            "state": "closed"

        })

    );

}

fn ready_repository(full_name: &str) -> String {

    let (owner, name) = full_name.split_once('/').expect("owner/name");

    format!(

        r#"{{"id":"11111111-1111-1111-1111-111111111111","name":"{name}","full_name":"{full_name}","owner":{{"id":1,"login":"{owner}","type":"User"}},"private":true,"visibility":"private","description":null,"default_branch":"main","lifecycle_state":"ready","provision_error_code":null,"clone_url":"http://example.test/{full_name}.git","html_url":"http://example.test/{full_name}","permissions":{{"admin":true,"push":true,"pull":true}},"created_at":"2026-08-26T00:00:00Z","updated_at":"2026-08-26T00:00:00Z"}}"#

    )

}

/// A named owner goes to the owner-neutral route with the owner in the body.

///

/// The bug this replaces read a slash as proof the owner is an organization

/// and posted to `/api/v1/orgs/{owner}/repos`, which is wrong whenever the

/// owner is a person. Both owners below take the same route now.

#[test]

fn a_named_owner_is_sent_to_the_server_rather_than_routed_on_a_guess() {

    for owner in ["AtlantisPleb", "OpenAgentsInc"] {

        let full_name = format!("{owner}/thing");

        let server = StubServer::start(vec![(201, ready_repository(&full_name))]);

        let origin = server.origin();

        let run = oa(&origin, &["repo", "create", &full_name]);

        assert_eq!(run.status, Some(0), "stderr: {}", run.stderr);

        let hits = server.hits();

        assert_eq!(hits.len(), 1, "unexpected requests: {hits:?}");

        assert_eq!(hits[0].route(), "POST /api/v1/repos");

        assert!(

            !hits[0].path.contains("/orgs/"),

            "a named owner still went to the organization route"

        );

        assert_eq!(hits[0].json()["owner"], serde_json::json!(owner));

        assert_eq!(hits[0].json()["name"], serde_json::json!("thing"));

    }

}

/// A bare name carries no owner, so the server uses the caller's namespace.

#[test]

fn a_bare_name_carries_no_owner() {

    let server = StubServer::start(vec![(201, ready_repository("octavia/thing"))]);

    let origin = server.origin();

    let run = oa(&origin, &["repo", "create", "thing"]);

    assert_eq!(run.status, Some(0), "stderr: {}", run.stderr);

    let hits = server.hits();

    assert_eq!(hits[0].route(), "POST /api/v1/repos");

    assert_eq!(hits[0].json().get("owner"), None);

}

sign in with GitHub, and organization creation requires an active GitHub

membership that can create repositories.

`repo create OWNER/NAME` works for either kind of owner. The owner travels to

the server, which resolves whether it is a person or an organization; the CLI

does not decide that from the shape of the argument. `repo create NAME` uses

your own namespace.

`repo create --source <directory>` verifies the Git worktree and adds the

server-provided clone URL as a remote. It refuses to overwrite an unrelated

remote and prints the next `git push` command. The first release never pushes

openagents project list --archived

openagents project view 2

openagents project create --title "Issues and Projects delivery"

openagents project edit 2 --title "Renamed" --description "Why it exists"

openagents project edit 2 --state closed

openagents project edit 2 --archive

openagents project delete 2 --yes

openagents project fields 2

openagents project items 2

openagents project item-add 2 --issue 129

Projects are repository-scoped, so every project command takes the same

`-R, --repo` and remote inference the issue commands take.

A board deletes in two steps. `project edit --archive` takes it out of the

working set, and `project delete --yes` removes it and everything on it. The

API refuses to delete a board that is not archived, so archiving is the

deliberate step that stands in for the confirmation an API caller never sees.

Deleting a board leaves the issues it pointed at alone: an item is a reference

to canonical work, not the work itself.

## Deploy the fleet (operators)

The `deploy` commands drive the operator-only fleet promotion API

  "idempotency": {

    "header": "Idempotency-Key",

    "required_for": [

      "POST /api/v1/repos",

      "POST /api/v1/user/repos",

      "POST /api/v1/orgs/{org}/repos",

      "POST /api/v1/user/repos/imports",

  },

  "endpoints": {

    "get_authenticated_user": "GET /api/v1/user",

    "create_repository": "POST /api/v1/repos",

    "create_user_repository": "POST /api/v1/user/repos",

    "create_organization_repository": "POST /api/v1/orgs/{org}/repos",

    "import_user_repository": "POST /api/v1/user/repos/imports",

export const REPOSITORY_CONTRACT_NAME = "openagents.repositories.v1";

export const REPOSITORY_CONTRACT_VERSION = 1;

export const REPOSITORY_CONTRACT_SHA256 =

  "96a71ee0a3d19eb77ffa0721cc76876e1e514bb821368c469f0a6d91f21c3870";

  "1e65a325a028a7cd71d239f932a20f84981781f728cd17c5450fd318bc4a592b";

export const AuthenticatedNamespace = Schema.Struct({

  id: Schema.Union([Schema.Number, Schema.String]),

    }),

).pipe(Command.withDescription("Create a project board"));

const projectEditTitleFlag = Flag.string("title").pipe(

  Flag.optional,

  Flag.withDescription("New project title"),

);

const projectStateFlag = Flag.string("state").pipe(

  Flag.optional,

  Flag.withDescription("New project state: open or closed"),

);

const projectArchiveFlag = Flag.boolean("archive").pipe(

  Flag.withDescription("Move the board out of the working set"),

);

const projectUnarchiveFlag = Flag.boolean("unarchive").pipe(

  Flag.withDescription("Return the board to the working set"),

);

const projectEditCommand = Command.make(

  "edit",

  {

    number: projectNumberArgument,

    repo: repositoryOverrideFlag,

    title: projectEditTitleFlag,

    description: projectDescriptionFlag,

    state: projectStateFlag,

    archive: projectArchiveFlag,

    unarchive: projectUnarchiveFlag,

  },

  ({ archive, description, number, repo, state, title, unarchive }) =>

    Effect.gen(function* () {

      const projectNumber = yield* parseTrackerNumber("A project number", number);

      if (archive && unarchive) {

        return yield* new InputError({

          message: "Pass either --archive or --unarchive, not both.",

        });

      }

      const stateValue = Option.isNone(state) ? undefined : state.value;

      if (stateValue !== undefined && stateValue !== "open" && stateValue !== "closed") {

        return yield* new InputError({ message: "--state accepts open or closed." });

      }

      const archived = archive ? true : unarchive ? false : undefined;

      const titleValue = Option.isNone(title) ? undefined : title.value;

      const descriptionValue = Option.isNone(description) ? undefined : description.value;

      if (

        titleValue === undefined &&

        descriptionValue === undefined &&

        stateValue === undefined &&

        archived === undefined

      ) {

        return yield* new InputError({

          message: "Pass --title, --description, --state, --archive, or --unarchive.",

        });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const projects = yield* ProjectClient;

      const output = yield* Output;

      const value = yield* projects.edit({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

        number: projectNumber,

        ...(titleValue === undefined ? {} : { title: titleValue }),

        ...(descriptionValue === undefined ? {} : { description: descriptionValue }),

        ...(stateValue === undefined ? {} : { state: stateValue }),

        ...(archived === undefined ? {} : { archived }),

      });

      const project = record(value);

      yield* output.write(

        {

          value,

          human: [

            `Updated project #${String(project["number"] ?? "?")} ${String(project["title"] ?? "")}`,

          ],

        },

        outputMode(flags.json),

      );

    }),

).pipe(Command.withDescription("Edit a project board's title, description, state, or archive"));

const projectDeleteYesFlag = Flag.boolean("yes").pipe(

  Flag.withDescription("Confirm permanent project deletion"),

);

const projectDeleteCommand = Command.make(

  "delete",

  { number: projectNumberArgument, repo: repositoryOverrideFlag, yes: projectDeleteYesFlag },

  ({ number, repo, yes }) =>

    Effect.gen(function* () {

      const projectNumber = yield* parseTrackerNumber("A project number", number);

      if (!yes) {

        return yield* new InputError({

          message: "Project deletion requires --yes confirmation.",

        });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const target = yield* resolveTrackerTarget(repo, session.endpoint.origin);

      const projects = yield* ProjectClient;

      const output = yield* Output;

      yield* projects.delete({

        origin: session.endpoint.origin,

        token: session.token,

        ...target,

        number: projectNumber,

      });

      yield* output.write(

        {

          value: { number: projectNumber, deleted: true },

          human: [`Deleted project #${projectNumber}.`],

        },

        outputMode(flags.json),

      );

    }),

).pipe(

  Command.withDescription(

    "Permanently delete a project board (archive it first with project edit --archive)",

  ),

);

const projectItemRow = (item: Record<string, unknown>): string => {

  const issue = record(item["issue"]);

  const values = record(item["values"]);

    projectListCommand,

    projectViewCommand,

    projectCreateCommand,

    projectEditCommand,

    projectDeleteCommand,

    projectFieldsCommand,

    projectItemsCommand,

    projectItemAddCommand,

  readonly description?: string;

}

export interface ProjectEditInput extends ProjectNumberInput {

  readonly title?: string;

  readonly description?: string;

  readonly state?: string;

  readonly archived?: boolean;

}

export interface ProjectItemInput extends ProjectNumberInput {

  readonly itemId: string;

}

  readonly list: (input: ProjectListInput) => Effect.Effect<unknown, CliError>;

  readonly view: (input: ProjectNumberInput) => Effect.Effect<unknown, CliError>;

  readonly create: (input: ProjectCreateInput) => Effect.Effect<unknown, CliError>;

  readonly edit: (input: ProjectEditInput) => Effect.Effect<unknown, CliError>;

  readonly delete: (input: ProjectNumberInput) => Effect.Effect<unknown, CliError>;

  readonly fields: (input: ProjectNumberInput) => Effect.Effect<unknown, CliError>;

  readonly items: (input: ProjectNumberInput) => Effect.Effect<unknown, CliError>;

  readonly addItem: (

          acceptedStatuses: [201],

        }),

      edit: (input) =>

        request("edit a project", {

          origin: input.origin,

          token: input.token,

          method: "PATCH",

          path: projectPath(input),

          body: {

            ...(input.title === undefined ? {} : { title: input.title }),

            ...(input.description === undefined ? {} : { description: input.description }),

            ...(input.state === undefined ? {} : { state: input.state }),

            ...(input.archived === undefined ? {} : { archived: input.archived }),

          },

          acceptedStatuses: [200],

        }),

      // The API refuses a board that is not archived, so the two-step is the

      // server's policy rather than a client convention. See `project archive`.

      delete: (input) =>

        request("delete a project", {

          origin: input.origin,

          token: input.token,

          method: "DELETE",

          path: projectPath(input),

          acceptedStatuses: [200, 204],

        }),

      fields: (input) =>

        request("list project fields", {

          origin: input.origin,

      const name = yield* validateRepositoryName(input.name);

      const owner = input.owner === undefined ? undefined : yield* validateOwner(input.owner);

      const idempotencyKey = input.idempotencyKey ?? globalThis.crypto.randomUUID();

      // `OWNER/NAME` says an owner was named, not that the owner is an

      // organization. Sending a named owner to the organization route on the

      // strength of a slash is what made `repo create AtlantisPleb/thing` ask

      // the org route to create under a person. The owner travels in the body

      // and the server resolves which kind it is.

      const body = {

        name,

        private: input.private,

        ...(owner === undefined ? {} : { owner }),

        ...(input.description === undefined ? {} : { description: input.description }),

        ...(input.defaultBranch === undefined ? {} : { default_branch: input.defaultBranch }),

      };

      const path =

        owner === undefined

          ? `${API_VERSION_PATH}/user/repos`

          : `${API_VERSION_PATH}/orgs/${encoded(owner)}/repos`;

      const value = yield* retryMutation(

        request("create repository", {

          ...input,

          method: "POST",

          path,

          path: `${API_VERSION_PATH}/repos`,

          body,

          headers: { "idempotency-key": idempotencyKey },

          acceptedStatuses: [201, 202],

    expect(requests[0]?.path).toBe("/api/v1/repos/octavia/project/projectsV2/2/items");

    expect(requests[0]?.body).toEqual({ issue_number: 155 });

  });

  it("archives and then deletes a board, and the list stops carrying it", async () => {

    // Listing on either side of the delete is what makes this a proof: the

    // board is present before and absent after, so a delete that answered 204

    // without removing anything would still fail here.

    const requests: Array<ApiRequest> = [];

    const board = { number: 5, title: "Scratch", state: "open", archived: false };

    let deleted = false;

    const { run, written } = harness((input) =>

      Effect.sync(() => {

        requests.push(input);

        if (input.method === "DELETE") {

          deleted = true;

          return { status: 204, body: {} };

        }

        if (input.method === "PATCH") return { status: 200, body: { ...board, archived: true } };

        return { status: 200, body: { projects: deleted ? [] : [board] } };

      }),

    );

    await run(["--json", "project", "list", "--archived"]);

    await run(["project", "edit", "5", "--archive"]);

    await run(["project", "delete", "5", "--yes"]);

    await run(["--json", "project", "list", "--archived"]);

    expect(requests.map((entry) => `${entry.method} ${entry.path}`)).toEqual([

      "GET /api/v1/repos/octavia/project/projectsV2?archived=true",

      "PATCH /api/v1/repos/octavia/project/projectsV2/5",

      "DELETE /api/v1/repos/octavia/project/projectsV2/5",

      "GET /api/v1/repos/octavia/project/projectsV2?archived=true",

    ]);

    expect(requests[1]?.body).toEqual({ archived: true });

    expect(written[0]?.document.value).toEqual({ projects: [board] });

    expect(written[3]?.document.value).toEqual({ projects: [] });

  });

  it("refuses to delete a board without --yes and sends no request", async () => {

    const requests: Array<ApiRequest> = [];

    const { run } = harness((input) =>

      Effect.sync(() => {

        requests.push(input);

        return { status: 204, body: {} };

      }),

    );

    await expect(run(["project", "delete", "5"])).rejects.toThrow(/--yes/u);

    expect(requests).toEqual([]);

  });

  it("refuses an edit that names no field and sends no request", async () => {

    const requests: Array<ApiRequest> = [];

    const { run } = harness((input) =>

      Effect.sync(() => {

        requests.push(input);

        return { status: 200, body: {} };

      }),

    );

    await expect(run(["project", "edit", "5"])).rejects.toThrow(/--title/u);

    expect(requests).toEqual([]);

  });

  it("sends a title, description, and state together in one edit", async () => {

    const requests: Array<ApiRequest> = [];

    const { run } = harness((input) =>

      Effect.sync(() => {

        requests.push(input);

        return { status: 200, body: { number: 5, title: "Renamed" } };

      }),

    );

    await run([

      "project",

      "edit",

      "5",

      "--title",

      "Renamed",

      "--description",

      "Why it exists",

      "--state",

      "closed",

    ]);

    expect(requests[0]?.method).toBe("PATCH");

    expect(requests[0]?.body).toEqual({

      title: "Renamed",

      description: "Why it exists",

      state: "closed",

    });

  });

});

    expect(repository.full_name).toBe("octavia/project");

    expect(requests).toHaveLength(1);

    expect(requests[0]?.path).toBe("/api/v1/user/repos");

    expect(requests[0]?.path).toBe("/api/v1/repos");

    expect(requests[0]?.body).toEqual({ name: "project", private: true });

    expect(requests[0]?.headers?.["idempotency-key"]).toBeTypeOf("string");

  });

  it("creates an organization repository through the organization route", async () => {

  it("sends a named owner to the server rather than guessing its kind", async () => {

    // The bug this replaces: a slash in `repo create OWNER/NAME` was read as

    // proof the owner is an organization, so a personal namespace went to

    // `/api/v1/orgs/{owner}/repos`. An organization owner and a personal owner

    // are the same request now, and the server resolves which is which.

    const requests: Array<ApiRequest> = [];

    const layer = layerFromHandler((input) =>

      Effect.sync(() => {

        requests.push(input);

        return { status: 201, body: repositoryFixture("acme/project") };

        const sent = input.body as Record<string, unknown>;

        return { status: 201, body: repositoryFixture(`${String(sent["owner"])}/project`) };

      }),

    );

    await Effect.runPromise(

    const create = (owner: string) =>

      Effect.gen(function* () {

        const client = yield* RepositoryClient;

        return yield* client.create({

          origin: "http://localhost:4000",

          token,

          owner: "acme",

          owner,

          name: "project",

          private: true,

        });

      }).pipe(Effect.provide(layer)),

    );

    expect(requests[0]?.path).toBe("/api/v1/orgs/acme/repos");

      }).pipe(Effect.provide(layer));

    await Effect.runPromise(create("acme"));

    await Effect.runPromise(create("AtlantisPleb"));

    expect(requests.map((entry) => entry.path)).toEqual(["/api/v1/repos", "/api/v1/repos"]);

    expect(requests.map((entry) => (entry.body as Record<string, unknown>)["owner"])).toEqual([

      "acme",

      "AtlantisPleb",

    ]);

    expect(requests.every((entry) => !entry.path.includes("/orgs/"))).toBe(true);

  });

  it("reports repository provisioning progress before completion", async () => {