changeledger 0.9.0 → 0.11.0

package/src/git.mjs

@@ -5,9 +5,58 @@
 import { execFileSync } from 'node:child_process';
 
 const SEP = String.fromCharCode(31); // ASCII unit separator — safe field delimiter
+const RECORD_SEP = String.fromCharCode(30);
 
-function defaultRun(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+// Repo-location env vars git itself exports while running a hook (e.g. this
+// project's own pre-commit). Left inherited, a child `git` call would silently
+// target the hook's repo/worktree instead of the given `cwd` — strip them so
+// every invocation stays anchored on `cwd`.
+const GIT_LOCATION_ENV_VARS = [
+  'GIT_DIR',
+  'GIT_WORK_TREE',
+  'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY',
+  'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+  'GIT_COMMON_DIR',
+  'GIT_CEILING_DIRECTORIES',
+];
+
+function sanitizedEnv() {
+  const env = { ...process.env };
+  for (const key of GIT_LOCATION_ENV_VARS) delete env[key];
+  return env;
+}
+
+// Exported so other commands (e.g. `changeledger commit`) share the same
+// GIT_* sanitization instead of re-implementing it.
+export function defaultRun(args, cwd) {
+  return execFileSync('git', args, {
+    cwd,
+    env: sanitizedEnv(),
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+}
+
+// Run variant for mutating git commands (e.g. `commit`), where git's stderr is
+// the only clue to a failure (failed hook, nothing staged, missing identity,
+// lock). Pipes stderr and, on failure, throws an Error whose message includes
+// the captured diagnostic. Query paths keep `defaultRun` and degrade silently.
+export function mutatingRun(args, cwd) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      env: sanitizedEnv(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    const detail = [e.stderr, e.stdout]
+      .map((s) => (typeof s === 'string' ? s.trim() : ''))
+      .filter(Boolean)
+      .join('\n');
+    throw new Error(detail ? `${e.message}\n${detail}` : e.message, { cause: e });
+  }
 }
 
 // Local git identity (`git config user.name`), or '' if unavailable. Tolerant.
@@ -39,6 +88,92 @@ export function ownerHandle(cwd, run = defaultRun, ghRun = defaultGhRun) {
   return githubLogin(ghRun) || gitUser(cwd, run);
 }
 
+// Detects the branch `changeledger check --commits` should diff against when
+// no base is given: the remote's HEAD if configured, else a local `main` or
+// `master`. Throws with actionable guidance if neither is resolvable.
+export function defaultBaseBranch(repoRoot, run = defaultRun) {
+  try {
+    const out = run(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], repoRoot);
+    const name = out.trim().replace(/^origin\//, '');
+    if (name) return name;
+  } catch {
+    // no configured remote HEAD — fall through to local candidates
+  }
+  for (const candidate of ['main', 'master']) {
+    try {
+      run(['rev-parse', '--verify', '--quiet', candidate], repoRoot);
+      return candidate;
+    } catch {
+      // candidate branch does not exist locally — try the next one
+    }
+  }
+  throw new Error(
+    'Could not detect a default branch (no origin/HEAD, main, or master); pass one explicitly: changeledger check --commits <base>',
+  );
+}
+
+// Commits in `range` (e.g. `main..HEAD`): sha, subject, body and whether each is
+// a merge (more than one parent) — the git metadata `check --commits` lints.
+export function commitsInRange(repoRoot, range, run = defaultRun) {
+  let out;
+  try {
+    out = run(['log', range, `--pretty=format:%H${SEP}%P${SEP}%s${SEP}%b${RECORD_SEP}`], repoRoot);
+  } catch (e) {
+    throw new Error(`git log failed for range "${range}": ${e.message}`);
+  }
+  return out
+    .split(RECORD_SEP)
+    .map((record) => record.trim())
+    .filter(Boolean)
+    .map((record) => {
+      const [sha, parents, subject, body = ''] = record.split(SEP);
+      return {
+        sha,
+        subject,
+        body: body.trim(),
+        isMerge: parents.trim().split(/\s+/).filter(Boolean).length > 1,
+      };
+    });
+}
+
+const MARKER_RE = /\[#[^\]\s]+\]$/;
+const ANY_MARKER_RE = /\[#[^\]\s]+\]/g;
+const MULTI_BODY_RE = /^ChangeLedger: (\[#[^\]\s]+\])( \[#[^\]\s]+\])+$/;
+
+export function hasCommitMarker(subject) {
+  return MARKER_RE.test(subject.trim());
+}
+
+function commitMarkerViolation({ subject, body }) {
+  const subjectMarkers = subject.match(ANY_MARKER_RE) ?? [];
+  const trimmedBody = body.trim();
+  const hasBodyLabel = trimmedBody.includes('ChangeLedger:');
+  const validMultiBody = MULTI_BODY_RE.test(trimmedBody);
+
+  if (subjectMarkers.length > 1) return 'multiple [#id] markers must be in the body';
+  if (hasBodyLabel && !validMultiBody) return 'malformed ChangeLedger body';
+  if (subjectMarkers.length === 1 && hasCommitMarker(subject) && !hasBodyLabel) return null;
+  if (subjectMarkers.length === 0 && validMultiBody) return null;
+  if (subjectMarkers.length === 1 && validMultiBody)
+    return 'ambiguous [#id] markers in both subject and body';
+  return 'missing [#id] marker';
+}
+
+// Lints `range`: every non-merge commit must carry a well-formed `[#id]`
+// marker, except `chore(release)` prep commits. Returns only the violations
+// (sha + subject); never throws for a clean range.
+export function lintCommitRange(repoRoot, range, run = defaultRun) {
+  const commits = commitsInRange(repoRoot, range, run);
+  const violations = [];
+  for (const c of commits) {
+    if (c.isMerge) continue;
+    if (/^chore\(release\):/.test(c.subject)) continue;
+    const reason = commitMarkerViolation(c);
+    if (reason) violations.push({ sha: c.sha.slice(0, 7), subject: c.subject, reason });
+  }
+  return violations;
+}
+
 export function gitRefs(repoRoot, id, run = defaultRun) {
   const refs = { commits: [], branches: [] };
   if (!id) return refs;

package/src/metrics.mjs

@@ -70,6 +70,29 @@ function avg(nums) {
   return nums.length ? Math.round(nums.reduce((a, b) => a + b, 0) / nums.length) : 0;
 }
 
+// Nearest-rank percentile over an ascending-sorted array; 0 for an empty input
+// so callers never divide by zero or render NaN.
+function percentile(sorted, p) {
+  if (!sorted.length) return 0;
+  const rank = Math.min(sorted.length, Math.max(1, Math.ceil((p / 100) * sorted.length)));
+  return sorted[rank - 1];
+}
+
+// Count of `review → in-progress` verdicts (the `fail --retry` outcome) — the
+// same event grammar as lifecycle transitions, filtered to the implicit
+// review-verdict shape so an explicit `status:` move or a validation verdict
+// isn't miscounted as a retry.
+function reviewRetryCount(change) {
+  let count = 0;
+  for (const line of logBody(change).split('\n')) {
+    const event = parseLogEvent(line);
+    if (event && !event.explicit && event.from === 'in-review' && event.to === 'in-progress') {
+      count++;
+    }
+  }
+  return count;
+}
+
 export function computeMetrics(changes = [], { now } = {}) {
   const nowIso = now ?? '9999-12-31T23:59:59Z';
 
@@ -80,12 +103,17 @@ export function computeMetrics(changes = [], { now } = {}) {
   const aging = [];
   let blockedMs = 0;
   const byType = new Map(); // type → { closed, cycles:[] }
+  const byOwner = new Map(); // owner → { closed, cycles:[] }
+  let reviewRetries = 0;
 
   for (const c of changes) {
     const status = c.frontmatter?.status;
     const type = c.frontmatter?.type ?? 'unknown';
+    const owner = c.frontmatter?.owner || 'unassigned';
     const created = c.frontmatter?.created;
 
+    reviewRetries += reviewRetryCount(c);
+
     if (ACTIVE.includes(status)) wip[status] = (wip[status] ?? 0) + 1;
 
     const segs = statusTimeline(c, nowIso);
@@ -114,6 +142,11 @@ export function computeMetrics(changes = [], { now } = {}) {
         bt.closed += 1;
         bt.cycles.push(cycleMs);
         byType.set(type, bt);
+
+        const bo = byOwner.get(owner) ?? { closed: 0, cycles: [] };
+        bo.closed += 1;
+        bo.cycles.push(cycleMs);
+        byOwner.set(owner, bo);
       }
     }
   }
@@ -130,17 +163,26 @@ export function computeMetrics(changes = [], { now } = {}) {
   const byTypeArr = [...byType.entries()]
     .map(([type, v]) => ({ type, closed: v.closed, avgCycleMs: avg(v.cycles) }))
     .sort((a, b) => b.closed - a.closed);
+  const byOwnerArr = [...byOwner.entries()]
+    .map(([owner, v]) => ({ owner, closed: v.closed, avgCycleMs: avg(v.cycles) }))
+    .sort((a, b) => b.closed - a.closed);
+  const validationWaitMs = timeInStatus.find((t) => t.state === 'in-validation')?.avgMs ?? 0;
 
   return {
     count: perChange.length,
     avgCycleMs: avg(cycles),
     medianCycleMs: median(cycles),
+    p50CycleMs: percentile(cycles, 50),
+    p85CycleMs: percentile(cycles, 85),
     perChange,
     throughput,
     timeInStatus,
     wip,
     aging: aging.sort((a, b) => b.ms - a.ms),
     blockedMs,
+    validationWaitMs,
+    reviewRetries,
     byType: byTypeArr,
+    byOwner: byOwnerArr,
   };
 }

package/src/search.mjs

@@ -0,0 +1,162 @@
+// Deterministic lexical search over changes and specs. No embeddings, no
+// network — a fixed-boost term-frequency score (title x3, headings/CR x2,
+// body x1) with a stable tie-break, so repeated runs are byte-for-byte
+// identical. See change 20260711-103758.
+
+const ACCENTS = /[̀-ͯ]/g;
+const CR_HEADING = /^###\s+CR\d+.*$/gm;
+const MARKDOWN_HEADING = /^#{1,6}\s+(.+)$/gm;
+
+// Lowercase + strip diacritics so "búsqueda" and "busqueda" match the same term.
+export function normalize(text) {
+  return (text ?? '').normalize('NFD').replace(ACCENTS, '').toLowerCase();
+}
+
+function tokenize(query) {
+  return normalize(query)
+    .split(/\s+/)
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+function countOccurrences(haystackNormalized, term) {
+  if (!term) return 0;
+  let count = 0;
+  let idx = 0;
+  for (;;) {
+    const found = haystackNormalized.indexOf(term, idx);
+    if (found === -1) break;
+    count++;
+    idx = found + term.length;
+  }
+  return count;
+}
+
+// Locates the first case/accent-insensitive occurrence of `term` in `rawText`
+// and returns a short surrounding snippet, or null when there is no match.
+function findSnippet(rawText, term, span = 40) {
+  const normalized = normalize(rawText);
+  const idx = normalized.indexOf(term);
+  if (idx === -1) return null;
+  const start = Math.max(0, idx - span);
+  const end = Math.min(rawText.length, idx + term.length + span);
+  const prefix = start > 0 ? '…' : '';
+  const suffix = end < rawText.length ? '…' : '';
+  return `${prefix}${rawText.slice(start, end).replace(/\s+/g, ' ').trim()}${suffix}`;
+}
+
+// Splits a change's stages into a heading/CR bucket (boost x2) and a body
+// bucket (boost x1). CR heading lines are lifted out of the body so they are
+// scored once, at the heading boost, not twice.
+function changeHeadingsAndBody(stages) {
+  const headings = [];
+  const bodyParts = [];
+  for (const stage of stages) {
+    headings.push(stage.heading);
+    const crHeadings = stage.body.match(CR_HEADING) ?? [];
+    headings.push(...crHeadings);
+    bodyParts.push(stage.body.replace(CR_HEADING, ''));
+  }
+  return { headings: headings.join('\n'), body: bodyParts.join('\n\n') };
+}
+
+// Same split for a spec's free-form body: its own `#`..`######` headings
+// (boost x2) versus the remaining prose (boost x1).
+function specHeadingsAndBody(body) {
+  const headings = [...body.matchAll(MARKDOWN_HEADING)].map((m) => m[1]);
+  const stripped = body.replace(MARKDOWN_HEADING, '');
+  return { headings: headings.join('\n'), body: stripped };
+}
+
+// Builds the searchable corpus from a loaded repo (see repo.mjs `loadRepo`):
+// every change — including archived ones — and every spec, reduced to the
+// fields the scorer needs.
+export function buildCorpus({ changes, specs }) {
+  const fromChanges = changes.map((c) => {
+    const { headings, body } = changeHeadingsAndBody(c.stages);
+    return {
+      ref: `#${c.frontmatter.id}`,
+      kind: 'change',
+      title: c.frontmatter.title ?? '',
+      status: c.frontmatter.status ?? null,
+      type: c.frontmatter.type ?? null,
+      headings,
+      body,
+    };
+  });
+
+  const fromSpecs = specs.map((s) => {
+    const slug = s.name.replace(/\.md$/, '');
+    const { headings, body } = specHeadingsAndBody(s.body);
+    return {
+      ref: `spec:${slug}`,
+      kind: 'spec',
+      title: s.frontmatter.title ?? slug,
+      status: null,
+      type: null,
+      headings,
+      body,
+    };
+  });
+
+  return [...fromChanges, ...fromSpecs];
+}
+
+function scoreDocument(doc, terms) {
+  const titleN = normalize(doc.title);
+  const headingsN = normalize(doc.headings);
+  const bodyN = normalize(doc.body);
+  let score = 0;
+  for (const term of terms) {
+    score += countOccurrences(titleN, term) * 3;
+    score += countOccurrences(headingsN, term) * 2;
+    score += countOccurrences(bodyN, term) * 1;
+  }
+  return score;
+}
+
+function buildSnippet(doc, terms) {
+  for (const field of [doc.title, doc.headings, doc.body]) {
+    for (const term of terms) {
+      const snippet = findSnippet(field, term);
+      if (snippet) return snippet;
+    }
+  }
+  return '';
+}
+
+// Scores and ranks `docs` (as produced by `buildCorpus`) against `query`.
+// On an equal score, a spec sorts before a change — specs are the current
+// persistent truth, so that's what an agent should read first. Among equals
+// of the same kind, ties break by `ref` descending so the same repo state
+// always yields the same byte-for-byte output.
+export function searchDocuments(docs, query, { limit = 10, type, status } = {}) {
+  const terms = tokenize(query);
+  if (!terms.length) return [];
+
+  const hits = [];
+  for (const doc of docs) {
+    if (type && doc.type !== type) continue;
+    if (status && doc.status !== status) continue;
+    const score = scoreDocument(doc, terms);
+    if (score <= 0) continue;
+    hits.push({
+      ref: doc.ref,
+      kind: doc.kind,
+      title: doc.title,
+      type: doc.type,
+      status: doc.status,
+      score,
+      snippet: buildSnippet(doc, terms),
+    });
+  }
+
+  hits.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (a.kind !== b.kind) return a.kind === 'spec' ? -1 : 1;
+    if (a.ref === b.ref) return 0;
+    return a.ref < b.ref ? 1 : -1;
+  });
+
+  return hits.slice(0, limit);
+}

package/src/viewer/domain.mjs

@@ -407,7 +407,7 @@ export function previewConfigMigration(projects, id, rev) {
   return {
     code: 200,
     body: {
-      summary: `Config migration 0 → ${SUPPORTED_SCHEMA_VERSION} (dry run)`,
+      summary: `Config migration ${migrationResult.fromVersion} → ${SUPPORTED_SCHEMA_VERSION} (dry run)`,
       changes: migrationResult.changes,
       yaml: migrationResult.yaml,
     },
@@ -468,6 +468,7 @@ const PATCH_ALLOWED = new Set([
   'readiness',
   'types',
   'release',
+  'git',
 ]);
 
 const CANONICAL_STATUSES_REQUIRED = new Set([
@@ -500,6 +501,8 @@ function applyPatch(doc, patch, currentConfig) {
       applyReleasePatch(doc, value);
     } else if (key === 'readiness') {
       applyReadinessPatch(doc, value);
+    } else if (key === 'git') {
+      applyGitPatch(doc, value);
     } else if (key === 'statuses') {
       applyRequiredListPatch(doc, 'statuses', value, CANONICAL_STATUSES_REQUIRED);
     } else if (key === 'stages') {
@@ -554,3 +557,12 @@ function applyReadinessPatch(doc, readinessPatch) {
     doc.setIn(['readiness', 'verification_patterns'], readinessPatch.verification_patterns);
   }
 }
+
+function applyGitPatch(doc, gitPatch) {
+  if (!gitPatch || typeof gitPatch !== 'object') return;
+  if (typeof gitPatch.integration_branch === 'string' && gitPatch.integration_branch.trim()) {
+    doc.setIn(['git', 'integration_branch'], gitPatch.integration_branch.trim());
+  } else if (gitPatch.integration_branch === null) {
+    doc.deleteIn(['git', 'integration_branch']);
+  }
+}

package/src/viewer/public/app.js

@@ -48,7 +48,7 @@ import {
   tableRow,
   validationPanel,
 } from './view-parts.js';
-import { graphSvg, metricsHtml, specsListHtml } from './view-renderers.js';
+import { graphSvg, metricsHtml, sortSpecsByUpdated, specsListHtml } from './view-renderers.js';
 
 export { cssIdent, esc, makeMermaidExpandable, safeHtml } from './security.js';
 export { boardStatuses, isVisible, passesTombstones } from './state.js';
@@ -156,7 +156,7 @@ function renderChoiceFilter(host, label, choices, selected, toggle, clear, owner
     html`<details class="filter-menu">
       <summary class="filter-trigger">
         <svg viewBox="0 0 16 16" aria-hidden="true"><path d="M2 3.25h12M4.25 8h7.5M6.5 12.75h3"></path></svg>
-        <span>${summary}</span>
+        <span data-choice-summary>${summary}</span>
         <svg class="filter-chevron" viewBox="0 0 16 16" aria-hidden="true"><path d="m4.5 6.25 3.5 3.5 3.5-3.5"></path></svg>
       </summary>
       <div class="filter-popover">
@@ -169,19 +169,32 @@ function renderChoiceFilter(host, label, choices, selected, toggle, clear, owner
     </details>`,
     host,
   );
+  const syncSummary = () => {
+    host.querySelector('[data-choice-summary]').textContent = choiceFilterSummary(
+      label,
+      selected,
+      owners && state.filters.includeUnassigned,
+    );
+  };
   host.querySelectorAll('[data-choice]').forEach((input) => {
     input.onchange = () => {
       toggle(input.dataset.choice);
+      syncSummary();
       render();
     };
   });
   if (owners)
     host.querySelector('[data-unassigned]').onchange = () => {
       toggleUnassignedOwner();
+      syncSummary();
       render();
     };
   host.querySelector('[data-clear]').onclick = () => {
     clear();
+    host.querySelectorAll('[data-choice], [data-unassigned]').forEach((input) => {
+      input.checked = false;
+    });
+    syncSummary();
     render();
   };
 }
@@ -722,8 +735,10 @@ function sortVal(c, key) {
 /* Specs view */
 function renderSpecs() {
   const q = state.filters.text.toLowerCase();
-  const specs = (state.repo.specs || []).filter(
-    (s) => !q || `${s.title} ${(s.tags || []).join(' ')} ${s.body}`.toLowerCase().includes(q),
+  const specs = sortSpecsByUpdated(
+    (state.repo.specs || []).filter(
+      (s) => !q || `${s.title} ${(s.tags || []).join(' ')} ${s.body}`.toLowerCase().includes(q),
+    ),
   );
   litRender(specsListHtml(specs, fmtDateTime), $('#specs'));
   $('#specs')
@@ -789,8 +804,32 @@ export function handleSpecBodyClick(event, _openSpecByName) {
 
 const VIEWS = ['board', 'table', 'graph', 'specs', 'metrics', 'projects'];
 
-function renderMetrics() {
-  litRender(metricsHtml(state.repo.metrics || {}), $('#metrics'));
+// The shared metrics module is dynamic-imported once and cached: the client
+// computes metrics itself, over the filtered set, instead of duplicating
+// `computeMetrics` (20260711-155721 CR2). Served read-only from the CLI's own
+// `src/metrics.mjs` by the router.
+let sharedMetricsModule;
+function loadMetricsModule() {
+  sharedMetricsModule ??= import('/shared/metrics.mjs');
+  return sharedMetricsModule;
+}
+
+// `computeMetrics` speaks the CLI's native change shape (`{ frontmatter,
+// stages }`); `state.repo.changes` is already flattened for board/table
+// rendering. Adapt back rather than reshaping the shared module's contract,
+// which the server also relies on unchanged.
+function toMetricsChange(c) {
+  return {
+    frontmatter: { id: c.id, type: c.type, status: c.status, owner: c.owner, created: c.created },
+    stages: c.stages,
+  };
+}
+
+async function renderMetrics() {
+  const changes = visibleChanges();
+  const { computeMetrics } = await loadMetricsModule();
+  const metrics = computeMetrics(changes.map(toMetricsChange), { now: new Date().toISOString() });
+  litRender(metricsHtml(metrics, changes.length), $('#metrics'));
 }
 
 export function syncViewerShell(root = document, renderContent = true) {
@@ -825,7 +864,6 @@ let configMode = 'form'; // 'form' | 'raw'
 let configDirty = false; // true when form/raw has unsaved edits
 let migrationPreview = null; // null | { summary, changes, yaml } | { already_current }
 
-const SUPPORTED_SCHEMA_VERSION = 1;
 // Confirm dialog — uses native <dialog> for proper focus-trap, ESC and backdrop.
 // _confirmImpl is replaceable in tests (JSDOM lacks showModal).
 let _confirmImpl = null;
@@ -929,8 +967,9 @@ function configSectionTemplate(config, mode, preview) {
   }
 
   const schema = config.schemaVersion ?? 0;
-  const futureSch = schema > SUPPORTED_SCHEMA_VERSION;
-  const outdated = schema < SUPPORTED_SCHEMA_VERSION;
+  const supported = config.supported;
+  const futureSch = schema > supported;
+  const outdated = schema < supported;
 
   return html`<div class="config-section">
     ${
@@ -964,7 +1003,7 @@ function configSectionTemplate(config, mode, preview) {
         : outdated
           ? html`<div class="config-migration-card">
               <h3>Migration required</h3>
-              <p>Config schema ${schema} is outdated. Preview and apply the migration to schema ${SUPPORTED_SCHEMA_VERSION} to enable the Form editor.</p>
+              <p>Config schema ${schema} is outdated. Preview and apply the migration to schema ${supported} to enable the Form editor.</p>
               ${
                 preview?.already_current
                   ? html`<p class="config-migration-ok">Migration already applied.</p>`
@@ -1055,6 +1094,14 @@ function formEditorTemplate(config) {
       </label>
     </fieldset>
 
+    <fieldset class="config-group">
+      <legend>Git</legend>
+      <label>Integration branch
+        <input name="integration_branch" .value=${cfg.git?.integration_branch ?? ''} placeholder="Auto-detect" />
+      </label>
+      <p class="config-note">Change branches start from and merge into this branch. Leave empty to auto-detect.</p>
+    </fieldset>
+
     <fieldset class="config-group">
       <legend>Lifecycle statuses</legend>
       <label>Status order (one per line)
@@ -1207,7 +1254,7 @@ async function openManagedProject(id, { reload = false } = {}) {
     const structured = await getProjectConfigStructured(id);
     managedConfig = { id, ...structured };
     // Default to form for current schema, raw for future schema
-    if (structured.schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    if (structured.schemaVersion > structured.supported) {
       configMode = 'raw';
     } else {
       configMode = 'form';
@@ -1300,6 +1347,13 @@ export function collectFormPatch(formEl, currentConfig) {
   if (els.specs_dir && els.specs_dir.value !== (currentConfig.specs_dir ?? '.changeledger/specs')) {
     patch.specs_dir = els.specs_dir.value;
   }
+  if (els.integration_branch) {
+    const currentBranch = currentConfig.git?.integration_branch ?? '';
+    const proposedBranch = els.integration_branch.value.trim();
+    if (proposedBranch !== currentBranch) {
+      patch.git = { integration_branch: proposedBranch || null };
+    }
+  }
 
   const statuses = listFromControl(els.statuses);
   if (els.statuses && !sameList(statuses, currentConfig.statuses ?? [])) patch.statuses = statuses;
@@ -1639,6 +1693,17 @@ function bootstrap() {
 
   loadProjects();
   setInterval(load, 5000);
+
+  // The topbar wraps to multiple rows at content-dependent widths, so the
+  // CSS fallback constant cannot bound the projects panels; track the real
+  // rendered height instead.
+  const topbar = document.querySelector('.topbar');
+  if (topbar && typeof ResizeObserver === 'function') {
+    const syncHeaderHeight = () =>
+      document.documentElement.style.setProperty('--header-height', `${topbar.offsetHeight}px`);
+    new ResizeObserver(syncHeaderHeight).observe(topbar);
+    syncHeaderHeight();
+  }
 }
 
 export function closeFilterMenusOnOutsideClick(menus, target) {