The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
chore: merge main into context citation fix
Yann Roberto298ac253302e
diff --cc scripts/lib/context-selection.jsindex 66381519f,6a925c033..5a642d455--- a/scripts/lib/context-selection.js+++ b/scripts/lib/context-selection.js@@@ -26,139 -26,28 +26,156 @@@ const AUTO_ADMIT_MARGIN = 1.5const FALLBACK_MIN_BM25 = 12;const FALLBACK_MIN_TERMS = 2;const FALLBACK_MARGIN = 1.1;++ // Adapted from contributor PR #3480: rankings become suggestions only when+ // an exact name or the fallback's absolute evidence floor supports them.+ function meetsFallbackBar(candidate) {+ return Boolean(candidate && candidate.bm25 >= FALLBACK_MIN_BM25+ && Array.isArray(candidate.matchedTerms) && candidate.matchedTerms.length >= FALLBACK_MIN_TERMS);+ }++ function hasSuggestionEvidence(candidate) {+ return Boolean(candidate && (candidate.exact || meetsFallbackBar(candidate)));+ }++ // Both tiers also require at least one matched term in the skill's name or+ // curated triggers. Description-only overlap on common words (two, both, same)+ // can clear the score bars without naming the skill's subject.+ const MIN_ANCHOR_TERMS = 1;// v4: an explicit empty proposal (decline) is honored; the tier-2 fallback no// longer overrides declines at the launch/selection call sites.-// v5: implicit admission requires a name or trigger anchor term.-const ROUTING_POLICY_VERSION = 5;+// v5: indirect name citations cannot bypass review through exact or scored admission.+// v6: ordered directives and singular named references share the same admission guard.+// v7: independent directives scope negation and imperatives allow question punctuation.+// v8: only recognized request/rejection scopes can authorize coordinated directives.+// v9: neutral task preambles do not suppress a later explicit skill request.+// v10: illustrative instructions do not supply or withdraw a direct request.+// v11: a contrastive current-task instruction ends the preceding example scope.- const ROUTING_POLICY_VERSION = 11;++// v12: preserve current-main evidence floors and anchor checks.++const ROUTING_POLICY_VERSION = 12;const TASK_KEYS = new Set(['sessionId', 'taskId', 'revision', 'phase', 'query', 'explicitIds', 'proposedIds', 'noWorkflow']);+const DIRECTIVE_VERB = /\b(use|apply|invoke|run|follow|load)\s+(the\s+)?/i;+const DIRECTIVE_REQUEST = /^(?:please )?(?:(?:can|could|would|will) you (?:please )?|do )?(?:use|apply|invoke|run|follow|load)\b/;+const DIRECTIVE_REJECTION = /^(?:please )?(?:(?:(?:do )?not|never) (?:use|apply|invoke|run|follow|load)\b|avoid\b)/;+const DIRECTIVE_NAME_PREFIX = new RegExp(DIRECTIVE_REQUEST.source + '\\s+(?:the\\s+)?(?:skill\\s*)?$');+const QUESTION_START = /^(?!do not\b)(can|could|would|should|shall|will|may|might|must|ought|do|does|did|is|are|why|how|what|when|where|which)\b/;+const REPORTED_INSTRUCTION = /\b(say|says|said|reads|told|mentions?|quoted?|document|states?|stated|recommends?|recommended|asserts?|asserted)\b/;+const EXAMPLE_PREFIX = /^(?:for (?:example|instance)|as an example|to illustrate)\b/;+const CURRENT_TASK_SUFFIX = /\bfor (?:this|the current) task$/;+// Subject-led statements may describe someone else's instructions or intentions.+const SUBJECT_PREFIX = /^(?:the|a|an|i|you|he|she|it|we|they|my|your|his|her|its|our|their|this|that|these|those)\b/;+// Rejections keep their whole list until another instruction/question begins.+const INSTRUCTION_BOUNDARY = /(?:,\s*(?:(?:and|but)\s+)?|\s+(?:and|but)\s+)(?=(?:please\s+)?(?:do\s+(?:not\s+)?|not\s+|never\s+)?(?:use|apply|invoke|run|follow|load)\b|(?:can|could|would|should|shall|will|may|might|must|ought|do|does|did|is|are|why|how|what|when|where|which)\b)/i;+// Admission additionally checks intervening scopes, including unknown wording.+const ADMISSION_BOUNDARY = /(?:,\s*(?:(?:and|but)\s+)?|\s+(?:and|but)\s+)(?=\S)/i;++/** Track example spans without discarding the connectors between instructions.+ * A contrast inside an example remains illustrative unless its instruction+ * explicitly addresses the current task. Earlier non-example scopes stay intact.+ * @param {string} text Normalized clause with comma boundaries preserved.+ * @param {string[]} names Known candidate aliases whose internal connectors are names.+ * @returns {Array<{start: number, text: string, example: boolean}>} Ordered scopes.+ */+function citationScopes(text, names) {+ const mentions = names.flatMap(name => [...text.matchAll(new RegExp('\\b' + name + '\\b', 'g'))]+ .map(mention => ({ start: mention.index, end: mention.index + name.length })));+ const boundaries = [...text.matchAll(new RegExp(ADMISSION_BOUNDARY.source, 'gi'))]+ .filter(boundary => !mentions.some(mention => boundary.index > mention.start && boundary.index < mention.end));+ let example = false;+ return [0, ...boundaries.map(boundary => boundary.index + boundary[0].length)].map((start, index) => {+ const scope = text.slice(start, boundaries[index]?.index ?? text.length);+ const currentTask = CURRENT_TASK_SUFFIX.test(scope)+ && (DIRECTIVE_REQUEST.test(scope) || DIRECTIVE_REJECTION.test(scope));+ if (currentTask && /\bbut\b/.test(boundaries[index - 1]?.[0] || '')) example = false;+ if (EXAMPLE_PREFIX.test(scope)) example = true;+ return { start, text: scope, example };+ });+}++/** Normalize citation names while preserving contracted negation as a separate word.+ * @param {string} text Raw query text or a registry alias.+ * @returns {string} Lowercase alphanumeric words with negation preserved.+ */+const normalizedQueryName = text => text.replace(/n['\u2019]t\b/gi, ' not')+ .replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/_/g, ' ')+ .toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();++/** Return canonical/native aliases plus conservative singular forms. Singular+ * multiword aliases only guard indirect references; they never create exact admission.+ * @param {object} candidate Ranked skill candidate with its canonical ID and exact alias.+ * @param {string} nativeName Registry name that may be absent from exact retrieval.+ * @returns {Array<{name: string, exact: boolean}>} Normalized names and admission eligibility.+ */+function citationAliases(candidate, nativeName) {+ const names = [...new Set([candidate.exactAlias, candidate.id.slice('skill:'.length), nativeName]+ .filter(Boolean).map(normalizedQueryName).filter(Boolean))];+ return names.flatMap(name => [{ name, exact: true },+ ...(/\s\w+[^s]s$/.test(name) ? [{ name: name.slice(0, -1), exact: false }] : [])]);+}++/** Classify a retrieval candidate's references in query order. Genuine later+ * directives/rejections replace earlier instructions; questions, quotations and+ * reported speech do not withdraw a directive. Returns directive, indirect or none.+ * @param {object} candidate Ranked skill candidate with its canonical ID and exact alias.+ * @param {string} query Task text to classify without loading skill contents.+ * @param {string} nativeName Registry name, including aliases absent from exact retrieval.+ * @param {string[]} names All candidate aliases, used to preserve names across scopes.+ * @returns {'directive'|'indirect'|'none'} Admission evidence for this skill only.+ */+function citationFor(candidate, query, nativeName, names) {+ const aliases = citationAliases(candidate, nativeName);+ let citation = 'none';+ // Mask quoted instructions before splitting clauses so punctuation inside a+ // quotation cannot look like a separate instruction. Quoted names remain usable.+ const unquoted = query.replace(/"[^"]*"|\u201c[^\u201d]*\u201d|(?:^|[\s(:])'[^']*'|\u2018[^\u2019]*\u2019|\x60[^\x60]*\x60/g, part => {+ const text = normalizedQueryName(part);+ const instruction = DIRECTIVE_VERB.test(text);+ // Quoting a task qualifier cannot turn an illustrative instruction into a request.+ if (!instruction && !CURRENT_TASK_SUFFIX.test(text)) return part;+ if (instruction && aliases.some(({ name }) => new RegExp('\\b' + name + '\\b').test(text))) citation = 'indirect';+ return part.replace(/[^.!?;\n]/g, ' ');+ });+ // Keep the illustrative abbreviation together when its periods would split clauses.+ const expanded = unquoted.replace(/\be\.g\.(?=\s|[,;:!?]|$)/gi, 'for example');+ for (const clause of expanded.match(/[^.!?;\n]+[.!?;\n]*/g) || []) {+ // Keep comma boundaries for directive scope without changing alias normalization.+ const text = clause.split(',').map(normalizedQueryName).join(', ');+ const clauseScopes = citationScopes(text, names);+ const mentions = aliases.flatMap(({ name, exact }) => [...text.matchAll(new RegExp('\\b' + name + '\\b', 'g'))]+ .map(mention => ({ index: mention.index, exact }))).sort((a, b) => a.index - b.index);+ for (const mention of mentions) {+ const prefix = text.slice(0, mention.index);+ const precedingScopes = clauseScopes.filter(scope => scope.start <= mention.index);+ const example = precedingScopes.at(-1)?.example;+ const scopes = precedingScopes.filter(scope => !scope.example)+ .map(scope => scope.text.slice(0, mention.index - scope.start));+ const instructionPrefix = prefix.split(INSTRUCTION_BOUNDARY).at(-1);+ // A task preamble such as "fix the bug" does not change a later request.+ // Only preceding scopes may be neutral: an embedded instruction, question,+ // or subject-led statement still needs review. The final scope must remain+ // a direct request; neutral text never supplies admission evidence itself.+ const instruction = scopes.every((scope, index) => DIRECTIVE_REQUEST.test(scope) || DIRECTIVE_REJECTION.test(scope)+ || (index < scopes.length - 1 && !DIRECTIVE_VERB.test(scope)+ && !QUESTION_START.test(scope) && !REPORTED_INSTRUCTION.test(scope) && !SUBJECT_PREFIX.test(scope)));+ const question = (!DIRECTIVE_REQUEST.test(text) && QUESTION_START.test(text))+ || (!DIRECTIVE_REQUEST.test(instructionPrefix)+ && (QUESTION_START.test(instructionPrefix) || clause.includes('?')));+ if (example || question || scopes.some(scope => REPORTED_INSTRUCTION.test(scope)) || /^\s*["'\u201c\u2018\x60]/.test(clause)) {+ if (citation === 'none') citation = 'indirect';+ } else if (/\b(do not|never|no|not|avoid)\b/.test(instructionPrefix)) {+ citation = 'indirect';+ } else if (!instruction) {+ if (citation === 'none') citation = 'indirect';+ } else if (mention.exact && candidate.exact+ && DIRECTIVE_NAME_PREFIX.test(scopes.at(-1))) {+ citation = 'directive';+ }+ }+ }+ return citation;+}+function validateTask(task) {if (!task || typeof task !== 'object' || Array.isArray(task)) throw new Error('Task must be an object');for (const key of Object.keys(task)) if (!TASK_KEYS.has(key)) throw new Error(`Unknown task field: ${key}`);@@@ -263,13 -160,43 +288,49 @@@ function validatePrevious(previous)}}+ const ADMISSION_DENIALS = new Set(['ECC_CONTEXT_EXCLUDED', 'ECC_CONTEXT_MANUAL_ONLY', 'ECC_CONTEXT_AUTHORITY',+ 'ECC_CONTEXT_SKILL_LIMIT', 'ECC_CONTEXT_BYTE_BUDGET']);++ function admissibility(byId, excluded, reader) {+ return id => {+ try {+ const closure = selectedClosure([id], new Set(), byId, excluded, reader);+ readSelected(closure, byId, reader);+ return true;+ } catch (error) {+ // Only coded admission denials remove a suggestion. Source drift,+ // malformed policy and non-UTF-8 resources fail the build instead.+ if (ADMISSION_DENIALS.has(error.code)) return false;+ throw error;+ }+ };+ }++ /** Entries the resolver could suggest for a profile: not excluded and admissible+ * without explicit selection. Metadata only; bodies are never returned. */+ function routingEntries({ repoRoot = DEFAULT_REPO_ROOT, profileId = 'lean@1', target = 'codex',+ selectionMode = 'auto', include = [], exclude = [] } = {}) {+ const plan = compileContextProfile({ repoRoot, profileId, target, selectionMode, include, exclude });+ const registry = loadContextRegistry({ repoRoot });+ const { triggers } = loadSkillTriggers({ repoRoot });+ if (registry.registryDigest !== plan.registryDigest) throw new Error('Registry changed during routing index build');+ const byId = new Map(registry.entries.map(entry => [entry.id, entry]));+ const excluded = new Set(plan.excludedIds);+ const admissible = admissibility(byId, excluded, createSourceReader(repoRoot));+ const entries = registry.entries.filter(entry => !excluded.has(entry.id) && admissible(entry.id))+ .map(entry => ({ id: entry.id, name: entry.name, description: entry.description,+ ownerModuleId: entry.ownerModuleId, packId: entry.packId, ...(triggers[entry.id] ? { triggers: triggers[entry.id] } : {}) }));+ return { profileId: plan.profileId, target, selectionMode, planDigest: plan.planDigest, registryDigest: registry.registryDigest,+ routingPolicyVersion: ROUTING_POLICY_VERSION, triggersDigest: digestObject(triggers), entries };+ }+-/** Pure task-scoped resolver. Returned context never invokes a native skill or changes permissions. */+/** Resolve task-scoped skill context without invoking native skills or changing permissions.+ * @param {object} [options] Repository, task, profile, and selection constraints.+ * @param {object} options.task Task identity, query, and explicit or proposed skill IDs.+ * @param {boolean} [options.load=false] Include verified resource contents in the result.+ * @param {object|null} [options.previous=null] Receipt reusable only when its binding matches.+ * @returns {object} Selection decision, candidates, verified resources, and a bound receipt.+ */function resolveTaskContext({ repoRoot = DEFAULT_REPO_ROOT, task, profileId = 'lean@1', target = 'codex',selectionMode = 'auto', include = [], exclude = [], load = false, previous = null, expectedDigest = null } = {}) {validateTask(task);@@@ -326,7 -259,8 +376,8 @@@} else if (!exactAnchors.length) {const top = candidates[0];const second = candidates[1];- if (top.bm25 >= AUTO_ADMIT_MIN_BM25 && top.matchedTerms.length >= AUTO_ADMIT_MIN_TERMS+ if (citations.get(top.id) !== 'indirect' && top.bm25 >= AUTO_ADMIT_MIN_BM25 && top.matchedTerms.length >= AUTO_ADMIT_MIN_TERMS+ && top.anchorTerms.length >= MIN_ANCHOR_TERMS&& (!second || top.bm25 >= AUTO_ADMIT_MARGIN * (second.bm25 || 0))) {autoSelection = { id: top.id, bm25: top.bm25, matchedTerms: top.matchedTerms.length, exact: false };}@@@ -337,7 -271,8 +388,8 @@@&& !explicitIds.length && !proposedIds.length && candidates.length && !exactAnchors.length) {const top = candidates[0];const second = candidates[1];- if (citations.get(top.id) !== 'indirect' && top.bm25 >= FALLBACK_MIN_BM25 && top.matchedTerms.length >= FALLBACK_MIN_TERMS- if (meetsFallbackBar(top)++ if (citations.get(top.id) !== 'indirect' && meetsFallbackBar(top)+ && top.anchorTerms.length >= MIN_ANCHOR_TERMS&& (!second || top.bm25 >= FALLBACK_MARGIN * (second.bm25 || 0))) {fallback = { id: top.id, bm25: top.bm25, matchedTerms: top.matchedTerms.length };}diff --cc tests/lib/context-selection.test.jsindex 728887ad8,281f646d5..c04f943d0--- a/tests/lib/context-selection.test.js+++ b/tests/lib/context-selection.test.js@@@ -316,371 -320,27 +334,396 @@@ test('invalid input and oversized bodieassert.throws(() => resolve(repoRoot, { explicitIds: ['skill:feature'] }, { load: true }), /budget/);}));+ test('routing entries drop only coded admission denials; a corrupt source still fails the build', () => withFixture(root => {+ const { routingEntries } = require('../../scripts/lib/context-selection');+ write(root, 'skills/shared/SKILL.md', '---\nname: shared\ndescription: Shared helper\ndisable-model-invocation: true\n---\nShared');+ assert.equal(routingEntries({ repoRoot: root, target: 'claude' }).entries.some(entry => entry.id === 'skill:shared'), false);+ const file = path.join(root, 'skills/feature/SKILL.md');+ fs.writeFileSync(file, Buffer.concat([fs.readFileSync(file), Buffer.from([0xff, 0x0a])]));+ assert.throws(() => routingEntries({ repoRoot: root, target: 'claude' }), /UTF-8/);+ }));++ test('admission denials carry stable codes', () => withFixture(root => {+ write(root, 'skills/shared/SKILL.md', '---\nname: shared\ndescription: Shared helper\ndisable-model-invocation: true\n---\nShared');+ assert.throws(() => resolve(root, { query: 'shared', proposedIds: ['skill:shared'] }, { load: true }),+ error => error.code === 'ECC_CONTEXT_MANUAL_ONLY');+ }));++ test('suggestion evidence requires an exact name or the absolute fallback floor', () => {+ const { hasSuggestionEvidence } = require('../../scripts/lib/context-selection');+ const candidate = values => ({ exact: false, bm25: 12, matchedTerms: ['feature', 'work'], ...values });+ assert.equal(hasSuggestionEvidence(candidate()), true);+ assert.equal(hasSuggestionEvidence(candidate({ bm25: 11.99 })), false);+ assert.equal(hasSuggestionEvidence(candidate({ matchedTerms: ['feature'] })), false);+ assert.equal(hasSuggestionEvidence(candidate({ exact: true, bm25: 1, matchedTerms: ['feature'] })), true);+ assert.equal(hasSuggestionEvidence(null), false);+ });+++for (const query of [+ "You shouldn't use feature.",+ "You can\u2019t use feature.",+ "For feature, don't use the feature skill.",+ 'For feature, never invoke feature.',+ 'The phrase "Use feature" is an example.',+ 'The phrase "Use feature." is an example.',+ 'The phrase \u201cUse feature\u201d is an example.',+ 'The phrase `Use feature` is an example.',+ "Don't use the feature skill.",+ 'Don\u2019t use the feature skill.',+ 'Do not use the feature skill.',+ 'Never use the feature skill.',+ 'Can I use the feature skill?',+ 'Should we use the feature skill?',+ 'Why use the feature skill?',+ 'The README says to use the feature skill.',+ 'The docs say use feature.',+ 'The docs say to use feature.',+ 'The docs said use feature.',+ '"Use the feature skill" is an example.',+]) {+ test('indirect name citation needs an agent decision: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:feature'));+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.reason, 'agent-selection-required');+ assert.equal(result.fallback, null);+ }));+}++test('a negated citation does not suppress a separate affirmative directive', () => withFixture(repoRoot => {+ for (const query of [+ "Don't use feature. Use shared guidance.",+ 'Don\u2019t use feature; please use shared guidance.',+ 'The document says use feature. Use shared guidance.',+ ]) {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.loadedIds, ['skill:shared']);+ }+}));++for (const query of [+ "Don't use feature, use shared guidance.",+ "Don't use feature and use shared guidance.",+ "Don't use feature but use shared guidance.",+ 'Do not use feature, please use shared guidance.',+ 'Don\u2019t use feature, and please use shared guidance.',+ "Don't use feature, do use shared guidance.",+ "Don't use feature, use shared guidance, okay?",+ "Don't use feature and use shared guidance, okay?",+ "Don't use feature but use shared guidance, okay?",+ 'Do not use feature, please use shared guidance?',+ 'Do not use feature and please use shared guidance?',+ 'Do not use feature but please use shared guidance?',+]) {+ test('a new directive scopes an earlier rejection: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.selectedIds, ['skill:shared']);+ assert.deepEqual(result.loadedIds, ['skill:shared']);+ assert.equal(result.reason, 'auto-selection');+ assert.equal(result.receipt.autoSelection.exact, true);+ }));+}++for (const query of [+ 'The docs say do not use feature and use shared guidance.',+ 'The docs say do not use feature, use shared guidance.',+ 'The docs say do not use feature, use shared guidance, okay?',+ 'Use standard tools, the spec states do not use feature and use shared guidance.',+ 'The spec states do not use feature and use shared guidance.',+ 'The spec stated do not use feature, use shared guidance.',+ 'The spec recommends we do not use feature and use shared guidance.',+ 'The spec asserts we should not use feature and use shared guidance.',+ 'Use standard tools, the spec stipulates do not use feature and use shared guidance.',+ 'Use the documentation that says do not use feature and use shared guidance.',+ 'Should we avoid feature and use shared guidance?',+ 'Should we avoid feature, use shared guidance?',+ 'Do not use feature and shared guidance.',+ 'Do not use feature, shared guidance.',+]) {+ test('a connector preserves indirect or negated context: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:shared'));+ assert.deepEqual(result.selectedIds, []);+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.reason, 'agent-selection-required');+ assert.equal(result.fallback, null);+ }));+}++for (const query of [+ 'Use standard tools, should we use feature?',+ 'Use standard tools, shall we use feature?',+ 'Use standard tools, will we use feature?',+ 'Use standard tools, ought we to use feature?',+ 'Please use the existing code, can I use feature?',+ 'Use standard tools and should we use feature?',+ 'Use standard tools but should we use feature?',+]) {+ test('a generic directive does not authorize a later question: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:feature'));+ assert.deepEqual(result.selectedIds, []);+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.reason, 'agent-selection-required');+ assert.equal(result.fallback, null);+ }));+}++for (const query of ['Use feature?', 'Please use feature?', 'Use feature to fix the bug, okay?']) {+ test('an imperative with question punctuation remains a directive: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.selectedIds, ['skill:feature']);+ assert.deepEqual(result.loadedIds, ['skill:feature']);+ assert.equal(result.reason, 'auto-selection');+ assert.equal(result.receipt.autoSelection.exact, true);+ }));+}++test('ordinary and polite directives preserve automatic and explicit selection', () => withFixture(repoRoot => {+ for (const query of ['Please use the feature skill.', 'Can you use the feature skill?',+ 'Use feature without changing the code.', 'Use feature to document the change.',+ 'Use "feature".', 'Use `feature`.', 'Do use feature.', 'Please can you use feature?']) {+ assert.deepEqual(resolve(repoRoot, { query }, { load: true }).loadedIds, ['skill:feature']);+ }+ for (const field of ['explicitIds', 'proposedIds']) {+ assert.deepEqual(resolve(repoRoot, { query: 'Should we use feature?', [field]: ['skill:feature'] },+ { load: true }).loadedIds, ['skill:feature']);+ }+}));++for (const [query, expectedId] of [+ ['Fix the bug, use feature', 'skill:feature'],+ ['Fix the bug and use feature.', 'skill:feature'],+ ['Please fix the bug, please use feature.', 'skill:feature'],+ ['Write the regression test, use feature.', 'skill:feature'],+ ['Investigate the bug but use feature.', 'skill:feature'],+ ['For this task, use feature.', 'skill:feature'],+ ["Fix the bug, don't use feature and use shared guidance.", 'skill:shared'],+]) {+ test('a general task preamble preserves a later directive: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.selectedIds, [expectedId]);+ assert.deepEqual(result.loadedIds, [expectedId]);+ assert.equal(result.reason, 'auto-selection');+ assert.equal(result.receipt.autoSelection.exact, true);+ }));+}++for (const query of [+ 'Fix the bug, shall we use feature?',+ 'Fix the bug, the spec states do not use feature and use shared guidance.',+ 'The docs say fix the bug and use feature.',+ 'Can we fix the bug and use feature?',+ 'The spec stipulates: fix the bug and use feature.',+ 'Our policy stipulates repair the bug and use feature.',+ 'Fix the bug, ought we to repair it and use feature?',+ 'Fix the bug, must we repair it and use feature?',+ 'Fix the bug, feature.',+]) {+ test('a general task preamble cannot promote an indirect citation: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:feature'));+ assert.deepEqual(result.selectedIds, []);+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.reason, 'agent-selection-required');+ assert.equal(result.fallback, null);+ }));+}++for (const prefix of ['database-migrations:', "Don't use database-migrations.", 'Do not use database-migrations.',+ 'Should we use database-migrations?', 'The README says use database-migrations.']) {+ test('strong retrieval cannot bypass an indirect citation: ' + prefix, () => {+ const query = prefix + ' Review a PostgreSQL migration that adds an indexed nullable column without downtime.';+ const result = resolveTaskContext({ task: task({ query }), load: true });+ const candidate = result.candidates.find(value => value.id === 'skill:database-migrations');+ assert.ok(candidate && candidate.bm25 >= 20, 'Exercise the BM25 auto-admission threshold');+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.fallback, null);+ });+}++for (const query of [+ 'For example, use feature',+ 'For instance, use feature.',+ 'As an example, use feature.',+ 'To illustrate, use feature.',+ 'Fix the bug, for example, use feature.',+ 'For example, use feature and use feature.',+ 'For example, use feature but use shared guidance.',+ "For example, don't use feature but use shared guidance.",+ 'For example, use feature and use feature for this task.',+ 'For example, use feature, but should we use feature for this task?',+ 'For example, use feature, but the docs say use feature for this task.',+ 'For example, use feature, but "use feature for this task" is an example.',+ 'The docs say for example, use feature, but use feature for this task.',+ 'For example, use feature, but use feature "for this task"',+ 'Should we, for example, use shared guidance, but use feature for this task?',+ 'Our policy stipulates, for example, use shared guidance, but use feature for this task.',+ 'e.g., use feature.',+ 'E.g. use feature.',+]) {+ test('an illustrative citation needs an agent decision: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:feature'));+ assert.deepEqual(result.selectedIds, []);+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.reason, 'agent-selection-required');+ assert.equal(result.fallback, null);+ }));+}++for (const [routingPolicyVersion, query] of [+ [7, 'Use standard tools, shall we use feature?'],+ [9, 'For example, use feature'],+]) {+ test('an old policy ' + routingPolicyVersion + ' selected receipt is invalidated after policy changes', () => withFixture(repoRoot => {+ const first = resolve(repoRoot, { query, explicitIds: ['skill:feature'] });+ const { digestObject } = require('../../scripts/lib/context-profile-support');+ const { compileContextProfile } = require('../../scripts/lib/context-profiles');+ const plan = compileContextProfile({ repoRoot, selectionMode: 'auto' });+ const bindingDigest = digestObject({ sessionId: 'session-1', taskId: 'task-1', revision: 1,+ phase: 'implement', planDigest: plan.planDigest, routingPolicyVersion,+ triggersDigest: digestObject({}), queryDigest: digestObject(query) });+ const { receiptDigest: _receiptDigest, ...receipt } = first.receipt;+ const oldReceipt = { ...receipt, bindingDigest, explicitIds: [],+ selectionDigest: digestObject({ bindingDigest, selectedIds: ['skill:feature'], explicitIds: [] }) };+ const previous = { ...oldReceipt, receiptDigest: digestObject(oldReceipt) };+ const result = resolve(repoRoot, { query }, { previous, load: true });+ assert.equal(result.reused, false);+ assert.notEqual(result.receipt.bindingDigest, previous.bindingDigest);+ assert.deepEqual(result.selectedIds, []);+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.fallback, null);+ }));+}++for (const [routingPolicyVersion, query, expectedId] of [+ [6, "Don't use feature, use shared guidance.", 'skill:shared'],+ [8, 'Fix the bug, use feature', 'skill:feature'],+ [10, 'For example, use feature, but use feature for this task', 'skill:feature'],+]) {+ test('an old policy ' + routingPolicyVersion + ' empty selection is reconsidered after policy changes', () => withFixture(repoRoot => {+ const first = resolve(repoRoot, { query });+ const { digestObject } = require('../../scripts/lib/context-profile-support');+ const { compileContextProfile } = require('../../scripts/lib/context-profiles');+ const plan = compileContextProfile({ repoRoot, selectionMode: 'auto' });+ const bindingDigest = digestObject({ sessionId: 'session-1', taskId: 'task-1', revision: 1,+ phase: 'implement', planDigest: plan.planDigest, routingPolicyVersion,+ triggersDigest: digestObject({}), queryDigest: digestObject(query) });+ const { receiptDigest: _receiptDigest, autoSelection: _autoSelection, ...receipt } = first.receipt;+ const oldReceipt = { ...receipt, bindingDigest, decision: 'none', selectedIds: [], explicitIds: [],+ loadedIds: [], resources: [], selectionDigest: digestObject({ bindingDigest, selectedIds: [], explicitIds: [] }) };+ const previous = { ...oldReceipt, receiptDigest: digestObject(oldReceipt) };+ const result = resolve(repoRoot, { query }, { previous, load: true });+ assert.equal(result.reused, false);+ assert.notEqual(result.receipt.bindingDigest, previous.bindingDigest);+ assert.deepEqual(result.selectedIds, [expectedId]);+ assert.deepEqual(result.loadedIds, [expectedId]);+ assert.equal(result.reason, 'auto-selection');+ }));+}++for (const query of [+ 'Should we use feature? Use feature.',+ 'Use feature. Should we use feature?',+ 'Use feature, should we use feature?',+ 'Use feature. Shall we use feature?',+ 'Use feature, shall we use shared guidance?',+ 'Shall we use shared guidance? Use feature.',+ 'The docs say use feature. Use feature.',+ 'Use feature. The docs say use feature.',+ 'Use feature. The spec states do not use feature and use shared guidance.',+ 'Use feature. Use the warning that says never use feature.',+ 'The spec states do not use feature and use shared guidance. Use feature.',+ 'The phrase "Use feature." is an example. Use feature.',+ 'The docs say "Use feature." Use feature.',+ 'The docs say "Should we use feature?" Use feature.',+ `Use feature. The docs say "don’t use feature."`,+ 'Use feature. The phrase "Use feature." is an example.',+ "Don't use feature. Use feature.",+ "Don't use feature, use feature.",+ "Don't use feature and use feature.",+ "Don't use feature but use feature.",+ 'The docs say never use feature. Use feature.',+ 'Use feature. The docs say never use feature.',+ 'Use feature to inspect the essay.',+ 'Use feature. For example, use shared guidance.',+ 'For example, use shared guidance. Use feature.',+ "Use feature. For example, don't use feature.",+ 'Use feature to build an example.',+ 'Fix the example, use feature.',+ 'Fix e.g.js, use feature.',+ "Use feature. E.g., don't use feature.",+ 'For example, use feature, but use feature for this task',+ 'For example, use shared guidance, but please use feature for this task.',+ 'For instance, use shared guidance but use feature for this task.',+ 'For example use shared guidance, but use feature for this task.',+ 'For example, use shared guidance, but use feature for the current task.',+ 'For example, use shared guidance, but use feature for this task, for instance, do not use feature.',+ 'For example, the docs say use shared guidance, but use feature for this task.',+]) {+ test('a genuine directive survives surrounding discussion: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.loadedIds, ['skill:feature']);+ assert.equal(result.reason, 'auto-selection');+ assert.equal(result.receipt.autoSelection.exact, true);+ }));+}++for (const query of [+ "Use feature. Don't use feature.",+ 'Use feature. Avoid feature.',+ 'Use feature. You should not use feature.',+ 'Use feature. You shouldn\u2019t use feature.',+ 'Use feature, no feature.',+ 'Use feature. For this task, do not use feature.',+ "Use feature, don't use feature.",+ "Use feature and don't use feature.",+ "Use feature but don't use feature.",+ 'Use feature. Never use feature.',+ "Use feature. Don't use feature. Should we use feature?",+ 'Use feature. For example, use shared guidance, but do not use feature for this task.',+ 'For example, use shared guidance, but use feature for this task and do not use feature.',+]) {+ test('a later rejection withdraws an earlier directive: ' + query, () => withFixture(repoRoot => {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.fallback, null);+ }));+}++test('a later grouped rejection withdraws a previously requested skill', () => withFixture(repoRoot => {+ for (const query of ["Use shared. Don't use feature and shared guidance.",+ 'Use shared. Do not use feature and our shared guidance.',+ 'Use shared. Do not use feature and the existing shared guidance.',+ 'Use shared. Do not use feature, manual, and shared guidance.',+ "Use shared. Don't use feature and the shared skill."]) {+ const result = resolve(repoRoot, { query }, { load: true });+ assert.deepEqual(result.loadedIds, [], query);+ assert.equal(result.fallback, null);+ }+}));++for (const prefix of [+ "Don't use the database migration skill.",+ 'Don\u2019t use the database migration skill.',+ 'Never use database migration.',+ 'Should we use the database migration skill?',+ 'The docs say use the database migration skill.',+]) {+ test('singular named references cannot bypass citation review: ' + prefix, () => {+ const query = prefix + ' Review a PostgreSQL migration that adds an indexed nullable column without downtime.';+ const result = resolveTaskContext({ task: task({ query }), load: true });+ const candidate = result.candidates.find(value => value.id === 'skill:database-migrations');+ assert.ok(candidate && candidate.bm25 >= 20, 'Exercise the BM25 auto-admission threshold');+ assert.equal(candidate.exact, false, 'Exercise the non-exact candidate path');+ assert.deepEqual(result.loadedIds, []);+ assert.equal(result.fallback, null);+ });+}++test('singular forms do not create exact directive admission', () => {+ const result = resolveTaskContext({ task: task({ query: 'Use the database migration skill.' }), load: true });+ assert.ok(result.candidates.some(candidate => candidate.id === 'skill:database-migrations'));+ assert.ok(!result.receipt.autoSelection || !result.receipt.autoSelection.exact);+});