@nodii/dev 0.6.5 → 0.6.6

package/README.md

@@ -164,6 +164,8 @@ nodii-dev lane list [--kind KIND] [--status STATUS] [--machine UUID]
 nodii-dev lane show KEY
 nodii-dev lane prioritize|deprioritize KEY --reason TEXT
 nodii-dev lane stop KEY --reason TEXT
+nodii-dev lane non-issue KEY --reason TEXT --evidence TEXT --reroute KEY[,KEY]|none
+                         --branch carried:ISSUE|dropped[:REASON] [--commits SHA[,SHA]]
 nodii-dev next KEY
 
 nodii-dev built list [--cursor CURSOR] [--include-acknowledged true]
@@ -343,6 +345,38 @@ checks. Setup also checks the OAuth login (a token refresh, then the registered
 agent) and prints `nodii-dev login` guidance without exposing credential
 details.
 
+`lane non-issue` ends a lane at its second terminal status, `non_issue`, when
+its investigation proves the issue is not a defect in its repository (DEC-0011,
+MW1-28.1). The lane's own agent or the machine's coordinator runs it; no staff
+person is needed. It needs:
+
+- `--reason`: why this is not a defect here;
+- `--evidence`: what was checked, with `file:line` or data;
+- `--reroute`: the issue keys the real cause was re-routed to, comma-separated,
+  or `none` only when the evidence shows no defect anywhere;
+- `--branch`: what happens to the lane's branch work. `carried:ISSUE` carries it
+  into that open follow-up issue with its commits; `dropped:REASON` drops it
+  with a reason. A bare `dropped` is accepted only when the branch has no
+  commits beyond `origin/main`, and records that as the reason. Dev records the
+  outcome with the lane's branch.
+- `--commits`: the commits (at most 200). Carried work needs at least one.
+  Without the flag the CLI reads the lane's branch commits that are not on
+  `origin/main` (as last fetched) from the lane's recorded worktree; it refuses
+  with `GIT_REQUIRED` when it cannot read them, and with `USAGE` when carried
+  work has none (drop it instead).
+
+The CLI refuses with `USAGE` (exit 2) before sending anything when one of these
+is missing. Dev then makes the lane `non_issue`, which frees its slot like
+`on_dev`, and moves each linked open issue to `wont_do` with the reason. An
+issue that another active lane still works on stays open. Dev refuses a lane
+that is already terminal (409 `LANE_TERMINAL`), a caller that is neither the
+lane's agent nor its coordinator (403 `LANE_ACTOR_REQUIRED`), a live lease held
+by someone else (409 `CLAIM_HELD_BY_OTHER`), and a re-route or carried key that
+names no issue, the lane's own issue, or (for carried) a closed one (422).
+The command reaches Dev through the edge, so it needs the edge's route for
+`/devops/api/v1/lanes/:id/non-issue`; until that is on an environment, the
+command gets the edge's 404 there.
+
 Heartbeat notes are optional and limited by Dev to 500 characters.
 Prioritize and deprioritize require a 1–500 character reason, which the CLI
 sends to Dev. `lane review` records the review gate.

package/dist/cli.js

@@ -84,6 +84,9 @@ Usage: nodii-dev <command> [options] [--json]
   lane step <key> --side SIDE --start|--done|--block <step>
   lane evidence <key> --pr|--commit|--figma|--deploy|--dev-check REF
   lane heartbeat|review|land|verify|prioritize|deprioritize|stop <key>
+  lane non-issue <key> --reason TEXT --evidence TEXT --reroute KEY[,KEY]|none
+                 --branch carried:KEY|dropped[:REASON] [--commits SHA[,SHA]]
+                                        # DEC-0011: terminal non_issue; issue -> wont_do; slot frees
   lane list [--kind KIND] [--status STATUS] [--mine] [--cursor CURSOR]
   lane show <key> | next <key>
   built list | built ack <key...>

package/dist/core.js

@@ -4,7 +4,7 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 
-export const VERSION = "0.6.5";
+export const VERSION = "0.6.6";
 export const configPath = () =>
   process.env.NODII_DEV_CONFIG_PATH ??
   join(homedir(), ".config/nodii-dev/config.json");

package/dist/lanes.js

@@ -48,7 +48,55 @@ function evidence(flags) {
   return { kind: flag === "figma" ? "figma_frame" : flag.replace("-", "_"), ...(URL.canParse(value) ? { url: value } : { ref: value }), ...via };
 }
 
-export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext } = {}) {
+const list = (value) => String(value).split(",").map((x) => x.trim()).filter(Boolean);
+
+/**
+ * DEC-0011 (MW1-28.1): the body for `lane non-issue`. A re-route needs at
+ * least one issue key or an explicit `none`, and the branch work is either
+ * carried into a named issue with its commits or dropped with a reason, never
+ * left unsaid. Without --commits, the commits are the lane's branch commits
+ * that are not on origin/main, read from the lane's recorded worktree.
+ */
+export async function nonIssueBody(flags, laneCommits) {
+  const reason = requireFlag(flags, "reason");
+  const evidence = requireFlag(flags, "evidence");
+  const rerouteFlag = requireFlag(flags, "reroute");
+  const reroute = rerouteFlag === "none" ? "none" : list(rerouteFlag);
+  if (reroute !== "none" && !reroute.length) throw new CliError("USAGE", "--reroute needs at least one issue key, or none when the evidence shows no defect anywhere.", 2);
+  const branchFlag = flags.branch;
+  const usage = "--branch must say what happens to the lane's branch work: carried:ISSUE_KEY or dropped[:REASON].";
+  if (typeof branchFlag !== "string" || !branchFlag) throw new CliError("USAGE", usage, 2);
+  const at = branchFlag.indexOf(":");
+  const disposition = at === -1 ? branchFlag : branchFlag.slice(0, at);
+  const detail = at === -1 ? "" : branchFlag.slice(at + 1).trim();
+  if (!(disposition === "carried" && detail) && disposition !== "dropped") throw new CliError("USAGE", usage, 2);
+  const given = flags.commits !== undefined ? list(requireFlag(flags, "commits")) : undefined;
+  // dropped:REASON states its own reason, so it needs no commit lookup.
+  const commits = given ?? (disposition === "dropped" && detail ? undefined : await laneCommits());
+  if (commits && commits.length > MAX_COMMITS) throw new CliError("USAGE", `That is ${commits.length} commits; Dev records at most ${MAX_COMMITS}. Pass --commits with the ones that matter, or --branch dropped:REASON.`, 2);
+  let branch;
+  if (disposition === "carried") {
+    if (!commits.length) throw new CliError("USAGE", "Carried work needs its commits: the lane's branch has none beyond origin/main. Pass --commits SHA[,SHA], or --branch dropped:REASON.", 2);
+    branch = { disposition, issueKey: detail, commits };
+  } else if (detail) branch = { disposition, reason: detail, ...(commits ? { commits } : {}) };
+  else if (!commits.length) branch = { disposition, reason: "no commits beyond origin/main" };
+  else throw new CliError("USAGE", `The lane's branch has ${commits.length} commits beyond origin/main. Say why they are dropped: --branch dropped:REASON.`, 2);
+  return { reason, evidence, reroute, branch, ...via };
+}
+
+const MAX_COMMITS = 200;
+
+/** The lane's branch commits not on origin/main (as last fetched), from its recorded worktree. */
+export async function branchCommits(lane) {
+  try {
+    const out = (await execFileAsync("git", ["-C", lane.worktree, "rev-list", `origin/main..${lane.branch}`], { encoding: "utf8" })).stdout.trim();
+    return out ? out.split("\n") : [];
+  } catch {
+    throw new CliError("GIT_REQUIRED", `Cannot read the commits of ${lane.branch} in ${lane.worktree}. Pass --commits SHA[,SHA], or --branch dropped:REASON.`, 2);
+  }
+}
+
+export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits } = {}) {
   if (action === "list") {
     const c = flags.mine ? await config() : null;
     const payload = await request("GET", `/api/v1/lanes${query({ kind: flags.kind, status: flags.status, machine: flags.machine, agent: flags.mine ? c.agentId : flags.agent, "waiting-on": flags["waiting-on"], stuck: flags.stuck, cursor: flags.cursor, limit: flags.limit })}`);
@@ -108,6 +156,14 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     return { payload, human: `${ref}: ${action}d.` };
   }
   if (action === "stop") return { payload: await request("POST", `/api/v1/lanes/${encode(id)}/stop`, { reason: requireFlag(flags, "reason"), ...via }), human: `${ref}: stopped.` };
+  if (action === "non-issue") {
+    const body = await nonIssueBody(flags, async () => commitsOf((await request("GET", `/api/v1/lanes/${encode(id)}`)).data));
+    const payload = await request("POST", `/api/v1/lanes/${encode(id)}/non-issue`, body);
+    const { closedIssues = [], openIssues = [] } = payload?.data?.nonIssue ?? {};
+    const closed = closedIssues.length ? ` ${closedIssues.join(", ")} moved to wont_do.` : "";
+    const open = openIssues.length ? ` ${openIssues.join(", ")} left open: another active lane works on it.` : "";
+    return { payload, human: `${ref}: non_issue; slot freed.${closed}${open}` };
+  }
   throw new CliError("USAGE", `Unknown lane action: ${action}`, 2);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodii/dev",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "Agent CLI for Nodii Dev, reached through the platform edge",
   "type": "module",
   "bin": {