session-orchestrator 3.21.0 → 3.22.0

package/scripts/lib/vcs-repo-spec.mjs

@@ -227,17 +227,56 @@ const WRONG_FAMILY_HOST = {
   github: 'gitlab.com',
 };
 
+/** URI schemes that can name a supported Git remote. */
+const REMOTE_URI_PROTOCOLS = new Set(['http:', 'https:', 'ssh:']);
+
 /**
- * Extract the bare hostname from a git remote URL, handling both the HTTPS
- * (`https://host/owner/repo.git`) and SSH (`git@host:owner/repo.git`) forms.
- * Returns `null` for an unrecognized shape (never throws).
+ * Parse a URI-style remote only when it uses one of this module's supported
+ * protocols. The `URL` parser makes hostname/port handling consistent between
+ * HTTP(S) and URI-style SSH while scp-style SSH stays a separate grammar.
+ *
+ * @param {string} url
+ * @returns {URL|null}
+ */
+function parseRemoteUri(url) {
+  if (typeof url !== 'string' || !/^(?:https?|ssh):\/\//i.test(url)) return null;
+  try {
+    const parsed = new URL(url);
+    return REMOTE_URI_PROTOCOLS.has(parsed.protocol) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the operational host from a git remote URL, handling HTTPS
+ * (`https://host/owner/repo.git`), scp-style SSH (`git@host:owner/repo.git`),
+ * and URI-style SSH (`ssh://git@host/owner/repo.git`) forms. A non-default
+ * URI port is preserved because callers may need it to address a self-hosted
+ * instance. Returns `null` for an unrecognized shape (never throws).
  *
  * @param {string} url
  * @returns {string|null}
  */
 function extractHost(url) {
-  const httpsMatch = /^https?:\/\/([^/]+)/i.exec(url);
-  if (httpsMatch) return httpsMatch[1].toLowerCase();
+  const parsed = parseRemoteUri(url);
+  if (parsed !== null) return parsed.host.toLowerCase() || null;
+  const sshMatch = /^[^@\s]+@([^:\s]+):/i.exec(url);
+  if (sshMatch) return sshMatch[1].toLowerCase();
+  return null;
+}
+
+/**
+ * Extract a bare hostname for VCS-family comparisons. This deliberately drops
+ * a URI port: `github.com:443` is still the public GitHub host, while the
+ * operational `extractHost()` value retains a non-default self-hosted port.
+ *
+ * @param {string} url
+ * @returns {string|null}
+ */
+function extractHostname(url) {
+  const parsed = parseRemoteUri(url);
+  if (parsed !== null) return parsed.hostname.toLowerCase() || null;
   const sshMatch = /^[^@\s]+@([^:\s]+):/i.exec(url);
   if (sshMatch) return sshMatch[1].toLowerCase();
   return null;
@@ -367,12 +406,12 @@ export function resolveRepoSpec({ repoRoot, vcs = 'gitlab', gitRun = defaultGitR
 }
 
 /**
- * Resolve the bare hostname of the matching remote, for use with
- * `glab api --hostname`/`gh api --hostname` — the `api` subcommand of both
- * CLIs does NOT accept `-R`/`--repo` (it has no repo concept), only a
- * `--hostname` flag to pin which instance the request targets. This is the
- * host-pinning counterpart to `resolveRepoSpec` for those api-only call
- * sites.
+ * Resolve the operational host of the matching remote, preserving a
+ * non-default self-hosted port for `glab api --hostname`/`gh api --hostname`.
+ * The `api` subcommand of both CLIs does NOT accept `-R`/`--repo` (it has no
+ * repo concept), only `--hostname` to pin which instance the request targets.
+ * This is the host-pinning counterpart to `resolveRepoSpec` for those api-only
+ * call sites.
  *
  * Applies the identical remote-preference-order + cross-family-guard
  * resolution as `resolveRepoSpec`, just returning the host instead of the
@@ -393,6 +432,136 @@ export function resolveRepoHost({ repoRoot, vcs, gitRun } = {}) {
   return isUnsafeForArgv(host) ? undefined : host;
 }
 
+/** Project-path characters that cannot name a GitLab namespace/project. */
+// eslint-disable-next-line no-control-regex -- validate every C0/C1 control before encoding a GitLab API path
+const UNSAFE_PROJECT_PATH_CHARS_RE = /[\\\x00-\x1f\x7f-\x9f?#]/;
+
+/**
+ * Decode a transport project path exactly once, then validate its canonical
+ * namespace/project shape. A percent sign surviving the one decode is rejected
+ * because `%252e%252e` is indistinguishable from a literal encoded escape; do
+ * not normalize that ambiguity into an API target.
+ *
+ * @param {string} rawProjectPath
+ * @param {{ uriPath: boolean }} opts
+ * @returns {string|undefined}
+ */
+function normalizeGitlabProjectPath(rawProjectPath, { uriPath }) {
+  if (typeof rawProjectPath !== 'string') return undefined;
+
+  let projectPath = rawProjectPath;
+  if (uriPath) {
+    // URI syntax supplies one separator before the path. More than one is a
+    // path segment, not syntax to trim away.
+    if (!projectPath.startsWith('/') || projectPath.startsWith('//')) return undefined;
+    projectPath = projectPath.slice(1);
+  }
+
+  if (
+    projectPath === '' ||
+    projectPath.startsWith('/') ||
+    projectPath.endsWith('/') ||
+    UNSAFE_PROJECT_PATH_CHARS_RE.test(projectPath)
+  ) {
+    return undefined;
+  }
+
+  let decodedProjectPath;
+  try {
+    decodedProjectPath = decodeURIComponent(projectPath);
+  } catch {
+    return undefined;
+  }
+
+  if (
+    decodedProjectPath.includes('%') ||
+    UNSAFE_PROJECT_PATH_CHARS_RE.test(decodedProjectPath) ||
+    isUnsafeForArgv(decodedProjectPath)
+  ) {
+    return undefined;
+  }
+
+  const withoutGitSuffix = decodedProjectPath.replace(/\.git$/i, '');
+  const segments = withoutGitSuffix.split('/');
+  if (
+    withoutGitSuffix === '' ||
+    withoutGitSuffix.startsWith('/') ||
+    withoutGitSuffix.endsWith('/') ||
+    segments.length < 2 ||
+    segments.some((segment) => segment === '' || segment === '.' || segment === '..')
+  ) {
+    return undefined;
+  }
+
+  return withoutGitSuffix;
+}
+
+/**
+ * Extract an operational GitLab host and the raw (not URL-normalized) project
+ * path. URI parsing owns authority/port validation, while the raw path keeps
+ * dot and percent-encoded traversal visible to {@link normalizeGitlabProjectPath}
+ * before WHATWG URL normalization could erase it.
+ *
+ * @param {string} url
+ * @returns {{ host: string, rawProjectPath: string, uriPath: boolean }|undefined}
+ */
+function extractGitlabProjectTargetParts(url) {
+  const scpMatch = /^[^@/\s]+@([^:/\s]+):(.+)$/.exec(url);
+  if (scpMatch) {
+    return { host: scpMatch[1], rawProjectPath: scpMatch[2], uriPath: false };
+  }
+
+  const parsed = parseRemoteUri(url);
+  if (
+    parsed === null ||
+    parsed.search !== '' ||
+    parsed.hash !== '' ||
+    ((parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      (parsed.username !== '' || parsed.password !== ''))
+  ) {
+    return undefined;
+  }
+
+  // `parsed.pathname` is intentionally NOT used: the URL parser resolves
+  // `.`/`..` before this boundary can reject them. The regex reads only the
+  // path from an already-parsed, supported URI.
+  const rawPathMatch = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*(\/[^?#]*)?(?:[?#].*)?$/i.exec(url);
+  if (rawPathMatch === null) return undefined;
+  return { host: parsed.host, rawProjectPath: rawPathMatch[1] ?? '', uriPath: true };
+}
+
+/**
+ * Derive the API target for a GitLab project from the same sanitized,
+ * preference-selected remote that powers {@link resolveRepoSpec}. GitLab's REST
+ * API takes a URL-encoded `namespace/project` path rather than a remote URL or
+ * numeric project ID, so this projection removes the ambient project-metadata
+ * lookup from callers that need to pin both project and host.
+ *
+ * Supports HTTPS, scp-style SSH, and `ssh://` remotes. Credential stripping
+ * happens upstream in {@link listRemotes}; this helper returns only an
+ * operational host (including a non-default self-hosted port) and a once-only
+ * encoded project path, never a remote URL or HTTP userinfo. An SSH login such
+ * as `git@host` is transport identity, not project-path userinfo.
+ *
+ * @param {{ repoRoot?: string, gitRun?: GitRun }} [opts]
+ * @returns {{ host: string, encodedProjectPath: string }|undefined}
+ */
+export function resolveGitlabProjectTarget({ repoRoot, gitRun = defaultGitRun } = {}) {
+  const url = resolveRawRemoteUrl({ repoRoot, vcs: 'gitlab', gitRun });
+  if (!url) return undefined;
+
+  const parts = extractGitlabProjectTargetParts(url);
+  if (!parts || isUnsafeForArgv(parts.host)) return undefined;
+
+  const projectPath = normalizeGitlabProjectPath(parts.rawProjectPath, { uriPath: parts.uriPath });
+  if (!projectPath) return undefined;
+
+  return {
+    host: parts.host.toLowerCase(),
+    encodedProjectPath: encodeURIComponent(projectPath),
+  };
+}
+
 /**
  * @deprecated Back-compat alias for `archive-closed-prds.mjs`'s original
  * `defaultGlabRepo(repoRoot, gitRunFn)` positional signature (gitlab-only).
@@ -636,7 +805,7 @@ export function resolvePreferredRemote({ repoRoot, vcs, gitRun = defaultGitRun }
   const vcsPinned = vcs === 'github' || vcs === 'gitlab' ? vcs : null;
   const order = vcsPinned ? REMOTE_PREFERENCE[vcsPinned] : VCS_LESS_PREFERENCE;
   const wrongFamilyHost = vcsPinned ? WRONG_FAMILY_HOST[vcsPinned] : null;
-  const isWrongFamily = (url) => wrongFamilyHost !== null && extractHost(url) === wrongFamilyHost;
+  const isWrongFamily = (url) => wrongFamilyHost !== null && extractHostname(url) === wrongFamilyHost;
 
   /** @param {GitRemote} remote @param {'preference'|'sole-remote'} via */
   const accept = (remote, via) =>
@@ -670,7 +839,7 @@ export function resolvePreferredRemote({ repoRoot, vcs, gitRun = defaultGitRun }
  * @returns {{ family: 'gitlab'|'github', via: 'host-match'|'remote-name' }|null}
  */
 function classifyRemoteFamily(remote) {
-  const host = extractHost(remote.url);
+  const host = extractHostname(remote.url);
   if (host !== null) {
     if (host === 'github.com' || host.startsWith('github.')) return { family: 'github', via: 'host-match' };
     if (host === 'gitlab.com' || host.startsWith('gitlab.')) return { family: 'gitlab', via: 'host-match' };

package/scripts/lib/wave-resource-gate.mjs

@@ -7,7 +7,7 @@
  * Part of v3.1.0 Epic #157, Sub-Epic resource-gate. Issue #193.
  */
 
-import { probe } from './resource-probe.mjs';
+import { probe, evaluate } from './resource-probe.mjs';
 
 // ---------------------------------------------------------------------------
 // Public API
@@ -30,10 +30,23 @@ async function extractMeasurements(opts) {
       ramFreeGb: probeOverride.ramFreeGb,
       // Tests may supply ramAvailableGb to exercise the macOS path; absent → null.
       ramAvailableGb: probeOverride.ramAvailableGb ?? null,
+      // macOS memory_pressure — the highest-precedence memory signal (#1089).
+      memoryPressurePctFree: probeOverride.memoryPressurePctFree ?? null,
       cpuLoadPct: probeOverride.cpuLoadPct,
       // 5m-average CPU pct (#943); absent → null (legacy overrides → 1m-only judging).
       cpuLoad5mPct: probeOverride.cpuLoad5mPct ?? null,
+      // #1089: live peer SESSIONS from the registry — the unit
+      // `concurrent-sessions-warn` is named for. Absent → null, and the
+      // rescaled process-count fallback applies.
+      peerSessions: probeOverride.peerSessions ?? null,
+      // Raw Claude PROCESS count. Historically (and misleadingly) named
+      // `concurrentSessions` on this override object; kept as an accepted alias
+      // so existing callers keep working, but it is compared against a
+      // process-denominated threshold now, never a session-denominated one.
+      claudeProcesses: probeOverride.claudeProcesses ?? probeOverride.concurrentSessions ?? null,
       concurrentSessions: probeOverride.concurrentSessions,
+      swapUsedMb: probeOverride.swapUsedMb ?? null,
+      zombieProcesses: probeOverride.zombieProcesses ?? null,
     };
   }
 
@@ -48,12 +61,22 @@ async function extractMeasurements(opts) {
     // macOS: free + reclaimable (vm_stat). null on Linux/Windows where
     // os.freemem() is already accurate. (#667)
     ramAvailableGb: snapshot.ram_available_gb ?? null,
+    // macOS memory_pressure — outranks both of the above (#1089).
+    memoryPressurePctFree: snapshot.memory_pressure_pct_free ?? null,
     cpuLoadPct: snapshot.cpu_load_pct,
     // 5m load-average as pct-of-cores (#943). null on Windows/zero-load, where
     // the gate falls back to judging the 1m-derived cpu_load_pct alone.
     cpuLoad5mPct: snapshot.cpu_load_5m_pct ?? null,
-    // concurrent sessions: number of claude processes found by the probe.
+    // #1089: live peer SESSIONS (registry, self excluded) — what
+    // `concurrent-sessions-warn` was always named for. This line used to read
+    // `concurrentSessions: snapshot.claude_processes_count`, a measured 6x unit
+    // error that made the gate reduce waves on essentially every dispatch.
+    peerSessions: snapshot.peer_sessions_count ?? null,
+    claudeProcesses: snapshot.claude_processes_count ?? null,
+    // Retained for the returned `measurements` object, which callers log.
     concurrentSessions: snapshot.claude_processes_count ?? 0,
+    swapUsedMb: snapshot.swap_used_mb ?? null,
+    zombieProcesses: snapshot.zombie_processes_count ?? null,
   };
 }
 
@@ -131,29 +154,32 @@ function applyHeavyRepoCap(result, opts) {
 }
 
 /**
- * Rules 3-8: resource-driven decision sequence (RAM/CPU/concurrent-sessions).
- * Extracted so `applyDecisionRules` can layer the HR-004 heavy-repo cap on
- * top without duplicating this sequence.
+ * Resource-driven decision, delegated to `evaluate()` (#1089).
  *
- * @param {{ramFreeGb: number, ramAvailableGb?: number|null, cpuLoadPct: number, cpuLoad5mPct?: number|null, concurrentSessions: number}} measurements
+ * This function used to carry its OWN copy of the RAM/CPU/concurrency rules,
+ * running in sequence with first-match-wins. That duplication is exactly why
+ * the #667 available-RAM correction only ever landed halfway: it was applied
+ * here and in `evaluate()` separately, and the memory_pressure precedence that
+ * followed reached only one of the two. There is now one rule engine and this
+ * is a translation layer over it.
+ *
+ * Verdict → decision mapping:
+ *   critical (hard signal)      → coordinator-direct, 0 agents
+ *   warn     (2+ soft signals)  → reduce, plannedAgents / 2 (floor 1)
+ *   green    (0-1 soft signals) → proceed at plannedAgents, reasons retained
+ *
+ * The halving on `warn` is this gate's own policy and deliberately differs
+ * from `evaluate()`'s flat cap of 2: the gate knows `plannedAgents` (a wave of
+ * 3 should not be "capped" UP to nothing), `evaluate()` does not.
+ *
+ * @param {object} measurements — from extractMeasurements
  * @param {object} opts - Same opts shape as evaluateWaveResourceGate
  * @returns {{decision: string, agents: number, reasons: string[], measurements: object}}
  */
 function computeResourceDecision(measurements, opts) {
   const { config, plannedAgents } = opts;
-  const { ramFreeGb, ramAvailableGb, cpuLoadPct, cpuLoad5mPct, concurrentSessions } = measurements;
   const T = config['resource-thresholds'];
 
-  // macOS fix (#667): os.freemem() reports only `Pages free`, which reads
-  // sub-1 GB even on a 128 GB host with 80+ GB reclaimable cache — a false
-  // RAM-critical that forced spurious coordinator-direct fallbacks. When the
-  // probe supplied a numeric `ramAvailableGb` (free + reclaimable, via vm_stat),
-  // judge RAM thresholds on AVAILABLE; otherwise fall back to FREE (Linux/Win,
-  // where os.freemem() is already accurate).
-  const hasAvailable = ramAvailableGb !== null && ramAvailableGb !== undefined;
-  const effectiveRamGb = hasAvailable ? ramAvailableGb : ramFreeGb;
-  const ramLabel = hasAvailable ? 'RAM available' : 'RAM free';
-
   // Rule 3: resource-thresholds missing → degrade to proceed (defensive).
   // Handles legacy pre-#166 configs and test fixtures that omit the key.
   // The gate is considered "ran" — caller receives measurements but no enforcement.
@@ -166,77 +192,45 @@ function computeResourceDecision(measurements, opts) {
     };
   }
 
-  // Rule 4: RAM below critical → coordinator-direct.
-  if (effectiveRamGb < T['ram-free-critical-gb']) {
+  // Translate the gate's measurement shape into a probe-shaped snapshot so the
+  // single rule engine can judge it. Field names differ because the override
+  // object is a documented public test seam that predates the snapshot shape.
+  const snapshot = {
+    ram_free_gb: measurements.ramFreeGb,
+    ram_available_gb: measurements.ramAvailableGb ?? null,
+    memory_pressure_pct_free: measurements.memoryPressurePctFree ?? null,
+    cpu_load_pct: measurements.cpuLoadPct,
+    cpu_load_5m_pct: measurements.cpuLoad5mPct ?? null,
+    peer_sessions_count: measurements.peerSessions ?? null,
+    claude_processes_count: measurements.claudeProcesses ?? null,
+    swap_used_mb: measurements.swapUsedMb ?? null,
+    zombie_processes_count: measurements.zombieProcesses ?? null,
+  };
+
+  // heavyRepo is applied by applyHeavyRepoCap() on the way out, so it is
+  // deliberately NOT passed here — passing it would apply the ceiling twice.
+  const verdict = evaluate(snapshot, T);
+
+  if (verdict.verdict === 'critical') {
     return {
       decision: 'coordinator-direct',
       agents: 0,
-      reasons: [
-        `${ramLabel} ${effectiveRamGb}GB < critical ${T['ram-free-critical-gb']}GB — escalating to coordinator-direct`,
-      ],
-      measurements,
-    };
-  }
-
-  // Rule 5: RAM below min (but above critical) → reduce.
-  if (effectiveRamGb < T['ram-free-min-gb']) {
-    return {
-      decision: 'reduce',
-      agents: Math.max(1, Math.floor(plannedAgents / 2)),
-      reasons: [
-        `${ramLabel} ${effectiveRamGb}GB < min ${T['ram-free-min-gb']}GB — reducing agent count`,
-      ],
+      reasons: verdict.reasons,
       measurements,
     };
   }
-
-  // Rule 6: CPU overloaded → reduce. #943: this gate runs, by construction,
-  // right after the coordinator's own CPU-saturating quality-gate run — the 1m
-  // load average still carries that decaying tail (observed 2026-07-30:
-  // 96% → 91% → 78% → 75% within 36s), so a 1m-only reading systematically
-  // over-reports and halves waves without a real bottleneck. When the probe
-  // supplied a numeric 5m percentage, judge on min(1m, 5m): only-1m-high is a
-  // decaying transient (informational, no reduce), both-high is genuine
-  // sustained load. `cpuLoad5mPct` null (legacy overrides, Windows) → 1m-only.
-  const has5mCpu = typeof cpuLoad5mPct === 'number' && Number.isFinite(cpuLoad5mPct);
-  const effectiveCpuLoadPct = has5mCpu ? Math.min(cpuLoadPct, cpuLoad5mPct) : cpuLoadPct;
-  if (effectiveCpuLoadPct > T['cpu-load-max-pct']) {
-    const detail = has5mCpu ? ` (min of 1m ${cpuLoadPct}% / 5m ${cpuLoad5mPct}%)` : '';
+  if (verdict.verdict === 'warn') {
     return {
       decision: 'reduce',
       agents: Math.max(1, Math.floor(plannedAgents / 2)),
-      reasons: [
-        `CPU load ${effectiveCpuLoadPct}%${detail} > max ${T['cpu-load-max-pct']}% — reducing agent count`,
-      ],
-      measurements,
-    };
-  }
-  const cpuTransientNote =
-    has5mCpu && cpuLoadPct > T['cpu-load-max-pct']
-      ? `info: CPU 1m load ${cpuLoadPct}% > max ${T['cpu-load-max-pct']}% but 5m load ${cpuLoad5mPct}% is below — decaying transient (typically the coordinator's own just-finished gate run), not reducing (#943)`
-      : null;
-
-  // Rule 7: concurrent sessions above warn → proceed with warning.
-  if (concurrentSessions > T['concurrent-sessions-warn']) {
-    return {
-      decision: 'proceed',
-      agents: plannedAgents,
-      reasons: [
-        ...(cpuTransientNote ? [cpuTransientNote] : []),
-        `warn: ${concurrentSessions} concurrent sessions`,
-      ],
+      reasons: verdict.reasons,
       measurements,
     };
   }
-
-  // Rule 8: all within bounds.
   return {
     decision: 'proceed',
     agents: plannedAgents,
-    reasons: [
-      ...(cpuTransientNote ? [cpuTransientNote] : []),
-      'all thresholds within bounds',
-    ],
+    reasons: verdict.reasons.length > 0 ? verdict.reasons : ['all thresholds within bounds'],
     measurements,
   };
 }