@opengsd/gsd-core 1.12.0 → 1.13.0

package/gsd-core/bin/lib/git-base-branch.cjs

@@ -122,6 +122,7 @@ function readEffectiveGitConfig(cwd, deps) {
                     config = {
                         base_branch: _readGitKey(normalized, 'base_branch'),
                         protected_branches: _readGitNested(normalized, 'protected_branches'),
+                        allow_default_branch_commits: _readGitNested(normalized, 'allow_default_branch_commits'),
                     };
                 }
             }
@@ -161,7 +162,10 @@ function readEffectiveGitConfig(cwd, deps) {
         // Not a list at all — contributes no names, but is still a misconfiguration.
         rejectedProtectedBranches.push(renderRejected(rawProtectedBranches));
     }
-    return { baseBranch, protectedBranches, rejectedProtectedBranches };
+    // #3819: nested-only read (mirrors protected_branches — new key, no legacy
+    // flat form, so a top-level spelling must not become an undocumented alias).
+    const allowDefaultBranchCommits = config.allow_default_branch_commits === true;
+    return { baseBranch, protectedBranches, rejectedProtectedBranches, allowDefaultBranchCommits };
 }
 /**
  * Try `git symbolic-ref --short refs/remotes/origin/HEAD` (no network).
@@ -302,13 +306,17 @@ function resolveBaseBranch(cwd, deps) {
 function resolveProtectedBranchStatus(cwd, currentBranch, deps) {
     const effectiveConfig = readEffectiveGitConfig(cwd, deps);
     const { branch: baseBranch, verified } = resolveBaseBranchDiagnosticsWithConfig(cwd, effectiveConfig.baseBranch, deps);
-    const protectedBranches = [...new Set([baseBranch, ...effectiveConfig.protectedBranches])];
+    const protectedBranches = [...new Set([
+            ...(effectiveConfig.allowDefaultBranchCommits ? [] : [baseBranch]),
+            ...effectiveConfig.protectedBranches,
+        ])];
     return {
         baseBranch,
         protectedBranches,
         rejectedProtectedBranches: effectiveConfig.rejectedProtectedBranches,
         isProtected: protectedBranches.includes(currentBranch),
         verified,
+        allowDefaultBranchCommits: effectiveConfig.allowDefaultBranchCommits,
     };
 }
 /**

package/gsd-core/bin/lib/health-diagnostic-rules/phase-structure.cjs

@@ -56,7 +56,13 @@ const healthDiagnosticMod = require("../health-diagnostic-types.cjs");
 const { SEVERITY, adviseRemedy } = healthDiagnosticMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const validateMod = require("../validate.cjs");
-const { phaseDirNameRe } = validateMod;
+// #612: `isPhaseDirName` is the convention-SELECTED shape test wrapping
+// `phaseDirNameRe`. Handed no convention it delegates to that very regex, so a
+// legacy repo's W005 reading is byte-identical; handed 'bracket' it also
+// recognizes `{CODE}.{MM}-{PP}-slug`, which `phaseDirNameRe` rejects outright —
+// left un-threaded, W005 fires on EVERY phase directory of a repo that opted
+// into the convention, i.e. the check inverts on exactly the repos PR-2 widens.
+const { isPhaseDirName } = validateMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const phaseIdMod = require("../phase-id.cjs");
 const { extractPhaseToken, normalizePhaseName, comparePhaseNum } = phaseIdMod;
@@ -64,7 +70,7 @@ const { extractPhaseToken, normalizePhaseName, comparePhaseNum } = phaseIdMod;
 function checkW005(snapshot) {
     const diagnostics = [];
     for (const name of snapshot.phaseDirs.value) {
-        if (!name.match(phaseDirNameRe)) {
+        if (!isPhaseDirName(name, snapshot.phaseIdConvention)) {
             diagnostics.push({
                 code: 'W005',
                 severity: SEVERITY.WARNING,

package/gsd-core/bin/lib/health-diagnostic-rules/roadmap-disk-consistency.cjs

@@ -116,8 +116,16 @@ const { phaseVariants } = validateMod;
  * does the roadmap claim, for W007) call this — one matcher, reused, per the
  * file-level comment.
  */
-function dirsForPhase(dirs, phaseId) {
-    const canonical = matchPhaseDirs(dirs, normalizePhaseName(phaseId)).matches;
+function dirsForPhase(dirs, phaseId, convention) {
+    // #612: `convention` reaches BOTH operands of this pairing or it pairs
+    // nothing. The phases come from a bracket-aware heading scan and the dirs
+    // from a bracket-aware disk scan, so a convention-less selector here leaves
+    // W006's existence check and W007's `claimedDirs` empty on exactly the repos
+    // both scans just widened — every bracket phase reads as "no directory on
+    // disk" AND every bracket directory reads as unclaimed. `matchPhaseDirs`
+    // forwards it to its primary `phaseTokenMatches`; handed nothing it is
+    // byte-identical, so no legacy repo's pairing changes.
+    const canonical = matchPhaseDirs(dirs, normalizePhaseName(phaseId), convention).matches;
     if (canonical.length > 0)
         return canonical;
     // Bug 2 (#3309 W006/W007 migration cluster, found while fixing the
@@ -139,7 +147,12 @@ function dirsForPhase(dirs, phaseId) {
     // alone misses without re-deriving a second matcher.
     const variants = phaseVariants(phaseId);
     return dirs.filter((d) => {
-        const token = extractPhaseToken(d).toUpperCase();
+        // #612: the same convention the primary matcher above got. This fallback
+        // compares a DIRECTORY-derived token against phase-id variants, so left
+        // convention-less it reads `GSD.02-05-slug` with the legacy grammar and can
+        // never agree with a bracket phase id — the fallback would then be dead on
+        // precisely the convention it is reached for.
+        const token = extractPhaseToken(d, convention).toUpperCase();
         for (const variant of variants) {
             if (token === variant.toUpperCase())
                 return true;
@@ -173,15 +186,40 @@ function checkW006(snapshot) {
     if (snapshot.roadmapDeclaredPhases.scope !== SCOPE.COMPLETE)
         return [];
     const dirs = snapshot.allPhaseDirNames.value;
+    const convention = snapshot.phaseIdConvention;
     const archivedTokens = new Set(snapshot.archivedPhaseTokens.value);
+    // No separate scope guard: `roadmapSentinelPhaseTokens` and
+    // `roadmapDeclaredPhases` are produced by ONE builder call
+    // (`buildRoadmapDeclaredPhasesField`) from ONE `buildRoadmapPhaseVariants`
+    // result, so their scopes are yoked by construction — the COMPLETE check
+    // above covers both. Stated rather than left implicit, because reading the
+    // sentinel set unconditionally would be a latent bug the day the two fields
+    // acquire independent builders: an UNREADABLE sentinel set silently degrades
+    // to "nothing is a sentinel," which ADDS W006 warnings rather than dropping
+    // them.
+    const sentinelTokens = new Set(snapshot.roadmapSentinelPhaseTokens.value);
     const checkboxes = snapshot.roadmapPhaseCheckboxes.value;
     const diagnostics = [];
     for (const { phaseId } of snapshot.roadmapDeclaredPhases.value) {
-        // #3225: sentinel phase ids (999.x/0.x) are never-on-roadmap by
-        // convention; a sentinel heading shouldn't demand a directory.
-        if (isSentinelPhaseId(phaseId))
+        // A backlog/icebox phase legitimately has no directory. The two guards are
+        // DISJOINT, which is why both are needed and neither subsumes the other:
+        //
+        //   #612  `roadmapSentinelPhaseTokens` — bracket sentinels. Under the
+        //         bracket convention the sentinel-ness lives in the MILESTONE, not
+        //         the token: the heading `### [GSD.999] 07:` yields phase id `07`,
+        //         so a bare-token test cannot see it. The snapshot's
+        //         `buildRoadmapPhaseVariants` call carries the bracket id alongside
+        //         and reports the token here. Empty unless the bracket convention
+        //         is active, so no legacy repo's reading changes.
+        //   #3225 `isSentinelPhaseId` — the legacy/bare leading-int rule (999.x/0.x),
+        //         which sees `### Phase 999:` and is blind to `[GSD.999] 07`.
+        //
+        // Upstream's call is kept one-arg verbatim: every `phaseId` here is a bare
+        // token, never a `{CODE}.{MM}`-qualified id, so a convention argument could
+        // not change its result.
+        if (sentinelTokens.has(phaseId) || isSentinelPhaseId(phaseId))
             continue;
-        if (dirsForPhase(dirs, phaseId).length > 0)
+        if (dirsForPhase(dirs, phaseId, convention).length > 0)
             continue;
         // Bug 1 (#3309 W006/W007 migration cluster): a phase whose ONLY
         // directory lives under a milestone archive
@@ -209,10 +247,10 @@ function checkW006(snapshot) {
 // ─── W007 — an on-disk phase directory has no matching ROADMAP entry ──────
 // (verify.cts:2086-2101)
 /** Every directory in `dirs` that ANY declared roadmap phase resolves to. */
-function computeClaimedDirs(dirs, declaredPhases) {
+function computeClaimedDirs(dirs, declaredPhases, convention) {
     const claimed = new Set();
     for (const { phaseId } of declaredPhases) {
-        for (const dir of dirsForPhase(dirs, phaseId))
+        for (const dir of dirsForPhase(dirs, phaseId, convention))
             claimed.add(dir);
     }
     return claimed;
@@ -222,14 +260,19 @@ function checkW007(snapshot) {
     if (snapshot.roadmapDeclaredPhases.scope !== SCOPE.COMPLETE)
         return [];
     const dirs = snapshot.allPhaseDirNames.value;
-    const claimedDirs = computeClaimedDirs(dirs, snapshot.roadmapDeclaredPhases.value);
+    const convention = snapshot.phaseIdConvention;
+    const claimedDirs = computeClaimedDirs(dirs, snapshot.roadmapDeclaredPhases.value, convention);
     const diagnostics = [];
     for (const dirName of dirs) {
         // `extractPhaseToken` is the phase-id.cts owner `PHASE_TOKEN_FROM_DIR_RE`
         // (`src/validate.cts:73-76`) is documented to match exactly
         // (verify.cts's original `p` key from `collectDiskPhaseEntries`,
         // `verify.cts:1373-1397`) — same token, relocated read, not reinvented.
-        const token = extractPhaseToken(dirName);
+        // #612: `collectDiskPhaseEntries` keyed that map through the
+        // convention-aware extractor, so the token this message names must be
+        // derived the same way — otherwise a bracket repo's unclaimed
+        // `GSD.02-05-slug` is reported as phase `GSD.02` rather than `05`.
+        const token = extractPhaseToken(dirName, convention);
         // #3225: a sentinel dir on disk (999-interim, 0-drafts) is defined as
         // never-on-roadmap; it must not trigger W007. #3639: judged on the DIR
         // NAME via the dir-aware recognizer — the extracted token is

package/gsd-core/bin/lib/health-diagnostic-rules/state-consistency.cjs

@@ -111,7 +111,13 @@ const RULE_W024 = {
 function buildValidPhaseSet(snapshot) {
     const valid = new Set();
     for (const dir of snapshot.phaseDirs.value) {
-        const token = extractPhaseToken(dir);
+        // #612: the pre-migration source of this third was
+        // `collectDiskPhases(planBase, convention)`, whose keys came from the
+        // convention-aware extractor. Left convention-less here, a bracket repo's
+        // `GSD.02-05-slug` contributes `GSD.02` instead of `05`, so every STATE.md
+        // reference to a real phase falls outside the valid set and W002 fires on
+        // all of them.
+        const token = extractPhaseToken(dir, snapshot.phaseIdConvention);
         if (token)
             valid.add(token);
     }
@@ -233,31 +239,71 @@ const RULE_W021 = {
     description: "Phase's integer prefix implies a different milestone than its ROADMAP section (phase_id_convention: milestone-prefixed)",
     repairable: false,
     check: (snapshot) => {
-        const convention = snapshot.config.value?.['phase_id_convention'];
-        if (convention !== 'milestone-prefixed')
-            return [];
         const diagnostics = [];
-        for (const entry of snapshot.roadmapDeclaredPhases.value) {
-            // `entry.milestone === null` means the builder never found this phase
-            // heading inside any versioned (`v\d+\.\d+`) section — the original
-            // `checkMilestonePrefixMismatches` only ever iterates phases found
-            // WITHIN a section, so a phase outside any section is equivalently
-            // never checked here.
-            if (entry.milestone === null)
-                continue;
-            const expectedMilestone = getMilestoneFromPhaseId(entry.phaseId);
-            if (expectedMilestone === null || expectedMilestone === entry.milestone)
-                continue;
-            diagnostics.push({
-                code: 'W021',
-                severity: SEVERITY.WARNING,
-                message: `Phase ${entry.phaseId}: integer prefix implies ${expectedMilestone} but listed under ${entry.milestone}`,
-                remedy: adviseRemedy('gsd-tools roadmap upgrade --convention milestone-prefixed'),
-            });
+        // Two INDEPENDENT gates, evaluated in the order the pre-migration
+        // `cmdValidateHealth` block emitted them (milestone-prefixed first, then
+        // bracket). They are deliberately NOT written as if/else: the two read
+        // DIFFERENT config bases and can both be true at once.
+        //
+        //   milestone-prefixed — `snapshot.config` (ROOT config only), exactly as
+        //     this gate has always read it. Federating THIS one silently moved a
+        //     legacy convention's answer in BOTH directions on workstream repos: a
+        //     W021 that fires at base vanishing, and one silent at base firing.
+        //   bracket — `snapshot.phaseIdConvention` (federated workstream -> root),
+        //     because the bracket reads this half reports on are themselves
+        //     federated; gating it on the root answer would split the check against
+        //     the reads it describes.
+        //
+        // A workstream that overrides a `milestone-prefixed` ROOT to `bracket` is
+        // the case that makes the distinction observable, and it is the reason an
+        // early `return` here would be a bug: the root-configured M-NN gate must
+        // still fire, or the repo looks healthier than it is.
+        const rootConvention = snapshot.config.value?.['phase_id_convention'];
+        if (rootConvention === 'milestone-prefixed') {
+            diagnostics.push(...checkMilestonePrefixW021(snapshot));
+        }
+        // #612: an ADDITIVE sibling branch — the milestone-prefixed gate above is
+        // untouched. Gated strictly on the ACTIVE convention, never on
+        // project_code presence: reads are selected per convention, and a CHECK
+        // that can fail a repo runs only for the convention that repo opted into.
+        if (snapshot.phaseIdConvention === 'bracket') {
+            for (const mm of snapshot.roadmapBracketIncoherences.value) {
+                diagnostics.push({
+                    code: 'W021',
+                    severity: SEVERITY.WARNING,
+                    message: mm.kind === 'missing-bracket'
+                        ? `Phase ${mm.phaseId}: heading is not in bracket form under the 'bracket' convention (expected \`[CODE.${mm.sectionMilestone}] ${mm.phaseId}:\`)`
+                        : `Phase ${mm.phaseId}: bracket milestone ${mm.phaseMilestone} does not match its section milestone ${mm.sectionMilestone}`,
+                    remedy: adviseRemedy('Bracket migration lands with the #612 migrator (PR-3); until then, manually align the bracket milestone in this heading to match the enclosing section.'),
+                });
+            }
         }
         return diagnostics;
     },
 };
+/** The milestone-prefixed half of W021, unchanged by #612. */
+function checkMilestonePrefixW021(snapshot) {
+    const diagnostics = [];
+    for (const entry of snapshot.roadmapDeclaredPhases.value) {
+        // `entry.milestone === null` means the builder never found this phase
+        // heading inside any versioned (`v\d+\.\d+`) section — the original
+        // `checkMilestonePrefixMismatches` only ever iterates phases found
+        // WITHIN a section, so a phase outside any section is equivalently
+        // never checked here.
+        if (entry.milestone === null)
+            continue;
+        const expectedMilestone = getMilestoneFromPhaseId(entry.phaseId);
+        if (expectedMilestone === null || expectedMilestone === entry.milestone)
+            continue;
+        diagnostics.push({
+            code: 'W021',
+            severity: SEVERITY.WARNING,
+            message: `Phase ${entry.phaseId}: integer prefix implies ${expectedMilestone} but listed under ${entry.milestone}`,
+            remedy: adviseRemedy('gsd-tools roadmap upgrade --convention milestone-prefixed'),
+        });
+    }
+    return diagnostics;
+}
 // ─── W026 — STATE says milestone complete but ROADMAP lists unstarted phase ─
 const RULE_W026 = {
     code: 'W026',
@@ -282,7 +328,14 @@ const RULE_W026 = {
             // unwindowed `phaseDirNames2` (`verify.cts:2372-2382`, a direct
             // `readdirSync` of the phases dir), not the current-milestone-windowed
             // `phaseDirs`.
-            const hasDirectory = matchPhaseDirs(snapshot.allPhaseDirNames.value, normalized).matches.length > 0;
+            // #612: the directory read widens with the heading read that produced
+            // `currentMilestoneRoadmapPhaseIds`, or every bracket phase resolves to
+            // nothing, reads as unstarted, and this UNGATED warning false-fires on
+            // any bracket repo whose STATE says the milestone is complete. #2528
+            // moved the read onto the shared selector; the convention rides along,
+            // since the selector's primary match IS the `phaseTokenMatches` call this
+            // line used to make directly.
+            const hasDirectory = matchPhaseDirs(snapshot.allPhaseDirNames.value, normalized, snapshot.phaseIdConvention).matches.length > 0;
             if (!hasDirectory)
                 unstarted.push(phaseId);
         }

package/gsd-core/bin/lib/host-integration.cjs

@@ -72,7 +72,7 @@ const INTERFACE_POINTS = Object.freeze(['command', 'dispatch', 'model', 'hooks',
 const SAFE_DEFAULTS = {
     embeddingMode: 'declarative',
     commandSurface: 'prose-only',
-    dispatch: { namedDispatch: false, nested: false, maxDepth: 0, background: false, subagentToolkit: 'read-only', backgroundDispatch: false, isolation: 'none' },
+    dispatch: { namedDispatch: false, nested: false, maxDepth: 0, background: false, subagentToolkit: 'read-only', backgroundDispatch: false, isolation: 'none', maxConcurrency: 1 },
     modelMode: 'passive',
     hookBus: 'none',
     stateIO: 'session-log-append',
@@ -84,7 +84,7 @@ const PROFILE_BASELINES = Object.freeze({
     'programmatic-cli': Object.freeze({
         embeddingMode: 'imperative',
         commandSurface: 'slash-file',
-        dispatch: Object.freeze({ namedDispatch: true, nested: true, maxDepth: -1, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none' }),
+        dispatch: Object.freeze({ namedDispatch: true, nested: true, maxDepth: -1, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none', maxConcurrency: 1 }),
         modelMode: 'passive',
         hookBus: 'host',
         stateIO: 'filesystem',
@@ -95,7 +95,7 @@ const PROFILE_BASELINES = Object.freeze({
     'declarative-cli': Object.freeze({
         embeddingMode: 'declarative',
         commandSurface: 'slash-file',
-        dispatch: Object.freeze({ namedDispatch: true, nested: false, maxDepth: 1, background: false, subagentToolkit: 'full', backgroundDispatch: false, isolation: 'none' }),
+        dispatch: Object.freeze({ namedDispatch: true, nested: false, maxDepth: 1, background: false, subagentToolkit: 'full', backgroundDispatch: false, isolation: 'none', maxConcurrency: 1 }),
         modelMode: 'passive',
         hookBus: 'host',
         stateIO: 'filesystem',
@@ -106,7 +106,7 @@ const PROFILE_BASELINES = Object.freeze({
     'ide': Object.freeze({
         embeddingMode: 'imperative',
         commandSurface: 'palette',
-        dispatch: Object.freeze({ namedDispatch: true, nested: true, maxDepth: 5, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none' }),
+        dispatch: Object.freeze({ namedDispatch: true, nested: true, maxDepth: 5, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none', maxConcurrency: 1 }),
         modelMode: 'active',
         hookBus: 'engine',
         stateIO: 'sandboxed-storage',
@@ -235,7 +235,7 @@ const DEFAULT_ENGINE = {
     axes: {
         embeddingMode: 'imperative',
         commandSurface: 'slash-file',
-        dispatch: { namedDispatch: true, nested: true, maxDepth: -1, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none' },
+        dispatch: { namedDispatch: true, nested: true, maxDepth: -1, background: true, subagentToolkit: 'full', backgroundDispatch: true, isolation: 'none', maxConcurrency: 1 },
         modelMode: 'active',
         hookBus: 'host',
         stateIO: 'filesystem',
@@ -246,6 +246,19 @@ const DEFAULT_ENGINE = {
     known: HOST_INTEGRATION_AXES,
 };
 // ---------------------------------------------------------------------------
+// isPositiveSafeInteger — shared predicate (#3673)
+// ---------------------------------------------------------------------------
+/**
+ * True iff `v` is a positive (>0) JS safe integer. Single source of truth for
+ * the dispatch.maxConcurrency contract: used by negotiateHostCapabilities
+ * below, and by gsd-core/bin/gsd-tools.cjs's routeDispatchCapacity (which
+ * requires this module's compiled output rather than reimplementing the
+ * predicate), so the two consumers cannot silently diverge.
+ */
+function isPositiveSafeInteger(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+// ---------------------------------------------------------------------------
 // negotiateHostCapabilities
 // ---------------------------------------------------------------------------
 /**
@@ -335,6 +348,7 @@ function negotiateHostCapabilities(host, engine = DEFAULT_ENGINE) {
     let effectiveSubagentToolkit;
     let effectiveMaxDepth;
     let effectiveIsolation;
+    let effectiveMaxConcurrency;
     if (hostDispatch === null) {
         // Host didn't declare dispatch at all — fail-closed to most-restrictive values
         warnings.push(`host did not declare 'dispatch'`);
@@ -345,6 +359,7 @@ function negotiateHostCapabilities(host, engine = DEFAULT_ENGINE) {
         effectiveSubagentToolkit = 'read-only';
         effectiveMaxDepth = 0;
         effectiveIsolation = 'none';
+        effectiveMaxConcurrency = 1;
     }
     else {
         // N1: observability warnings for 'undocumented' sentinel on dispatch fields
@@ -408,6 +423,41 @@ function negotiateHostCapabilities(host, engine = DEFAULT_ENGINE) {
         const eDepthNum = engineDispatch.maxDepth < 0 ? Infinity : engineDispatch.maxDepth;
         const minDepth = Math.min(hDepthNum, eDepthNum);
         effectiveMaxDepth = minDepth === Infinity ? -1 : minDepth;
+        // maxConcurrency (#3673, ADR-1239 Phase 1): a positive-safe-integer
+        // passthrough with a fail-closed floor of 1. UNLIKE maxDepth, there is no
+        // min(host, engine) reduction here — the design doc explicitly rejects an
+        // engine-side ceiling for this field (no competing intrinsic worker
+        // ceiling to cap against at the negotiation layer); a `--jobs N` cap is
+        // applied later, at the Phase 4 scheduler.
+        const hostMaxConcurrency = hostDispatch.maxConcurrency;
+        if (hostMaxConcurrency === UNDOCUMENTED) {
+            warnings.push(`dispatch.maxConcurrency is undocumented — degraded closed (1)`);
+            effectiveMaxConcurrency = 1;
+        }
+        else if (isPositiveSafeInteger(hostMaxConcurrency)) {
+            effectiveMaxConcurrency = hostMaxConcurrency;
+        }
+        else if (hostMaxConcurrency === undefined) {
+            warnings.push(`host did not declare 'dispatch.maxConcurrency' — treating as 1`);
+            effectiveMaxConcurrency = 1;
+        }
+        else if (typeof hostMaxConcurrency !== 'number') {
+            warnings.push(`host dispatch.maxConcurrency is not a number — treating as 1`);
+            effectiveMaxConcurrency = 1;
+        }
+        else if (!Number.isSafeInteger(hostMaxConcurrency)) {
+            if (Number.isInteger(hostMaxConcurrency)) {
+                warnings.push(`host dispatch.maxConcurrency is an unsafe integer — treating as 1`);
+            }
+            else {
+                warnings.push(`host dispatch.maxConcurrency is not an integer — treating as 1`);
+            }
+            effectiveMaxConcurrency = 1;
+        }
+        else {
+            warnings.push(`host dispatch.maxConcurrency is non-positive — treating as 1`);
+            effectiveMaxConcurrency = 1;
+        }
         // If namedDispatch is false, cap maxDepth/nested/background/backgroundDispatch to 0/false/false/false (struct consistency)
         if (!effectiveNamedDispatch) {
             effectiveMaxDepth = 0;
@@ -424,6 +474,7 @@ function negotiateHostCapabilities(host, engine = DEFAULT_ENGINE) {
         subagentToolkit: effectiveSubagentToolkit,
         backgroundDispatch: effectiveBackgroundDispatch,
         isolation: effectiveIsolation,
+        maxConcurrency: effectiveMaxConcurrency,
     };
     // ---------------------------------------------------------------------------
     // Assemble effective axes
@@ -753,6 +804,7 @@ module.exports = {
     EXTENSION_EVENT_SURFACES,
     degradationFor,
     profileOf,
+    isPositiveSafeInteger,
     negotiateHostCapabilities,
     shouldFlattenDispatch,
     resolveDispatchType,

package/gsd-core/bin/lib/init-command-router.cjs

@@ -158,6 +158,20 @@ function routeInitCommand({ init, args, cwd, raw, error }) {
                     full: namedArgs['full'],
                 });
             },
+            // #3676 (Phase 4, epic #3344): `init.quick-batch` supplies model
+            // profiles/commit_docs/roadmap-existence/section_manifest — batch
+            // creation itself is the `quick-batch create` verb's job (wraps
+            // `createBatch`, src/quick-batch.cts). No free-text description to
+            // strip: `--research`/`--validate` are the only recognized flags
+            // (`--discuss`/`--full` are rejected upstream by `parseQuickBatchArgs`
+            // before this init bundle is ever reached).
+            'quick-batch': () => {
+                const namedArgs = (0, command_arg_projection_cjs_1.parseNamedArgsOrExit)(args, { booleanFlags: ['research', 'validate'], positionals: 2 }, error);
+                init.cmdInitQuickBatch(cwd, raw, {
+                    research: namedArgs['research'],
+                    validate: namedArgs['validate'],
+                });
+            },
             'ingest-docs': () => init.cmdInitIngestDocs(cwd, raw),
             resume: () => init.cmdInitResume(cwd, raw),
             // ADR-3473 §8.4 / #3358 gap: these handlers read args[2] positionally