forgedock 1.1.8 → 1.1.10

package/bin/hooks/session-start.mjs

@@ -63,6 +63,16 @@ let markNudgeSeen;
 let parseForgeYaml;
 let sanitizeContextValue;
 
+// ---------------------------------------------------------------------------
+// init-detect helpers — populated inside the try block to honour fail-open
+// ---------------------------------------------------------------------------
+
+// Declared at module scope so it is accessible from handler functions
+// (handleUnmanaged) called from within the try block. Assigned inside the
+// try/catch so that any import failure (missing file, permissions error,
+// syntax error) is caught and the hook still exits 0. <!-- fix: forge#1927 -->
+let resolveGitRoot;
+
 // ---------------------------------------------------------------------------
 // Main — wrapped in try/catch to guarantee fail-open
 // ---------------------------------------------------------------------------
@@ -98,6 +108,21 @@ try {
     )
   );
 
+  // Import the git-root resolver from the same installation.
+  // Placed inside try/catch to honour the fail-open contract: if init-detect.mjs
+  // cannot be loaded (broken install, missing file, permissions error) the
+  // catch block below ensures we still exit 0 without blocking Claude Code.
+  //
+  // Use pathToFileURL() to convert the OS-native path to a file:// URL before
+  // passing it to dynamic import(). On Windows, join() produces backslash paths
+  // that import() rejects with ERR_UNSUPPORTED_ESM_URL_SCHEME.
+  /** @type {import('../init-detect.mjs')} */
+  (
+    { resolveGitRoot } = await import(
+      pathToFileURL(join(FORGE_HOME, "bin", "init-detect.mjs")).href
+    )
+  );
+
   const cwd = process.cwd();
   const state = resolveState(cwd);
 
@@ -165,19 +190,32 @@ async function handleManagedActive(dir) {
  * Uses the registry to ensure the nudge fires at most once per directory.
  * After showing, records the directory so subsequent sessions are silent.
  *
+ * The nudge-tracking key is the *resolved git root*, not the raw `dir` — a
+ * user who launches Claude Code from a parent directory that merely contains
+ * the real git repo as its single subdirectory (e.g. `Projects/` containing
+ * `Projects/my-app/.git`) would otherwise have every sibling project under
+ * that same parent share one nudge-seen entry: the first project to trigger
+ * the nudge silently suppresses it for all the others. `resolveGitRoot`
+ * degrades gracefully (falls back to the unresolved `dir`) when the case
+ * doesn't apply, so this is safe to call unconditionally. <!-- fix: forge#1927 -->
+ *
  * @param {string} dir - Absolute path to the project directory.
  */
 async function handleUnmanaged(dir) {
-  if (nudgeSeen(dir)) {
+  const trackingKey = resolveGitRoot(dir).root;
+
+  if (nudgeSeen(trackingKey)) {
     // Nudge already shown — stay silent
     return;
   }
 
-  // Show the nudge, then record it so it won't show again
+  // Show the nudge, then record it so it won't show again. The displayed
+  // message still shows the raw `dir` the user is actually in — only the
+  // tracking key changes.
   console.log(buildNudgeContext(dir));
 
   // Best-effort — if this fails the nudge may show once more next session
-  await markNudgeSeen(dir).catch(() => {});
+  await markNudgeSeen(trackingKey).catch(() => {});
 }
 
 // ---------------------------------------------------------------------------
@@ -223,12 +261,39 @@ function buildActiveContext(dir, forgeYaml) {
     200,
   );
 
+  // Default agent model — resolved from forge.yaml's optional
+  // `agents.default_model` field, falling back to "sonnet" (the hardcoded
+  // default every command spec's "Agent model policy" line already uses).
+  // Rendered unconditionally, like stagingBranch/featurePattern above, so
+  // command specs always have a concrete value to reference — not a
+  // conditional *Note line like milestoneNote, which is omitted when unset.
+  const defaultModel = sanitizeContextValue(
+    forgeYaml.agents?.default_model ?? "sonnet",
+    100,
+  ) ?? "sonnet";
+
+  // Sub-agent model — resolved from forge.yaml's optional
+  // `agents.subagent_model` field. Governs child agents that a top-level
+  // command spawns internally (e.g. /orchestrate's per-issue /work-on
+  // agents, /review-pr's domain persona reviewers), which is a distinct
+  // hardcoded call-site from the top-level "Agent model policy" banner that
+  // `defaultModel` above already covers. Falls back to `defaultModel` (not
+  // directly to "sonnet") so a project that only sets `default_model` gets
+  // consistent behavior across both the main agent and its children.
+  // Rendered unconditionally, same as defaultModel above. <!-- issue #1852 -->
+  const subagentModel = sanitizeContextValue(
+    forgeYaml.agents?.subagent_model ?? defaultModel,
+    100,
+  ) ?? defaultModel;
+
   return `\
 <!-- ForgeDock: managed-active -->
 **ForgeDock** is active in this directory (${safeDir}).
 ${nameNote}${repoNote}${descNote}${milestoneNote}
 - **Staging branch**: \`${stagingBranch}\`
 - **Feature branch pattern**: \`${featurePattern}\`
+- **Default agent model**: \`${defaultModel}\`
+- **Sub-agent model**: \`${subagentModel}\`
 
 ### Available pipeline commands
 

package/bin/init-detect.mjs

@@ -2,7 +2,11 @@
 /**
  * init-detect.mjs — Pure deterministic config detection for ForgeDock.
  *
- * Exports a single function: detectConfig(cwd)
+ * Exports:
+ *   detectConfig(cwd)   → Promise<ConfigDraft>  (main deterministic detector)
+ *   resolveGitRoot(cwd) → { root, resolved, why }  (git-root resolution,
+ *                          reused outside this module by session-start.mjs's
+ *                          nudge-tracking path — see forge#1927)
  *
  * Returns a ConfigDraft: a structured object mirroring forge.yaml's required
  * sections (project, paths, branches) where every leaf is:
@@ -21,7 +25,8 @@
  */
 
 import { execFileSync } from "child_process";
-import { join } from "path";
+import { join, resolve } from "path";
+import { readdirSync, existsSync } from "fs";
 
 // ---------------------------------------------------------------------------
 // Field factory helpers
@@ -228,13 +233,88 @@ function detectStagingBranch(cwd, defaultBranch) {
     // git not available or no remotes
   }
 
-  return medium(
+  // No 'origin/staging' found. Deriving a merge target from a failed lookup
+  // is not a "likely correct" inference — it's a guess, and `staging` is the
+  // single most destructive field to get wrong (it's the fast-lane PR merge
+  // target). Flag it "low" so it gets a # TODO comment and the [low] badge
+  // instead of silently blending in as if it were verified. <!-- Added: forge#1850 -->
+  return low(
     defaultBranch,
-    "derived from default branch",
-    `No 'origin/staging' remote branch found; staging defaults to the default branch '${defaultBranch}'`,
+    "default placeholder",
+    `No 'origin/staging' remote branch found; guessed the default branch '${defaultBranch}' — verify this is actually your staging branch`,
   );
 }
 
+/**
+ * Resolve the effective git repository root for detection purposes.
+ *
+ * `execFileSync("git", ...)` already searches UPWARD through parent
+ * directories to find a repo root, so a `cwd` nested inside a repo is
+ * already handled correctly with no extra code here. The gap this closes is
+ * the other direction: `cwd` is a *parent* of the actual repo (a common
+ * monorepo-adjacent layout, e.g. `ScraperAPI/` containing the real repo at
+ * `ScraperAPI/alterlab/`) — git has no way to discover a repo by looking
+ * downward, so every detector below would otherwise degrade straight to
+ * placeholders.
+ *
+ * Never throws; falls back to the original `cwd` unchanged when neither
+ * case applies (no repo found at all, or the subdirectory scan is
+ * ambiguous — zero or multiple candidates).
+ *
+ * Exported for reuse outside `detectConfig()` — `bin/hooks/session-start.mjs`
+ * uses it to resolve the nudge-tracking key so that a directory which is a
+ * parent of the real git repo doesn't collide with sibling projects sharing
+ * the same parent. <!-- Added: forge#1927 -->
+ *
+ * @param {string} cwd
+ * @returns {{ root: string, resolved: boolean, why: string }}
+ */
+export function resolveGitRoot(cwd) {
+  // cwd is already inside a repo (possibly nested) — `--show-toplevel` finds
+  // the true root regardless of depth. Compare with path.resolve() so a pure
+  // separator-style difference (git always emits forward slashes, even on
+  // Windows) doesn't get mistaken for an actual resolution.
+  try {
+    const toplevel = execFileSync(
+      "git",
+      ["rev-parse", "--show-toplevel"],
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 },
+    ).trim();
+    if (toplevel) {
+      const resolved = resolve(toplevel) !== resolve(cwd);
+      return {
+        root: resolved ? toplevel : cwd,
+        resolved,
+        why: `'${cwd}' is nested inside a git repository rooted at '${toplevel}'`,
+      };
+    }
+  } catch {
+    // Not inside any git repository — try the subdirectory scan below.
+  }
+
+  // cwd itself isn't a repo — check whether it holds exactly one immediate
+  // subdirectory that is. Ambiguous (0 or 2+) candidates fall through
+  // unchanged, preserving the existing placeholder behavior.
+  try {
+    const entries = readdirSync(cwd, { withFileTypes: true });
+    const gitDirs = entries.filter(
+      (e) => e.isDirectory() && existsSync(join(cwd, e.name, ".git")),
+    );
+    if (gitDirs.length === 1) {
+      const sub = join(cwd, gitDirs[0].name);
+      return {
+        root: sub,
+        resolved: true,
+        why: `'${cwd}' is not a git repository, but its only subdirectory '${gitDirs[0].name}' is — resolved detection to that subdirectory`,
+      };
+    }
+  } catch {
+    // cwd unreadable — fall through to the unresolved case.
+  }
+
+  return { root: cwd, resolved: false, why: "" };
+}
+
 /**
  * Derive a human-readable project name from the repository slug.
  *
@@ -295,23 +375,32 @@ function deriveProjectName(repoSlug) {
  * @returns {Promise<ConfigDraft>}
  */
 export async function detectConfig(cwd = process.cwd()) {
+  // Resolve the effective repo root FIRST — every detector below runs
+  // against this, not the raw cwd argument. See resolveGitRoot() docblock.
+  const { root: gitRoot, resolved: rootResolved, why: rootWhy } = resolveGitRoot(cwd);
+
   // Project identity
-  const { owner, repo, remoteDetected } = detectRemote(cwd);
+  const { owner, repo, remoteDetected } = detectRemote(gitRoot);
 
   // Project name derived from the repo slug
   const name = deriveProjectName(repo.value);
 
-  // Paths — always high confidence (derived from the cwd argument)
-  const root = high(cwd, "process.cwd()", "Absolute path passed to detectConfig — the project root");
+  // Paths — high confidence in the common case (root === cwd, nothing to
+  // resolve). When detection had to redirect to a git subdirectory or a
+  // parent toplevel, flag it medium confidence with an explanatory `why` so
+  // the review screen surfaces the redirection instead of silently adopting it.
+  const root = rootResolved
+    ? medium(gitRoot, "resolved git repository root", rootWhy)
+    : high(cwd, "process.cwd()", "Absolute path passed to detectConfig — the project root");
   const worktreeBase = high(
-    join(cwd, ".claude", "worktrees"),
+    join(gitRoot, ".claude", "worktrees"),
     "derived from root",
-    `Convention: {root}/.claude/worktrees (root = ${cwd})`,
+    `Convention: {root}/.claude/worktrees (root = ${gitRoot})`,
   );
 
   // Branch detection
-  const defaultBranchField = detectDefaultBranch(cwd);
-  const stagingBranchField = detectStagingBranch(cwd, defaultBranchField.value);
+  const defaultBranchField = detectDefaultBranch(gitRoot);
+  const stagingBranchField = detectStagingBranch(gitRoot, defaultBranchField.value);
 
   return {
     project: { owner, repo, name },