@nodii/dev 0.6.29 → 0.6.31

package/dist/hooks.js

@@ -1,10 +1,10 @@
 import { CliError, devRequest, readConfig } from "./core.js";
 import { FOUNDATIONS_ID, figmaLockCheck, outOfScopeText } from "./figma.js";
 import { execFile } from "node:child_process";
-import { readFile, realpath } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { safetySettingsSnippet } from "./safety.js";
+import { regroundCurrentLane } from "./freeze.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -228,46 +228,20 @@ export async function heartbeatCurrentLane(request = devRequest) {
 /** SessionStart compact context, plain text for both Claude and Codex. */
 export async function sessionStartContext(payload, { request = devRequest, config = readConfig } = {}) {
   if (payload?.source !== "compact") return null;
-  let lane = null;
-  try {
-    const cwd = payload.cwd ?? process.cwd();
-    const branch = (await execFileAsync("git", ["branch", "--show-current"], { cwd, encoding: "utf8" })).stdout.trim();
-    const rootText = (await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" })).stdout.trim();
-    const root = await realpath(rootText).catch(() => resolve(rootText));
-    const current = await config(false);
-    try {
-      const markerPath = (await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-path", "nodii-lane.json"], { cwd, encoding: "utf8" })).stdout.trim();
-      const marker = JSON.parse(await readFile(markerPath, "utf8"));
-      const marked = (await request("GET", `/api/v1/lanes/${encodeURIComponent(marker.laneKey)}`)).data;
-      const repository = marked.repositories?.find((item) => item.branch === branch && resolve(item.worktree) === root);
-      if (marked.agentId === current.agentId && repository && !["on_dev", "stopped"].includes(marked.status)) lane = marked;
-    } catch {}
-    if (lane) {
-      const freeze = lane.freeze ?? {};
-      return [
-        `Freeze re-grounding for ${lane.key}:`,
-        `title: ${lane.title ?? "(untitled)"}`,
-        `status: ${lane.status}`,
-        `boundaries: ${JSON.stringify(freeze.boundaries ?? {})}`,
-        `rules: ${JSON.stringify(freeze.rules ?? freeze.ruleRefs ?? [])}`,
-      ].join("\n");
-    }
-    const lanes = (await request("GET", "/api/v1/lanes?limit=200")).data ?? [];
-    for (const item of lanes) {
-      if (item.agentId !== current.agentId || item.branch !== branch || ["on_dev", "stopped"].includes(item.status)) continue;
-      const worktree = await realpath(item.worktree ?? root).catch(() => resolve(item.worktree ?? root));
-      if (worktree === root) { lane = item; break; }
-    }
-  } catch {}
-  if (!lane) return "Freeze re-grounding: no active Dev lane was available for this branch; re-read the lane brief before continuing.";
-  const freeze = lane.freeze ?? {};
-  return [
-    `Freeze re-grounding for ${lane.key}:`,
-    `title: ${lane.title ?? "(untitled)"}`,
-    `status: ${lane.status}`,
-    `boundaries: ${JSON.stringify(freeze.boundaries ?? {})}`,
-    `rules: ${JSON.stringify(freeze.rules ?? freeze.ruleRefs ?? [])}`,
-  ].join("\n");
+  let context = "";
+  const result = await regroundCurrentLane(
+    {
+      cwd: payload.cwd ?? process.cwd(),
+      force: true,
+      write: (text) => {
+        context += text;
+      },
+    },
+    { request, config },
+  );
+  return result.shown
+    ? context.trimEnd()
+    : "Freeze re-grounding: no active Dev lane with initialized Freeze was available for this worktree; run `nodii-dev lane freeze show <key>` before continuing.";
 }
 
 export function workflowSuggestion(payload) {

package/dist/lanes.js

@@ -4,9 +4,12 @@ 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 { storeGatherFreeze } from "./freeze.js";
 
 const execFileAsync = promisify(execFile);
 const via = { via: "nodii-dev" };
+const GATHER_ACTIVE = new Set(["queued", "building"]);
 // heartbeatLane's note limit.
 const BLOCK_NOTE_MAX = 500;
 
@@ -118,7 +121,34 @@ export async function branchCommits(lane) {
   }
 }
 
-export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt, launch = launchRecovery } = {}) {
+async function currentGatherLane(request, config, gitContext) {
+  const c = await config();
+  const context = await gitContext();
+  const lanes = [];
+  let cursor;
+  do {
+    const page = await request("GET", `/api/v1/lanes${query({ agent: c.agentId, cursor, limit: 200 })}`);
+    lanes.push(...(page.data ?? []));
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor);
+  const active = lanes.filter((lane) => GATHER_ACTIVE.has(lane.status));
+  const repositories = (lane) => lane.repositories?.length
+    ? lane.repositories
+    : lane.freeze?.boundaries?.repos?.length
+      ? lane.freeze.boundaries.repos
+      : [{ repo: lane.repos?.[0], branch: lane.branch, worktree: lane.worktree }];
+  const exact = active.filter((lane) => repositories(lane).some((repository) => repository.worktree === context.worktree));
+  const branch = active.filter((lane) => repositories(lane).some((repository) =>
+    repository.branch === context.branch && repoName(repository.repo ?? "") === context.repo));
+  const matches = exact.length ? exact : branch;
+  if (matches.length !== 1)
+    throw new CliError("CURRENT_LANE_AMBIGUOUS", matches.length
+      ? `This worktree matches ${matches.length} active lanes (${matches.map((lane) => lane.key).join(", ")}); pass one key explicitly.`
+      : "No active lane matches this agent and worktree; pass the lane key explicitly.", 2);
+  return matches[0].key;
+}
+
+export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt, picker = pickDocuments, changedPaths = laneChangedPaths, gatherTimeoutMs = GATHER_TIMEOUT_MS, gatherSignal, storeFreeze = storeGatherFreeze, launch = launchRecovery } = {}) {
   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 })}`);
@@ -142,12 +172,138 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     const payload = await request("POST", `/api/v1/lanes/${encode(key)}/start`, via);
     return { payload, human: (p) => `Started ${laneLine(p.data)}` };
   }
-  const ref = need(args[0], `lane ${action} needs <key>`);
+  const ref = need(args[0] ?? (action === "gather" ? await currentGatherLane(request, config, gitContext) : undefined), `lane ${action} needs <key>`);
   const id = ref;
   if (action === "show") {
     const payload = await request("GET", `/api/v1/lanes/${encode(id)}`);
     return { payload, human: (p) => detailText(p.data) };
   }
+  if (action === "gather") {
+    const controller = gatherSignal ? null : new AbortController();
+    const deadline = controller ? setTimeout(() => controller.abort(), gatherTimeoutMs) : null;
+    const signal = gatherSignal ?? controller.signal;
+    try {
+      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);
+      if (flags["done-check"] !== undefined && (typeof flags["done-check"] !== "string" || !flags["done-check"].trim()))
+        throw new CliError("USAGE", "lane gather --done-check needs non-empty text", 2);
+      const durableObjective = [lane.objective, lane.freeze?.objective?.ask].find((x) => typeof x === "string" && x.trim());
+      const explicitObjective = typeof flags.objective === "string" ? flags.objective.trim() : undefined;
+      if (explicitObjective && durableObjective && explicitObjective !== durableObjective.trim())
+        throw new CliError("GATHER_OBJECTIVE_CONFLICT", `${ref} already has a different objective. Use lane amend; Gather cannot rewrite the durable contract.`, 1);
+      const issueObjective = typeof lane.issue?.bodyMd === "string" && lane.issue.bodyMd.trim() ? lane.issue.bodyMd : undefined;
+      const objective = durableObjective ?? explicitObjective ?? issueObjective;
+      if (!objective) throw new CliError("GATHER_OBJECTIVE_MISSING", `${ref} has no recorded objective. Amend the lane or pass --objective; the CLI does not invent one.`, 1);
+      if (objective.length > 20_000) throw new CliError("USAGE", "The recorded Gather objective exceeds Dev's 20,000-character limit.", 2);
+      const durableDoneCheck = [lane.doneCheck, lane.freeze?.objective?.doneCheck].find((x) => typeof x === "string" && x.trim());
+      const explicitDoneCheck = typeof flags["done-check"] === "string" ? flags["done-check"].trim() : undefined;
+      if (explicitDoneCheck && durableDoneCheck && explicitDoneCheck !== durableDoneCheck.trim())
+        throw new CliError("GATHER_DONE_CHECK_CONFLICT", `${ref} already has a different done check. Use lane amend; Gather cannot rewrite the durable contract.`, 1);
+      const doneCheck = durableDoneCheck ?? explicitDoneCheck;
+      if (!doneCheck) throw new CliError("GATHER_DONE_CHECK_MISSING", `${ref} has no recorded done check. Pass --done-check before Gather records anything.`, 1);
+      if (doneCheck.length > 10_000) throw new CliError("USAGE", "The Gather done check exceeds Dev's 10,000-character limit.", 2);
+      const legacyRepository = {
+        repo: lane.repos?.[0],
+        branch: lane.branch,
+        worktree: lane.worktree,
+        ownedPaths: lane.ownedPaths ?? [],
+      };
+      const sourceRepositories = lane.repositories?.length
+        ? lane.repositories
+        : lane.freeze?.boundaries?.repos?.length
+          ? lane.freeze.boundaries.repos
+          : [legacyRepository];
+      const repositories = sourceRepositories.map((repository) => Object.fromEntries(
+        ["repo", "branch", "worktree", "ownedPaths"]
+          .map((key) => [key, repository[key]])
+          .filter(([, value]) => value !== undefined),
+      ));
+      if (!repositories.length || repositories.some((repository) => !repository.repo || !repository.branch || !repository.worktree))
+        throw new CliError("GATHER_BOUNDARIES_MISSING", `${ref} has an incomplete repository boundary. Repair its repo, branch, and worktree before Gather records anything.`, 1);
+      const limit = flags.limit === undefined ? undefined : Number(flags.limit);
+      if (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 500))
+        throw new CliError("USAGE", "lane gather --limit needs a whole number from 1 to 500", 2);
+      const sectionLimit = flags["section-limit-per-document"] === undefined ? undefined : Number(flags["section-limit-per-document"]);
+      if (sectionLimit !== undefined && (!Number.isInteger(sectionLimit) || sectionLimit < 1 || sectionLimit > 20))
+        throw new CliError("USAGE", "lane gather --section-limit-per-document needs a whole number from 1 to 20", 2);
+      const recordedPaths = [
+        ...(lane.repositories ?? []).flatMap((repository) => repository.ownedPaths ?? []),
+        ...(lane.freeze?.boundaries?.repos ?? []).flatMap((repository) => repository.ownedPaths ?? []),
+        ...(lane.ownedPaths ?? []),
+      ];
+      const driftPaths = await changedPaths(lane, { signal });
+      if (driftPaths === null)
+        throw new CliError("GATHER_PATHS_UNAVAILABLE", "Gather could not read every recorded worktree. Repair the lane boundary or make its repositories available before continuing.", 1);
+      const paths = flags.paths ? list(flags.paths) : [...new Set([...recordedPaths, ...driftPaths])];
+      if (paths.length > 5000) throw new CliError("GATHER_SCOPE_TOO_LARGE", `Gather found ${paths.length} paths; Dev accepts at most 5,000. Narrow the lane's recorded scope before continuing.`, 1);
+      const repoRefs = [
+        ...(lane.repositories ?? []).map((repository) => repository.repo),
+        ...(lane.freeze?.boundaries?.repos ?? []).map((repository) => repository.repo),
+        ...(Array.isArray(lane.repos) ? lane.repos.map((repo) => typeof repo === "string" ? repo : repo.repo) : []),
+      ];
+      const repos = [...new Set(repoRefs.filter(Boolean).map(repoName))];
+      const components = flags.components ? list(flags.components) : [
+        ...(lane.freeze?.boundaries?.figma ?? []).flatMap((file) => file.componentSetKeys ?? []),
+        ...(lane.launch?.figmaScopes ?? []).flatMap((file) => file.componentSets ?? []),
+        ...(lane.components ?? []),
+      ];
+      const shortlistBody = {
+        objective,
+        paths,
+        repos,
+        components,
+        ...(limit !== undefined ? { limit } : {}),
+      };
+      const shortlist = await request("POST", "/api/v1/rules/shortlist", shortlistBody, { signal });
+      const triggers = shortlist.data?.triggers ?? [];
+      const picked = await picker({
+        objective,
+        files: paths,
+        triggers: triggers.map((trigger) => ({
+          code: trigger.code,
+          trigger: trigger.sentence,
+          ...(trigger.forcedBy ? { forcedBy: trigger.forcedBy } : {}),
+        })),
+      }, { signal });
+      const payload = await request("POST", `/api/v1/lanes/${encode(id)}/gather`, {
+        objective,
+        documentCodes: picked.documents,
+        paths,
+        components,
+        mode: flags.delta ? "delta" : "full",
+        ...(sectionLimit !== undefined ? { sectionLimitPerDocument: sectionLimit } : {}),
+      }, { signal });
+      const figma = lane.freeze?.boundaries?.figma ?? (lane.launch?.figmaScopes ?? []).map((file) => ({
+        fileKey: file.fileKey,
+        ...(file.componentSets?.length ? { componentSetKeys: file.componentSets } : {}),
+      }));
+      const issue = lane.issue ? { key: lane.issue.key, title: lane.issue.title } : null;
+      const laneNotes = [
+        lane.launch?.notes,
+        lane.launch?.narrowingNote && `Narrowing: ${lane.launch.narrowingNote}`,
+        lane.launch?.narrowingRemainder && `Narrowing remainder: ${lane.launch.narrowingRemainder}`,
+      ].filter(Boolean);
+      const freezeRequest = (method, path, body, options = {}) => request(method, path, body, { ...options, signal });
+      await storeFreeze(id, {
+        gather: payload.data,
+        boundaries: { repos: repositories, ...(figma.length ? { figma } : {}) },
+        issue,
+        laneNotes,
+        doneCheck,
+      }, { request: freezeRequest });
+      const reasons = Object.fromEntries(triggers.map((trigger) => [
+        trigger.code,
+        Array.isArray(trigger.forcedBy) && trigger.forcedBy.length ? `forced by ${trigger.forcedBy.join(", ")}` : trigger.sentence,
+      ]));
+      return { payload, human: (p) => gatherText(p, objective, reasons) };
+    } catch (error) {
+      if (signal.aborted) throw new CliError("GATHER_TIMEOUT", `Gather exceeded its ${Math.round(gatherTimeoutMs / 1000)}-second deadline; nothing was retried.`, 1);
+      throw error;
+    } finally {
+      if (deadline) clearTimeout(deadline);
+    }
+  }
   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);
@@ -303,21 +459,26 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
 /**
  * The files a lane touches, for path-tagged rules (M05-32): its branch and
  * working-tree changes against origin/main, plus untracked files, read from
- * its recorded worktree. Null when that worktree cannot be read here; Dev then
- * serves every path-tagged clause rather than miss one.
+ * its recorded worktree. Null when any worktree cannot be read here; Gather
+ * refuses that unknown scope rather than silently omit path-triggered rules.
  */
-export async function laneChangedPaths(lane) {
+export async function laneChangedPaths(lane, { signal, exec = execFileAsync } = {}) {
   try {
-    const repositories = lane.repositories?.length ? lane.repositories : [{ repo: lane.repos?.[0], worktree: lane.worktree, baseRef: "origin/main" }];
+    const repositories = lane.repositories?.length
+      ? lane.repositories
+      : lane.freeze?.boundaries?.repos?.length
+        ? lane.freeze.boundaries.repos
+        : [{ repo: lane.repos?.[0], worktree: lane.worktree, baseRef: "origin/main" }];
     const changed = await Promise.all(repositories.map(async (repository) => {
-      const run = async (...args) => (await execFileAsync("git", ["-C", repository.worktree, ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 })).stdout;
+      const run = async (...args) => (await exec("git", ["-C", repository.worktree, ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, signal })).stdout;
       const base = (await run("merge-base", repository.baseRef ?? "origin/main", "HEAD")).trim();
       const tracked = (await run("diff", "--name-only", base)).split("\n");
       const untracked = (await run("ls-files", "--others", "--exclude-standard")).split("\n");
       return [...tracked, ...untracked].map((path) => path.trim()).filter(Boolean);
     }));
-    return [...new Set(changed.flat())].slice(0, 5000);
-  } catch {
+    return [...new Set(changed.flat())];
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return null;
   }
 }

package/dist/managed-hooks.js

@@ -135,7 +135,12 @@ export async function dispatchManagedHook(event, payloadText, deps = {}) {
     }
     const structured = messages.map((message) => message.hookSpecificOutput?.additionalContext).filter(Boolean);
     const plain = successful.map((result) => responseOf(result.stdout) ? "" : result.stdout.trim()).filter(Boolean);
-    if (["Stop", "SubagentStop"].includes(event)) return "{}\n";
+    // A Stop nudge asks the session to continue once; any other Stop output is dropped.
+    if (event === "Stop") {
+      const block = messages.find((message) => message.decision === "block" && typeof message.reason === "string");
+      return block ? `${JSON.stringify({ decision: "block", reason: block.reason })}\n` : "{}\n";
+    }
+    if (event === "SubagentStop") return "{}\n";
     return [...structured, ...plain].join("\n") + ([...structured, ...plain].length ? "\n" : "");
   } catch {
     return emptyResponse(event);

package/dist/nodii-dev.js

@@ -1,14 +1,24 @@
 #!/usr/bin/env node
 import { fail, main } from "./cli.js";
+import { regroundCurrentLane, shouldReground } from "./freeze.js";
 
 // Hooks run in the agent's environment, which may be incomplete or may not be
 // a git worktree. An unavailable hook must never turn into a refused tool call.
 // Intentional policy denials are handled inside the hook command before they
 // reach this boundary.
-main().catch((error) => {
+const argv = process.argv.slice(2);
+
+async function run() {
+  // AGENT-HARNESS-19: this is the executable boundary, so every ordinary CLI
+  // invocation re-grounds without adding hidden requests to library callers.
+  if (shouldReground(argv)) await regroundCurrentLane();
+  await main(argv);
+}
+
+run().catch((error) => {
   const denial = String(error?.code ?? "").startsWith("SAFETY_") ||
     ["FIGMA_FILE_KEY_MISSING", "FIGMA_LOCK_DENIED", "WRITE_OUT_OF_SCOPE"].includes(error?.code);
-  if (process.argv[2] === "hook" && !denial) {
+  if (argv[0] === "hook" && !denial) {
     process.exitCode = 0;
     return;
   }