yadflow 3.4.1 → 3.4.2

package/CHANGELOG.md

@@ -1,4 +1,10 @@
-## [3.4.1](https://github.com/abdelrahmannasr/yadflow/compare/v3.4.0...v3.4.1) (2026-07-01)
+## [3.4.2](https://github.com/abdelrahmannasr/yadflow/compare/v3.4.1...v3.4.2) (2026-07-01)
+
+
+### Bug Fixes
+
+* **doctor:** warn YAD-CFG-005 on hub.json missing git_url; stop misleading YAD-ENV-002 ([3f588af](https://github.com/abdelrahmannasr/yadflow/commit/3f588af2e01e117e661b08b5f5b8e069e41e887f))
+* **setup:** write and backfill hub.json git_url from the origin remote ([c809358](https://github.com/abdelrahmannasr/yadflow/commit/c8093581319dcb9700b3dd0ebe930dbf784348ff))
 
 # [2.2.0](https://github.com/abdelrahmannasr/yadflow/compare/v2.1.0...v2.2.0) (2026-06-14)
 

package/cli/doctor.mjs

@@ -76,13 +76,25 @@ export function projectChecks(checks, root) {
       // platform CLI + auth (best-effort; auth probing is the user's own session)
       const cli = cliFor(hub.platform);
       if (cli) {
-        // Scope the auth probe to the hub's own host (derived from git_url). `${cli} auth status`
-        // without --hostname exits non-zero when ANY configured instance fails, so an unrelated
-        // stale login (e.g. a dead gitlab.com token) would falsely flag a working self-hosted hub.
-        const host = hostFromGitUrl(hub.git_url);
-        const authArgs = host ? ['auth', 'status', '--hostname', host] : ['auth', 'status'];
+        // git_url is required whenever a platform is set — doctor needs it to scope the auth probe
+        // and the bridge/PR flow needs it to open PRs. Warn on its absence directly (not on the
+        // resolved host), so it fires even when an origin remote can substitute: the field itself
+        // is required regardless.
+        if (!hostFromGitUrl(hub.git_url)) {
+          check(checks, 'hub-git-url', 'project', 'warn',
+            `${PROJECT_FILES.hubConfig} sets platform '${hub.platform}' but has no git_url [YAD-CFG-005]`,
+            'add git_url to hub.json (or re-run `yad setup`) — auth/PR checks need the hub host');
+        }
+        // Scope the auth probe to the hub's own host (derived from git_url, falling back to the
+        // origin remote). `${cli} auth status` without --hostname exits non-zero when ANY configured
+        // instance fails, so an unrelated stale login (e.g. a dead gitlab.com token) would falsely
+        // flag a working self-hosted hub — so we SKIP the probe entirely when no host resolves
+        // rather than run the flaky unscoped form.
+        const host = hostFromGitUrl(hub.git_url)
+          || hostFromGitUrl(run('git', ['remote', 'get-url', 'origin'], { cwd: root }).stdout);
         if (!has(cli)) check(checks, 'platform-cli', 'project', 'warn', `${cli} not found on PATH [YAD-ENV-002]`, `install ${cli} — the gate degrades to file-only without it`);
-        else if (!run(cli, authArgs).ok) check(checks, 'platform-cli', 'project', 'warn', `${cli} present but not authenticated${host ? ` for ${host}` : ''} [YAD-ENV-002]`, `run \`${cli} auth login${host ? ` --hostname ${host}` : ''}\``);
+        else if (!host) check(checks, 'platform-cli', 'project', 'warn', 'auth check skipped — hub host unknown (no git_url / origin)', 'add git_url to hub.json so the auth probe can target the right host');
+        else if (!run(cli, ['auth', 'status', '--hostname', host]).ok) check(checks, 'platform-cli', 'project', 'warn', `${cli} present but not authenticated for ${host} [YAD-ENV-002]`, `run \`${cli} auth login --hostname ${host}\``);
         else {
           check(checks, 'platform-cli', 'project', 'ok', `${cli} present and authenticated`);
           // Re-validate each roster login against the hub (warn-only). Skips when a login is already
@@ -99,10 +111,10 @@ export function projectChecks(checks, root) {
           // probe a cheap api call (warn-only) to surface it before a sync silently holds the gate.
           if (hub.platform === 'gitlab') {
             // Scope the probe to the hub's own host (like the auth check above) so a multi-instance
-            // setup doesn't hit the wrong GitLab and emit a misleading warning.
-            const apiArgs = host ? ['api', 'version', '--hostname', host] : ['api', 'version'];
-            if (!run('glab', apiArgs).ok) {
-              check(checks, 'gitlab-api', 'project', 'warn', `glab is authenticated but \`glab api\` failed${host ? ` for ${host}` : ''} [YAD-ENV-002]`, 'ensure the token has `api` scope — the gate reads MR approvals/discussions via the API');
+            // setup doesn't hit the wrong GitLab. `host` is guaranteed truthy here (we skip the whole
+            // auth branch when it cannot be resolved), so the probe is always host-scoped.
+            if (!run('glab', ['api', 'version', '--hostname', host]).ok) {
+              check(checks, 'gitlab-api', 'project', 'warn', `glab is authenticated but \`glab api\` failed for ${host} [YAD-ENV-002]`, 'ensure the token has `api` scope — the gate reads MR approvals/discussions via the API');
             }
           }
           // Solo + GitHub: a branch that "requires approvals" would block the solo dev's own merge

package/cli/errors.mjs

@@ -23,6 +23,7 @@ export const CODES = {
   'YAD-CFG-002': 'design.json names an unknown design tool (expected one of config.yaml design.tools, or none)',
   'YAD-CFG-003': 'testing.json names an unknown testing tool (expected one of config.yaml testing.tools, or none)',
   'YAD-CFG-004': 'learning.json names an unknown learning tool (expected one of config.yaml learning.tools, or none)',
+  'YAD-CFG-005': 'hub.json sets a platform but is missing git_url (required to scope auth + open PRs)',
 };
 
 export const err = (code, message, hint) => new YadError(code, message, hint);

package/cli/setup.mjs

@@ -482,16 +482,24 @@ export async function runSetup(root, opts = {}) {
     // `bridge_enabled` is the canonical flag (hub-config schema); keep the legacy `bridge` spelling
     // for anything that still reads it.
     const enabled = platform !== 'none';
-    writeJSON(hubPath, { platform: enabled ? platform : null, bridge_enabled: enabled, bridge: enabled, default_branch, roster, solo, profile: { codebase, repo_layout, team_size } });
+    // Record git_url — doctor needs it to scope the auth probe (YAD-CFG-005) and the bridge/PR flow
+    // needs it to open PRs. Derived from the origin remote already resolved above; null when local-only.
+    const git_url = enabled ? ((remote.ok && remote.stdout.trim()) || null) : null;
+    writeJSON(hubPath, { platform: enabled ? platform : null, git_url, bridge_enabled: enabled, bridge: enabled, default_branch, roster, solo, profile: { codebase, repo_layout, team_size } });
     ok(`wrote ${PROJECT_FILES.hubConfig} (${roster.length} reviewer(s)${solo ? ', solo mode' : ''})`);
   }
   // Persist the profile + solo flag even on the "keeping existing" path, so re-running setup with new
   // flags (e.g. `yad setup --solo`) updates the mode without a full reconfigure. Merge, never clobber.
+  // Also backfill a missing git_url from origin here (idempotent repair for the doctor's YAD-CFG-005).
   if (exists(hubPath)) {
     const cur = readJSON(hubPath, {}) || {};
-    if (cur.solo !== solo || JSON.stringify(cur.profile || {}) !== JSON.stringify({ codebase, repo_layout, team_size })) {
-      writeJSON(hubPath, { ...cur, solo, profile: { codebase, repo_layout, team_size } });
-      info(`recorded profile: ${solo ? 'solo' : `team(${team_size})`}, ${codebase}, ${repo_layout}`);
+    const backfillUrl = (cur.platform && !cur.git_url)
+      ? ((run('git', ['remote', 'get-url', 'origin'], { cwd: root }).stdout || '').trim() || null)
+      : null;
+    if (cur.solo !== solo || JSON.stringify(cur.profile || {}) !== JSON.stringify({ codebase, repo_layout, team_size }) || backfillUrl) {
+      writeJSON(hubPath, { ...cur, ...(backfillUrl ? { git_url: backfillUrl } : {}), solo, profile: { codebase, repo_layout, team_size } });
+      if (backfillUrl) info(`backfilled hub git_url from origin: ${backfillUrl}`);
+      else info(`recorded profile: ${solo ? 'solo' : `team(${team_size})`}, ${codebase}, ${repo_layout}`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yadflow",
-  "version": "3.4.1",
+  "version": "3.4.2",
   "description": "Yadflow — the gated, team, multi-repo SDLC: author → review → build with a PR-driven review gate and a zero-dependency `yad` CLI (setup, gate, commit, open-pr, ship, repo, thread, reconcile). A BMAD module + 37 yad-* skills.",
   "type": "module",
   "author": "AbdelRahman Nasr",

package/skills/yad-connect-repos/references/hub-config.md

@@ -16,7 +16,7 @@ login to an SDLC name + role. It is a single object for the hub itself — the s
 ```json
 {
   "platform": "github",                                       // github | gitlab (from the hub's own remote host); null when local-only
-  "git_url": "https://github.com/abdelrahmannasr/yadflow.git",
+  "git_url": "https://github.com/abdelrahmannasr/yadflow.git", // REQUIRED when platform is non-null (scopes auth + opens PRs); yad doctor warns YAD-CFG-005 if absent
   "default_branch": "main",
   "bridge_enabled": true,                                     // open review PRs/MRs on the hub for front-half reviews
   "review": { "requireEngagement": false },                   // Review Companion: false (soft) counts bare approves but nudges; true counts only verified-engagement approvals
@@ -69,6 +69,11 @@ run `git remote get-url origin` **on the hub itself** and read the host —
 Auth is the **local user's own** `gh`/`glab`/git credentials; **no tokens are ever stored** (same rule
 as the registry). `detect-hub` upserts `hub.json` in place — it is idempotent and safe to re-run.
 
+**`git_url` is required whenever `platform` is non-null.** `yad doctor` uses it to scope the auth
+probe to the hub's own host (an unscoped `glab auth status` fails on any unrelated broken instance),
+and the bridge/PR flow uses it to open PRs. Doctor flags its absence with a warn (`YAD-CFG-005`);
+re-running `yad setup` backfills it from the origin remote (idempotent, non-interactive).
+
 ## Bridge enable / degradation
 
 - `bridge_enabled: true` **and** a non-null `platform` **and** `gh`/`glab` authenticated → the front-half