* test(#2871): failing-first suite for trigger-surface resolution 23 tests over the 50-test-matrix rows. RED by construction: resolveTriggerSurface and DEFAULT_TRIGGER_PRECEDENCE do not exist yet, and the validator silently ignores triggerPrecedence today. Written in the per-runtime describe idiom the other four runtime-artifact-layout suites use, not a table. The rows that carry the weight: windsurf must NOT report a shadow it does not have, since its global scope emits only agents and agents are not trigger-bearing; agents and kimi-agents must be absent from the output for every runtime; and reordering a runtime's triggerPrecedence must flip the winner, which is the only assertion that proves the axis is read rather than decorative. Stems are injected, never scanned, so the surface is assertable with no filesystem. * feat(#2871): resolve triggers and host precedence, not just placement resolveTriggerSurface(runtime, scopes) returns every /gsd-<name> trigger a runtime emits, with the scope and kind that produced it, whether the host registers it directly or only through a router, and which artifact shadows it. resolveRuntimeArtifactLayout is untouched -- its 7 callers need placement only and the issue requires them unchanged. AGENTS ARE NOT TRIGGER-BEARING, and ADR-2866 said they were. The host-integration matrix models command and dispatch as separate interface points: an agent is invoked through the Agent tool's subagent_type, not by typing a slash trigger, and _copyStaged never applies the kind prefix to an agents entry. So agents and kimi-agents are excluded from the surface entirely, and this commit amends ADR-2866 with a dated correction. #2218's conclusion is unchanged -- the collision is strictly commands-vs-skills, and claude's local /gsd-* trigger surface is still fully shadowed -- but the ADR implied the local agents surface was lost too, and it is not. That correction is what makes windsurf come out right. Its global scope emits only agents, so it has no global trigger and its local commands are unshadowed. Model agents as trigger-bearing and windsurf falsely reports a full shadow. The triggerPrecedence axis lands on all 19 descriptors as an ordered kind list, one value with one owner, rather than a numeric rank spread across N kind entries with nothing keeping them consistent. Validation uses a required-with-default shape that has no precedent in this validator -- every existing axis is hard-required -- so a third-party capability.json omitting the field still validates, which is what ADR-894's additive-only contract promises. Winner resolution reads Phase 1's scope rank first, then the kind ordering. A test reorders the axis and asserts the winner flips, since an axis that is added, validated and never consulted would pass every other assertion. shadowedBy ships unread. Phase 4 (#2873) is its first consumer, per this issue's out-of-scope note. Verified via the remote runner. * fix(#2871): single-source namespacedByDir and close two test gaps Four findings from the isolated adversarial review. The namespacedByDir rule had reached three copies -- install-engine, surface, and the new trigger resolver -- one of which carried a hand-written keep-in-sync comment and no assertion. That is this repo's generative-fix-divergence class. Extracted to one exported predicate all three now call. Verified by diverging one copy deliberately: the existing #816 parity test failed, and passes again on revert. The omission test was vacuous. Row 16 asserted that a descriptor without triggerPrecedence still validates, but built its fixture from claude's shipped descriptor -- which this PR had just added the axis to. It now clones and deletes the key, following the shippedDescriptorWithout pattern, and asserts both that validation passes and that the resolver still picks the right winner from the default. The second half is what makes it prove anything. resolveTriggerSurface silently dropped an unrecognized scope while every sibling in this epic throws. Two phases of one epic should not disagree about whether an invalid scope is an error, so it now rejects through the same shared validator; an empty scope list still returns empty rather than throwing. The ADR amendment had been spliced into the middle of the References list, orphaning its last bullet. Moved to the top, after the header block, which is where ADR-3660 and ADR-1016 both put dated amendments. No lint checks markdown structure, so this was green while malformed. * fix(#2871): single-source the command filename composition too The earlier fix shared the namespacedByDir boolean but left the filename composition around it written twice -- once in _copyStaged as what actually gets written, once in resolveTriggerSurface as what gets predicted. The predictor could go stale silently. One exported helper now composes it for both. The entry.name asymmetry that looked like it would block extraction does not: entry.name is filtered to end in .md and stem is entry.name minus those three characters, so the two branches are the same string by construction. Divergence proven to fail: injecting a marker into the helper broke the trigger-surface suite; reverting restored 25/25. The four sibling layout suites hold at 227 unchanged. * docs(#2871): correct the ADR timing notes that this phase makes stale The Amended by back-links on ADR-3660 and ADR-1016 were written in Phase 0, when the widenings they describe had not shipped. Each carried a forward-looking clause -- "the module changes at Phase 2, not before, until then this module resolves placement only" -- which becomes false the moment this PR merges. ADR-2866's own Amends header and its reciprocal-notes section carried the same tense. All four now describe what shipped. This is a tense and status correction on Accepted ADRs, not a change to any decision. Worth stating because it is the failure mode this epic keeps meeting: gen-adr-index.cjs tracks only Supersedes and Subsumes, so nothing in CI would have caught either the missing back-link in Phase 0 or these stale clauses now. They stay correct only because someone checks. * chore(#2871): backfill changeset PR number --------- Co-authored-by: sim <sim@local>
This commit is contained in:
Tom Boucher
@@ -461,9 +461,10 @@ function _copyStaged(stagedDir: string, destDir: string, kind: any, configDir: s
|
||||
const entries = fs.readdirSync(stagedDir, { withFileTypes: true });
|
||||
// For commands: apply prefix unless the destSubpath's last segment already
|
||||
// represents the GSD namespace (e.g. 'commands/gsd' → last segment 'gsd').
|
||||
const destLast = path.basename(kind.destSubpath);
|
||||
const prefixStem = kind.prefix ? kind.prefix.replace(/-$/, '') : '';
|
||||
const namespacedByDir = kind.kind === 'commands' && destLast === prefixStem;
|
||||
// Single source of truth: runtimeArtifactLayout.isNamespacedByDir (#2871
|
||||
// Phase 2 review finding — this rule previously drifted independently
|
||||
// across install-engine.cts / surface.cts / runtime-artifact-layout.cts).
|
||||
const namespacedByDir = runtimeArtifactLayout.isNamespacedByDir(kind.kind, kind.destSubpath, kind.prefix);
|
||||
|
||||
for (const entry of entries) {
|
||||
if (!entry.isFile()) continue;
|
||||
@@ -481,12 +482,14 @@ function _copyStaged(stagedDir: string, destDir: string, kind: any, configDir: s
|
||||
destName = _agentExt
|
||||
? entry.name.replace(/\.md$/, _agentExt)
|
||||
: entry.name;
|
||||
} else if (namespacedByDir) {
|
||||
// Directory is the namespace; don't double-prefix the filename
|
||||
destName = entry.name;
|
||||
} else {
|
||||
// Flat commands directory (e.g. command/ for opencode/kilo)
|
||||
destName = `${kind.prefix}${stem}.md`;
|
||||
// Commands: filename composition (namespacedByDir ? `${stem}.md` :
|
||||
// `${prefix}${stem}.md`) is single-sourced with resolveTriggerSurface's
|
||||
// destPath prediction via composeCommandFilename (#2871 Phase 2 review
|
||||
// finding). Byte-identical to the prior separate namespacedByDir/flat
|
||||
// branches — see that helper's doc comment for why the namespacedByDir
|
||||
// case reconstructing `${stem}.md` is always exactly `entry.name`.
|
||||
destName = runtimeArtifactLayout.composeCommandFilename(namespacedByDir, kind.prefix, stem);
|
||||
}
|
||||
|
||||
fs.copyFileSync(path.join(stagedDir, entry.name), path.join(destDir, destName));
|
||||
|
||||
@@ -115,12 +115,15 @@ export interface ResolveScopeInput {
|
||||
const VALID_SCOPE_IDS: ReadonlySet<string> = new Set(['global', 'local']);
|
||||
|
||||
/**
|
||||
* Single owner of the `'global' | 'local'` membership check. `resolveScope`
|
||||
* and `isGlobalScope` (below) both call this instead of each carrying its
|
||||
* own copy of the rule — two surfaces reading one validator, not two
|
||||
* validators that could silently diverge.
|
||||
* Single owner of the `'global' | 'local'` membership check. `resolveScope`,
|
||||
* `isGlobalScope`, `scopeRank`, and `resolveTriggerSurface`
|
||||
* (`runtime-artifact-layout.cts`, #2871 Phase 2) all call this instead of
|
||||
* each carrying its own copy of the rule — one validator every scope-typed
|
||||
* seam reads, not N validators that could silently diverge. Exported so a
|
||||
* sibling module can reuse it directly rather than re-deriving the same
|
||||
* membership check a second time.
|
||||
*/
|
||||
function validateScopeId(id: unknown, caller: string): InstallScope {
|
||||
export function validateScopeId(id: unknown, caller: string): InstallScope {
|
||||
if (typeof id !== 'string' || !VALID_SCOPE_IDS.has(id)) {
|
||||
throw new TypeError(
|
||||
`${caller}: id must be one of 'global' | 'local', got ${JSON.stringify(id)}`,
|
||||
@@ -319,3 +322,19 @@ export function resolveScope(input: ResolveScopeInput): ResolvedScope {
|
||||
export function isGlobalScope(scope: InstallScope): boolean {
|
||||
return validateScopeId(scope, 'isGlobalScope') === 'global';
|
||||
}
|
||||
|
||||
/**
|
||||
* Project a bare `InstallScope` down to its `hostPrecedenceRank` — the SAME
|
||||
* `HOST_PRECEDENCE_RANK` table `resolveScope`'s `ResolvedScope.hostPrecedenceRank`
|
||||
* field reads, exposed standalone so a caller that only needs the ranking (not a
|
||||
* full config-home resolution, which touches the filesystem via
|
||||
* `resolveConfigHomeFromDescriptor`) never has to re-derive `{global: 2, local:
|
||||
* 1}` as a second copy of the same fact. First consumer: `resolveTriggerSurface`
|
||||
* (`runtime-artifact-layout.cts`, #2871 Phase 2), which is documented pure — no
|
||||
* filesystem — so it cannot call `resolveScope` itself. Same validation/error
|
||||
* contract as `resolveScope` / `isGlobalScope`: all three share `validateScopeId`,
|
||||
* so an out-of-union `id` throws the same `TypeError` shape everywhere.
|
||||
*/
|
||||
export function scopeRank(id: InstallScope): number {
|
||||
return HOST_PRECEDENCE_RANK[validateScopeId(id, 'scopeRank')];
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ import { posixNormalize } from './shell-command-projection.cjs';
|
||||
// projection both kind-builder closures below need at the converters'
|
||||
// positional `isGlobal` boundary (see its doc comment in install-scope.cts
|
||||
// for why the projection is centralized rather than eliminated).
|
||||
import { isGlobalScope } from './install-scope.cjs';
|
||||
import { isGlobalScope, scopeRank, validateScopeId, type InstallScope } from './install-scope.cjs';
|
||||
|
||||
// In .cts (CommonJS output) files, `require` is available as a global.
|
||||
const _require: NodeRequire = require;
|
||||
@@ -610,5 +610,289 @@ function resolveRuntimeArtifactLayoutFromRegistry(
|
||||
return { runtime, configDir, scope, kinds };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// resolveTriggerSurface (#2871 Phase 2)
|
||||
// ---------------------------------------------------------------------------
|
||||
//
|
||||
// Widens this module from PLACEMENT (resolveRuntimeArtifactLayout, above —
|
||||
// untouched, still 7 callers) to TRIGGER resolution: "what does a user type"
|
||||
// rather than "where does a file land". A new function, not a widened
|
||||
// signature — see .gsd/phase/feat-2871-trigger-resolution/40-design.md.
|
||||
//
|
||||
// Only `commands` and `skills` are trigger-bearing. `agents` / `kimi-agents`
|
||||
// are a SEPARATE dispatch interface point (subagent invocation via
|
||||
// `subagent_type` / named dispatch, never a `/gsd-<name>` a user types) — see
|
||||
// 40-design.md's "agents are not trigger-bearing" correction to ADR-2866.
|
||||
// Excluding them here is deliberate, not an oversight: including `agents`
|
||||
// would misreport windsurf (whose global scope emits agents only) as fully
|
||||
// shadowing its local `/gsd-*` surface, when in fact nothing shadows it.
|
||||
|
||||
/** The trigger-bearing subset of ArtifactKindName — mirrors
|
||||
* VALID_TRIGGER_PRECEDENCE_KINDS in capability-validator.cjs (kept as two
|
||||
* literal-typed surfaces rather than importing a runtime Set into a type
|
||||
* position; tests assert the two vocabularies parity-match via
|
||||
* DEFAULT_TRIGGER_PRECEDENCE). */
|
||||
type TriggerKindName = 'commands' | 'skills';
|
||||
|
||||
/** 'direct': the host itself registers this trigger. 'via-router': only the
|
||||
* owning router is registered by the host; this trigger is reachable
|
||||
* because the router's body was rewritten to `Read` it (#69 nested-skill
|
||||
* bundles — install-profiles.cts:714-723). See 40-design.md's "Nested-router
|
||||
* children" section for why a boolean cannot carry this distinction.
|
||||
*
|
||||
* Not `export`ed: matches this file's existing house style (`Layout`,
|
||||
* `ArtifactKind`, etc. are internal types too) — `export =` at the bottom
|
||||
* of this module is its sole export surface, and mixing it with named type
|
||||
* exports is unnecessary since the only external consumer of these shapes
|
||||
* is a plain-JS test file. */
|
||||
type TriggerRegistration = 'direct' | 'via-router';
|
||||
|
||||
interface TriggerShadower {
|
||||
kind: TriggerKindName;
|
||||
scope: InstallScope;
|
||||
}
|
||||
|
||||
interface TriggerSurface {
|
||||
/** What the user types, e.g. `gsd-plan-phase`. Always `${prefix}${stem}` —
|
||||
* unaffected by the destPath branch below (see `destPath`). */
|
||||
trigger: string;
|
||||
kind: TriggerKindName;
|
||||
scope: InstallScope;
|
||||
/** Where the artifact is staged, mirroring `_copyStaged`'s actual write
|
||||
* (`install-engine.cts:404-493`) INCLUDING its `namespacedByDir` branch
|
||||
* (~L464-466): a `commands` kind whose `destSubpath` basename equals
|
||||
* `prefix` minus its trailing hyphen is written bare (no prefix on the
|
||||
* filename) because the directory itself is the namespace. */
|
||||
destPath: string;
|
||||
registration: TriggerRegistration;
|
||||
/** The owning router's trigger string, only when `registration ===
|
||||
* 'via-router'`; `null` otherwise (including for the router's own entry —
|
||||
* a router has no router of its own). */
|
||||
routerTrigger: string | null;
|
||||
/** The winning sibling entry for this SAME trigger, or `null` when this
|
||||
* entry is itself unshadowed (including when it is the only candidate).
|
||||
* Reported as a fact, never a defect — see 40-design.md's "Not-corruption"
|
||||
* section: same-kind shadowing across scopes is the healthy, expected
|
||||
* state for every both-scope runtime. */
|
||||
shadowedBy: TriggerShadower | null;
|
||||
}
|
||||
|
||||
interface TriggerSurfaceOpts {
|
||||
/** Source command/skill stems present for this call, shared across every
|
||||
* trigger-bearing kind entry — mirrors ResolvedProfile's flat stem
|
||||
* membership at staging time (install-profiles.cts). */
|
||||
stems: string[];
|
||||
/** Subset of `stems` that are namespace routers (nested-router runtimes
|
||||
* only, #69). Absent or empty ⇒ no nested-router distinction is made —
|
||||
* every stem resolves `registration: 'direct'`, matching the caller's own
|
||||
* choice not to supply router membership. */
|
||||
routerStems?: string[];
|
||||
/** Concrete stem -> owning router stem(s); mirrors
|
||||
* buildNamespaceBundleMap's childToRouters shape. Only consulted for a
|
||||
* stem that is NOT itself in `routerStems`, on a `nesting: 'nested'` kind
|
||||
* entry. The first named router is used. */
|
||||
childToRouters?: Record<string, string[]>;
|
||||
/** Registry override — the SAME seam resolveRuntimeArtifactLayoutFromRegistry
|
||||
* already exposes. Lets a synthetic descriptor be exercised without
|
||||
* touching the real capability-registry. */
|
||||
registry?: TriggerRegistryLike;
|
||||
}
|
||||
|
||||
interface RuntimeDescriptorForTriggers {
|
||||
artifactLayout?: ArtifactLayoutDescriptor;
|
||||
/** Ordered kind precedence, highest priority first (#2871 Phase 2). Absent
|
||||
* ⇒ capability-validator.cjs's DEFAULT_TRIGGER_PRECEDENCE applies — see
|
||||
* `getDefaultTriggerPrecedence` below. */
|
||||
triggerPrecedence?: string[];
|
||||
}
|
||||
|
||||
interface TriggerRegistryLike {
|
||||
runtimes: Record<string, { runtime?: RuntimeDescriptorForTriggers }>;
|
||||
}
|
||||
|
||||
function getTriggerRegistry(): TriggerRegistryLike {
|
||||
return _require('./capability-registry.cjs') as TriggerRegistryLike;
|
||||
}
|
||||
|
||||
/**
|
||||
* capability-validator.cjs is a COMMITTED plain .cjs (not built from a .cts
|
||||
* source — see its own header comment), so it is required the same way
|
||||
* capability-registry.cjs is above: a lazy `_require` rather than a static
|
||||
* ES import. DEFAULT_TRIGGER_PRECEDENCE is the single source of truth for
|
||||
* "what applies when a descriptor omits triggerPrecedence"; this module
|
||||
* reads it rather than re-declaring `['skills', 'commands']` as a second
|
||||
* literal that could silently drift from the validator's own default.
|
||||
*/
|
||||
function getDefaultTriggerPrecedence(): string[] {
|
||||
const capValidator = _require('./capability-validator.cjs') as { DEFAULT_TRIGGER_PRECEDENCE: string[] };
|
||||
return capValidator.DEFAULT_TRIGGER_PRECEDENCE;
|
||||
}
|
||||
|
||||
const SCOPE_ORDER: readonly InstallScope[] = ['global', 'local'];
|
||||
|
||||
/**
|
||||
* True when a `commands` kind entry is namespaced by its destination
|
||||
* directory rather than by a filename prefix — i.e. `destSubpath`'s basename
|
||||
* equals `prefix` with its trailing hyphen stripped (e.g. `commands/gsd` +
|
||||
* `gsd-`). When true, `_copyStaged` (`install-engine.cts`) and `surface.cts`
|
||||
* both write the bare stem filename (no prefix) because the directory itself
|
||||
* already carries the namespace; `resolveTriggerSurface` mirrors that in its
|
||||
* own `destPath` computation. Single source of truth for the three sites
|
||||
* that used to compute this independently (#2871 Phase 2 review finding) —
|
||||
* a new caller MUST reuse this rather than re-deriving the rule.
|
||||
*/
|
||||
function isNamespacedByDir(kind: string, destSubpath: string, prefix: string): boolean {
|
||||
const destLast = path.posix.basename(posixNormalize(destSubpath));
|
||||
const prefixStem = prefix ? prefix.replace(/-$/, '') : '';
|
||||
return kind === 'commands' && destLast === prefixStem;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compose the destination filename `_copyStaged` (install-engine.cts) writes
|
||||
* for a `commands` kind entry, given `isNamespacedByDir`'s result, the
|
||||
* kind's prefix, and the file's `.md`-stripped stem. Single source of truth
|
||||
* alongside `isNamespacedByDir` for the FILENAME COMPOSITION itself (#2871
|
||||
* Phase 2 review finding — the boolean was single-sourced first, but the
|
||||
* `${stem}.md` / `${prefix}${stem}.md` string-building around it stayed
|
||||
* duplicated between `_copyStaged` and `resolveTriggerSurface`'s `destPath`
|
||||
* prediction below, so a divergence in the write convention would not have
|
||||
* failed anything).
|
||||
*
|
||||
* Byte-identical to `_copyStaged`'s prior separate branches: when
|
||||
* `namespacedByDir` is true this returns `${stem}.md`. `_copyStaged` always
|
||||
* derives `stem` as `entry.name.slice(0, -3)` for an `entry.name` that has
|
||||
* already been filtered to end in `.md`, so `${stem}.md` is always exactly
|
||||
* `entry.name` again — `_copyStaged` can pass this helper's result in place
|
||||
* of the `entry.name` it used to write directly, with no behavior change.
|
||||
*/
|
||||
function composeCommandFilename(namespacedByDir: boolean, prefix: string, stem: string): string {
|
||||
return namespacedByDir ? `${stem}.md` : `${prefix}${stem}.md`;
|
||||
}
|
||||
|
||||
/**
|
||||
* True when candidate `a` should win over the current best `b` for the same
|
||||
* trigger. Scope rank first (Phase 1's `install-scope.cts#scopeRank` —
|
||||
* global outranks local; NOT re-derived here), then the runtime's
|
||||
* `triggerPrecedence` kind ordering (lower index = higher priority). A kind
|
||||
* absent from `precedenceRank` (should not happen — every entry's kind is
|
||||
* validated against the same closed vocabulary the precedence list draws
|
||||
* from) sorts last rather than throwing, so a malformed precedence value
|
||||
* degrades to "leaves the incumbent standing" instead of corrupting the
|
||||
* whole resolution.
|
||||
*/
|
||||
function isHigherPriority(a: TriggerSurface, b: TriggerSurface, precedenceRank: Map<string, number>): boolean {
|
||||
const rankA = scopeRank(a.scope);
|
||||
const rankB = scopeRank(b.scope);
|
||||
if (rankA !== rankB) return rankA > rankB;
|
||||
const pa = precedenceRank.get(a.kind) ?? Number.POSITIVE_INFINITY;
|
||||
const pb = precedenceRank.get(b.kind) ?? Number.POSITIVE_INFINITY;
|
||||
return pa < pb;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve the `/gsd-<name>`-style trigger surface for a runtime: what the
|
||||
* user types, at which scope, whether it wins or is shadowed, and (for
|
||||
* nested-router runtimes) whether the host registers it directly or only
|
||||
* reaches it through a router. Pure — no filesystem, no mutation of `scopes`
|
||||
* or `opts`, and safe against a caller mutating the returned array/objects
|
||||
* (a fresh array/objects are built on every call; nothing is cached or
|
||||
* shared across calls beyond the read-only registry module).
|
||||
*
|
||||
* Only `commands` and `skills` kind entries are considered — see the
|
||||
* module-level comment above. `resolveRuntimeArtifactLayout` is untouched by
|
||||
* this function; they are independent readers of the same descriptor.
|
||||
*
|
||||
* @throws {TypeError} for an unknown runtime — same contract (and message
|
||||
* shape) as `resolveRuntimeArtifactLayoutFromRegistry`.
|
||||
* @throws {TypeError} for an unrecognized entry in `scopes` — reuses
|
||||
* `install-scope.cts`'s shared `validateScopeId`, the same validator
|
||||
* `scopeRank`/`resolveScope`/`isGlobalScope` already throw through, so this
|
||||
* sibling of theirs cannot silently fail open on a bad scope (#2871 Phase 2
|
||||
* review finding). `scopes: []` is untouched — an empty array has no
|
||||
* entries to validate and still resolves to `[]`.
|
||||
*/
|
||||
function resolveTriggerSurface(runtime: string, scopes: InstallScope[], opts: TriggerSurfaceOpts): TriggerSurface[] {
|
||||
const registry = opts.registry ?? getTriggerRegistry();
|
||||
const runtimeDescriptor = registry.runtimes[runtime]?.runtime;
|
||||
const layout = runtimeDescriptor?.artifactLayout;
|
||||
if (!layout) {
|
||||
throw new TypeError(`Unknown runtime: '${runtime}' — add to runtime-artifact-layout.cjs table`);
|
||||
}
|
||||
|
||||
for (const scope of scopes) {
|
||||
validateScopeId(scope, 'resolveTriggerSurface');
|
||||
}
|
||||
|
||||
const scopeSet = new Set(scopes);
|
||||
const stems = opts.stems ?? [];
|
||||
const routerStemSet = new Set(opts.routerStems ?? []);
|
||||
const childToRouters = opts.childToRouters ?? {};
|
||||
const precedence = runtimeDescriptor?.triggerPrecedence ?? getDefaultTriggerPrecedence();
|
||||
const precedenceRank = new Map(precedence.map((kind, index) => [kind, index]));
|
||||
|
||||
const surfaces: TriggerSurface[] = [];
|
||||
|
||||
for (const scope of SCOPE_ORDER) {
|
||||
if (!scopeSet.has(scope)) continue;
|
||||
const entries = layout[scope] ?? [];
|
||||
for (const entry of entries) {
|
||||
if (entry.kind !== 'commands' && entry.kind !== 'skills') continue; // excludes agents/kimi-agents
|
||||
const kind = entry.kind;
|
||||
const destSubpath = posixNormalize(entry.destSubpath);
|
||||
const namespacedByDir = isNamespacedByDir(kind, entry.destSubpath, entry.prefix);
|
||||
const nested = entry.nesting === 'nested';
|
||||
|
||||
for (const stem of stems) {
|
||||
const trigger = `${entry.prefix}${stem}`;
|
||||
let destPath: string;
|
||||
if (kind === 'skills') {
|
||||
destPath = `${destSubpath}/${entry.prefix}${stem}`;
|
||||
} else {
|
||||
destPath = `${destSubpath}/${composeCommandFilename(namespacedByDir, entry.prefix, stem)}`;
|
||||
}
|
||||
|
||||
let registration: TriggerRegistration = 'direct';
|
||||
let routerTrigger: string | null = null;
|
||||
if (nested && routerStemSet.size > 0 && !routerStemSet.has(stem)) {
|
||||
const owningRouters = childToRouters[stem];
|
||||
const routerStem = owningRouters && owningRouters.length > 0 ? owningRouters[0] : undefined;
|
||||
if (routerStem !== undefined && routerStemSet.has(routerStem)) {
|
||||
registration = 'via-router';
|
||||
routerTrigger = `${entry.prefix}${routerStem}`;
|
||||
}
|
||||
}
|
||||
|
||||
surfaces.push({ trigger, kind, scope, destPath, registration, routerTrigger, shadowedBy: null });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Winner computation, per trigger string, across every scope/kind candidate.
|
||||
const groups = new Map<string, TriggerSurface[]>();
|
||||
for (const surface of surfaces) {
|
||||
const group = groups.get(surface.trigger);
|
||||
if (group) {
|
||||
group.push(surface);
|
||||
} else {
|
||||
groups.set(surface.trigger, [surface]);
|
||||
}
|
||||
}
|
||||
for (const group of groups.values()) {
|
||||
if (group.length <= 1) continue; // sole candidate: unshadowed by construction
|
||||
let winner = group[0];
|
||||
for (let i = 1; i < group.length; i++) {
|
||||
const candidate = group[i];
|
||||
if (isHigherPriority(candidate, winner, precedenceRank)) winner = candidate;
|
||||
}
|
||||
for (const surface of group) {
|
||||
if (surface !== winner) {
|
||||
surface.shadowedBy = { kind: winner.kind, scope: winner.scope };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return surfaces;
|
||||
}
|
||||
|
||||
// getInstallExports removed in ADR-1508 / #1511 Phase 2 (last upward .cts→install.js dep).
|
||||
export = { resolveRuntimeArtifactLayout, resolveRuntimeArtifactLayoutFromRegistry, findInstallSourceRoot };
|
||||
export = { resolveRuntimeArtifactLayout, resolveRuntimeArtifactLayoutFromRegistry, findInstallSourceRoot, resolveTriggerSurface, isNamespacedByDir, composeCommandFilename };
|
||||
|
||||
@@ -625,13 +625,11 @@ function _syncGsdDir(stagedDir: string, destDir: string, kind: ArtifactKind | st
|
||||
// from install and orphaned the installed gsd-*.md files, and the unscoped
|
||||
// prune deleted user-owned command files.
|
||||
//
|
||||
// NOTE: the destName rule below intentionally mirrors bin/install.js
|
||||
// `_copyStaged` (the `namespacedByDir` decision). Keep them in sync.
|
||||
const destLast = (typeof kind === 'object' && kind !== null && kind.destSubpath)
|
||||
? path.basename(kind.destSubpath)
|
||||
: '';
|
||||
const prefixStem = kindPrefix ? kindPrefix.replace(/-$/, '') : '';
|
||||
const namespacedByDir = kindName === 'commands' && destLast === prefixStem;
|
||||
// Single source of truth: runtimeArtifactLayout.isNamespacedByDir (#2871
|
||||
// Phase 2 review finding — this rule previously drifted independently
|
||||
// across install-engine.cts / surface.cts / runtime-artifact-layout.cts).
|
||||
const kindDestSubpath = (typeof kind === 'object' && kind !== null && kind.destSubpath) ? kind.destSubpath : '';
|
||||
const namespacedByDir = runtimeArtifactLayout.isNamespacedByDir(kindName, kindDestSubpath, kindPrefix);
|
||||
|
||||
const stagedFiles = fs.readdirSync(stagedDir).filter(f => f.endsWith('.md'));
|
||||
const stagedDestNames = new Set<string>();
|
||||
|
||||
Reference in New Issue
Block a user