Skip to content

armgit / ECC

Public Imported from GitHub
0

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.js
index 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.5
const 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.js
index 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 bodie
assert.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);
+});