@nodii/dev 0.6.32 → 0.6.33

package/dist/cli.js

@@ -178,6 +178,10 @@ Usage: nodii-dev <command> [options] [--json]
   lane amend <key> --objective|--scope|--rules TEXT --reason TEXT
   lane gather [<key>] [--delta] [--objective TEXT] [--done-check TEXT] [--components a,b] [--paths a,b]
                                         # infers a launched worktree; explicit contract inputs support manual lane start
+  lane gather [<key>] --picker agent [--shortlist ID --documents CODE[,CODE]]
+                                        # the lane agent picks instead of local Gemma: alone it prints the
+                                        # recorded trigger shortlist; with --shortlist/--documents it records
+                                        # the pick (picker: agent) and the Clause map
   run [--kind build|test_run|subagent|deploy] [--name TEXT] -- <command> [args...]
                                         # watched command: registers with NODII_DEV_RUN_ID,
                                         # heartbeats, and records exit code + redacted log tail
@@ -185,6 +189,8 @@ Usage: nodii-dev <command> [options] [--json]
   lane start <key> --title TEXT --kind KIND --side SIDE [--repo REPO] [--issue ISSUE]
   lane step <key> --side SIDE --start|--done|--block <step> [--reason TEXT]
                                         # --block --reason on a blocked step records its new reason
+  lane step <key> --side SIDE --not-applicable gather --reason-code pre_harness_lane [--note TEXT]
+                                        # coordinator only: Gather never applied (pre-Gather lane); never "done"
   lane evidence <key> --pr|--commit|--figma|--deploy|--dev-check REF
   lane subagent-quota <key> <n>          # coordinator assigns 0-100 subagent slots
   lane heartbeat|resume|land|verify|prioritize|deprioritize|stop <key>
@@ -609,6 +615,8 @@ export async function main(argv = process.argv.slice(2)) {
   if (command === "lane" && action === "amend") return emitCommand(await amendLaneCommand(rest[0], f));
   if (command === "lane" && action === "gather") {
     const result = await gatherLaneCommand(rest[0], f);
+    // An agent picker's shortlist step records nothing yet.
+    if (result.payload?.data?.recorded === false) return emitCommand(result);
     // What a gather covered is the lane's gathered set for the nudge hooks.
     const asked = (value) => (typeof value === "string" ? value.split(",").map((item) => item.trim()).filter(Boolean) : []);
     await (async () => recordGathered(process.cwd(), { guidelines: asked(f.components), deltaGathered: f.delta ? (f.paths ? asked(f.paths) : await changedPaths(process.cwd())) : [] }))().catch(() => {});

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.32";
+export const VERSION = "0.6.33";
 export const configPath = () =>
   process.env.NODII_DEV_CONFIG_PATH ??
   join(homedir(), ".config/nodii-dev/config.json");

package/dist/lanes.js

@@ -4,7 +4,7 @@ import { promisify } from "node:util";
 import { CliError, encode, devRequest, query, readConfig, requireFlag } from "./core.js";
 import { launchRecovery } from "./runtime-launcher.js";
 import { recordReviewReceipt, reviewCommitContext } from "./safety.js";
-import { GATHER_TIMEOUT_MS, gatherText, pickDocuments } from "./gather.js";
+import { GATHER_TIMEOUT_MS, PICKER_MODEL, gatherText, pickDocuments } from "./gather.js";
 import { storeGatherFreeze } from "./freeze.js";
 
 const execFileAsync = promisify(execFile);
@@ -46,7 +46,65 @@ export async function inferGitContext() {
 }
 
 const laneLine = (x) => `${x.key}\t${x.status}\t${x.kind}/${x.side}\t${x.title}${x.stuck ? "\tSTUCK" : ""}`;
-const detailText = (x) => [laneLine(x), ...(x.steps ?? []).map((s) => `  ${s.side}\t${s.state}\t${s.stepKey}\t${s.label}`)].join("\n");
+// GATHER-NA: a step the coordinator ruled not applicable is never shown as done.
+const stepState = (s) => s.state === "not_applicable" ? `not applicable: ${s.notApplicableReason ?? "(no reason recorded)"}` : s.state;
+const detailText = (x) => [laneLine(x), ...(x.steps ?? []).map((s) => `  ${s.side}\t${stepState(s)}\t${s.stepKey}\t${s.label}`)].join("\n");
+
+/**
+ * GATHER-NA: `--picker agent` makes the lane agent Gather's picker. Without
+ * --shortlist it only shortlists and prints the triggers to pick from; with
+ * --shortlist ID --documents A,B it records that pick against the recorded
+ * shortlist: Dev reuses its objective, paths and components, refuses a pick
+ * it did not offer, and adds its forced triggers. Gather never records a
+ * pick with no shortlist behind it.
+ */
+function agentPickerFlags(flags) {
+  if (flags.picker === undefined) {
+    if (flags.shortlist !== undefined || flags.documents !== undefined)
+      throw new CliError("USAGE", "--shortlist and --documents go with --picker agent.", 2);
+    return null;
+  }
+  if (flags.picker !== "agent")
+    throw new CliError("USAGE", `--picker accepts only agent; without it the local ${PICKER_MODEL} picks.`, 2);
+  const shortlist = typeof flags.shortlist === "string" ? flags.shortlist.trim() : undefined;
+  const documents = typeof flags.documents === "string" ? list(flags.documents) : undefined;
+  if ((flags.shortlist !== undefined && !shortlist) || (flags.documents !== undefined && !documents?.length))
+    throw new CliError("USAGE", "--shortlist needs an id and --documents needs one or more codes.", 2);
+  if (Boolean(shortlist) !== Boolean(documents))
+    throw new CliError("USAGE", "Record an agent pick with both --shortlist ID and --documents CODE[,CODE]; run --picker agent alone first to see the shortlist.", 2);
+  return { shortlist, documents };
+}
+
+// hub-58: the reason is a fixed code (Dev stores its canonical text); a note may add context.
+export const NOT_APPLICABLE_REASON_CODES = ["pre_harness_lane"];
+function notApplicableRuling(flags) {
+  const code = flags["reason-code"];
+  if (!NOT_APPLICABLE_REASON_CODES.includes(code))
+    throw new CliError("USAGE", `--not-applicable needs --reason-code ${NOT_APPLICABLE_REASON_CODES.join("|")}.`, 2);
+  if (flags.note !== undefined && (typeof flags.note !== "string" || !flags.note.trim()))
+    throw new CliError("USAGE", "--note needs non-empty text.", 2);
+  return { reasonCode: code, ...(flags.note !== undefined ? { note: flags.note.trim() } : {}) };
+}
+
+const shellQuote = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
+// The follow-up repeats the flags that shaped this Gather, so it records the same one.
+const agentFollowUp = (ref, shortlistId, flags) => [
+  `nodii-dev lane gather ${ref} --picker agent --shortlist ${shortlistId} --documents CODE[,CODE]`,
+  ...(flags.delta ? ["--delta"] : []),
+  // --paths/--components are not resent to Dev (it reuses the shortlist's),
+  // but the local gathered set for the nudge hooks reads them.
+  ...["objective", "done-check", "section-limit-per-document", "paths", "components"]
+    .filter((flag) => typeof flags[flag] === "string")
+    .map((flag) => `--${flag} ${shellQuote(flags[flag])}`),
+].join(" ");
+const agentShortlistText = (ref, data, flags) => [
+  `Trigger shortlist ${data.shortlistId} · ${JSON.stringify(data.objective)}`,
+  "You are Gather's picker (picker: agent). Nothing is recorded yet.",
+  ...data.triggers.map((trigger) => `  ${trigger.code}\t${trigger.title ?? ""}: ${trigger.sentence ?? ""}${trigger.forcedBy?.length ? `  [forced by ${trigger.forcedBy.join(", ")}]` : ""}`),
+  "",
+  "Pick every document that applies (forced ones are added for you), then record the pick:",
+  `  ${agentFollowUp(ref, data.shortlistId, flags)}`,
+].join("\n");
 
 function evidence(flags) {
   const selected = ["pr", "commit", "figma", "deploy", "dev-check"].filter((x) => flags[x] !== undefined);
@@ -183,6 +241,7 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     const deadline = controller ? setTimeout(() => controller.abort(), gatherTimeoutMs) : null;
     const signal = gatherSignal ?? controller.signal;
     try {
+      const byAgent = agentPickerFlags(flags);
       const lane = (await request("GET", `/api/v1/lanes/${encode(id)}`, undefined, { signal })).data;
       if (flags.objective !== undefined && (typeof flags.objective !== "string" || !flags.objective.trim()))
         throw new CliError("USAGE", "lane gather --objective needs non-empty text", 2);
@@ -255,9 +314,15 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
         components,
         ...(limit !== undefined ? { limit } : {}),
       };
-      const shortlist = await request("POST", "/api/v1/rules/shortlist", shortlistBody, { signal });
+      // An agent pick records against the shortlist it was made from.
+      const shortlist = byAgent?.shortlist
+        ? { data: { shortlistId: byAgent.shortlist, triggers: [] } }
+        : await request("POST", "/api/v1/rules/shortlist", shortlistBody, { signal });
+      const shortlistId = shortlist.data?.shortlistId;
       const triggers = shortlist.data?.triggers ?? [];
-      const picked = await picker({
+      if (byAgent && !byAgent.shortlist)
+        return { payload: { data: { recorded: false, picker: "agent", shortlistId, objective, triggers } }, human: (p) => agentShortlistText(ref, p.data, flags) };
+      const picked = byAgent ? { documents: byAgent.documents } : await picker({
         objective,
         files: paths,
         triggers: triggers.map((trigger) => ({
@@ -269,10 +334,12 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
       const payload = await request("POST", `/api/v1/lanes/${encode(id)}/gather`, {
         objective,
         documentCodes: picked.documents,
-        paths,
-        components,
+        // An agent pick answers the shortlist's own paths and components.
+        ...(byAgent ? {} : { paths, components }),
         mode: flags.delta ? "delta" : "full",
         ...(sectionLimit !== undefined ? { sectionLimitPerDocument: sectionLimit } : {}),
+        shortlistId,
+        picker: byAgent ? "agent" : picked.model ?? PICKER_MODEL,
       }, { signal });
       const figma = lane.freeze?.boundaries?.figma ?? (lane.launch?.figmaScopes ?? []).map((file) => ({
         fileKey: file.fileKey,
@@ -305,15 +372,24 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     }
   }
   if (action === "step") {
-    const selected = ["start", "done", "block"].filter((x) => flags[x]);
-    if (selected.length !== 1) throw new CliError("USAGE", "lane step needs exactly one of --start, --done, or --block.", 2);
+    const selected = ["start", "done", "block", "not-applicable"].filter((x) => flags[x]);
+    if (selected.length !== 1) throw new CliError("USAGE", "lane step needs exactly one of --start, --done, --block, or --not-applicable.", 2);
     const side = requireFlag(flags, "side");
-    const stepRef = need(flags[selected[0]] === true ? args[1] : flags[selected[0]], "lane step needs <key> --side <side> --start|--done|--block <step>");
+    const stepRef = need(flags[selected[0]] === true ? args[1] : flags[selected[0]], "lane step needs <key> --side <side> --start|--done|--block|--not-applicable <step>");
     const reason = typeof flags.reason === "string" ? flags.reason.trim() : "";
     if (flags.reason !== undefined && (selected[0] !== "block" || !reason)) throw new CliError("USAGE", "--reason TEXT goes with --block.", 2);
+    const ruling = selected[0] === "not-applicable" ? notApplicableRuling(flags) : null;
+    if (!ruling && (flags["reason-code"] !== undefined || flags.note !== undefined)) throw new CliError("USAGE", "--reason-code and --note go with --not-applicable.", 2);
     const lane = (await request("GET", `/api/v1/lanes/${encode(id)}`)).data;
     const step = lane.steps.find((x) => x.side === side && (x.id === stepRef || x.stepKey === stepRef));
     if (!step) throw new CliError("STEP_NOT_FOUND", `No ${side} step ${stepRef} on ${ref}.`, 1);
+    // hub-58: Gather is the only step a coordinator may rule not applicable.
+    if (ruling && step.stepKey !== "gather") throw new CliError("USAGE", "--not-applicable covers only the gather step.", 2);
+    // GATHER-NA: coordinator only; Dev refuses a lane identity (COORDINATOR_REQUIRED).
+    if (ruling) {
+      const payload = await request("POST", `/api/v1/lanes/${encode(id)}/steps/${encode(step.id)}/not-applicable`, { ...ruling, ...via });
+      return { payload, human: (p) => `${ref}: ${side}/${step.stepKey} not applicable: ${p.data.notApplicableReason}${ruling.note ? ` (${ruling.note})` : ""}` };
+    }
     // Dev's blockLaneStep stores no reason and refuses a step that is already
     // blocked (INVALID_STEP_STATE), so the reason is a lane heartbeat note
     // until Dev issue 125 lets the step carry it.

package/dist/starting.js

@@ -396,6 +396,9 @@ export async function amendmentGuard(argv, { request = devRequest, marker = curr
 
 const runGather = (key, flags, { request, signal }) => laneCommand("gather", [key], flags, { request, gatherSignal: signal });
 
+// Gather's human text is its Clause map (a function of the payload).
+const gatheredText = (gathered) => typeof gathered.human === "function" ? gathered.human(gathered.payload) : gathered.human ?? "Gather complete.";
+
 export async function gatherLaneCommand(key, flags, { request = devRequest, marker = currentMarker, gather = runGather, acknowledge = nextCommand, gatherTimeoutMs = GATHER_TIMEOUT_MS } = {}) {
   const controller = new AbortController();
   const deadline = setTimeout(() => controller.abort(), gatherTimeoutMs);
@@ -411,10 +414,13 @@ export async function gatherLaneCommand(key, flags, { request = devRequest, mark
     const pending = await timedRequest("GET", `/api/v1/lanes/${encode(key)}/amendments${query({ runId: lane.runId })}`);
     if (!pending.data.length) {
       const gathered = await withSignal(gather(key, flags, { request: timedRequest, signal }), signal);
-      return { ...gathered, human: `${typeof gathered.human === "string" ? gathered.human : "Gather complete."}\nNo pending amendments.` };
+      if (gathered.payload?.data?.recorded === false) return gathered;
+      return { ...gathered, human: `${gatheredText(gathered)}\nNo pending amendments.` };
     }
     const version = Math.max(...pending.data.map((item) => item.version));
     const gathered = await withSignal(gather(key, flags, { request: timedRequest, signal }), signal);
+    // An agent picker's shortlist step records nothing, so it acknowledges nothing.
+    if (gathered.payload?.data?.recorded === false) return gathered;
     const acknowledgement = await withSignal(acknowledge(key, {
       ...flags,
       deltaContext: { runId: lane.runId, amendmentVersion: version },
@@ -424,7 +430,7 @@ export async function gatherLaneCommand(key, flags, { request = devRequest, mark
       throw new CliError("LANE_AMENDMENT_ACK_FAILED", `Delta gather did not acknowledge amendment version ${version}; the lane remains blocked.`, 1);
     return {
       payload: { ...gathered.payload, rules: acknowledgement.payload?.rules, amendments: pending.data, acknowledgedVersion },
-      human: `${pending.data.map((item) => `v${item.version} ${item.reason}: ${JSON.stringify(item.change)}`).join("\n")}\n${typeof gathered.human === "string" ? gathered.human : "Gather complete."}\nAcknowledged amendment version ${version}.`,
+      human: `${pending.data.map((item) => `v${item.version} ${item.reason}: ${JSON.stringify(item.change)}`).join("\n")}\n${gatheredText(gathered)}\nAcknowledged amendment version ${version}.`,
     };
   } catch (error) {
     if (signal.aborted) throw new CliError("GATHER_TIMEOUT", `Gather exceeded its ${Math.round(gatherTimeoutMs / 1000)}-second deadline; nothing was retried.`, 1);

package/package.json

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