@event4u/agent-config 16.3.0 → 16.5.0

package/src/scripts/schemas/command.schema.json

@@ -306,7 +306,7 @@
     },
     "auto_detect": {
       "type": "boolean",
-      "description": "6.1.0 orchestrator auto-detection opt-in (Step 1, non-interactive-contract). When true, the orchestrator auto-detects its sub-command per the confidence-tiered detection table instead of always showing the menu, honoring the non-interactive-contract (TTY/CI detection, --yes/--json, abort schemas). Per-orchestrator kill-switch: set false to always show the menu; overridable globally via commands.auto_detect in .agent-settings.yml and per-invocation via --no-auto-detect. Only orchestrators (type: orchestrator) carry it."
+      "description": "6.1.0 orchestrator auto-detection opt-in (Step 1, non-interactive-contract). When true, the orchestrator auto-detects its sub-command per the confidence-tiered detection table instead of always showing the menu, honoring the non-interactive-contract (TTY/CI detection, --yes/--json, abort schemas). Per-orchestrator kill-switch: set false to always show the menu; per-invocation override via --no-auto-detect (there is no global settings switch). Only orchestrators (type: orchestrator) carry it."
     }
   }
 }

package/src/scripts/schemas/skill.schema.json

@@ -505,7 +505,7 @@
         "standard",
         "rich"
       ],
-      "description": "Token-cost class for this skill. `lean` (default): subject to telegraph-speak condensation and thin-projector trimming; optimize for <500 tokens. `standard`: balanced guidance, normal condensation. `rich`: exempt from telegraph-speak and thin-projector trimming; detailed examples preserved; eager-load eligible; ≤15% of skills in a suite may be `rich` (CI-enforced). A `rich` skill MUST carry a '## Why this skill is rich' section explaining the irreducible complexity that makes condensation harmful. Governed by `token-budget-discipline` rule + `tokens.rich_skills` consumer setting. See docs/guidelines/token-budget-governance.md."
+      "description": "Token-cost class for this skill. `lean` (default): subject to telegraph-speak condensation and thin-projector trimming; optimize for <500 tokens. `standard`: balanced guidance, normal condensation. `rich`: exempt from telegraph-speak and thin-projector trimming; detailed examples preserved; eager-load eligible; ≤15% of skills in a suite may be `rich` (CI-enforced). A `rich` skill MUST carry a '## Why this skill is rich' section explaining the irreducible complexity that makes condensation harmful. Governed by the `token-budget-discipline` rule; rich skills always load in full. See docs/guidelines/token-budget-governance.md."
     },
     "parallelizable": {
       "type": "string",

package/src/scripts/self_review_gate.ts

@@ -116,12 +116,30 @@ export function gateVerdict(findings: readonly Finding[], opts: { enforce: boole
 const SKIP_PREFIXES = ['dist/agent-src/', '.augment/', '.claude/', '.cursor/', '.clinerules/'];
 const SKIP_EXACT = new Set(['.windsurfrules', 'GEMINI.md', 'package-lock.json']);
 
+/**
+ * Review artefacts, `.review-input/` copies included: a copy of a diff that was
+ * already reviewed. The R2 reviewer excludes the same tree
+ * (`REVIEW_SCOPE_EXCLUDES` in `dispatch_r2_reviewer.ts`); here they used to
+ * compete for `MAX_REVIEW_CHUNKS` — 154 of 16.3.0's 603 unreviewed paths sat
+ * under it. Counted separately in the coverage record, never as unreviewed.
+ */
+export const REVIEW_COPY_PREFIX = 'agents/evidence/reviews/';
+
+export function isReviewCopyPath(p: string): boolean {
+    return p.startsWith(REVIEW_COPY_PREFIX);
+}
+
 export function isReviewablePath(p: string): boolean {
     if (SKIP_EXACT.has(p)) return false;
+    if (isReviewCopyPath(p)) return false;
     return !SKIP_PREFIXES.some((pre) => p.startsWith(pre));
 }
 
 function changedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
+    return allChangedFiles(baseRef, cwd).filter(isReviewablePath);
+}
+
+function allChangedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
     // `-c core.quotePath=false`: by default git renders a non-ASCII path as an
     // escaped, QUOTED string (`"gr\303\274e.ts"`), which then matches no
     // pathspec when fed back to `git diff`. The file was silently skipped by
@@ -138,8 +156,7 @@ function changedFiles(baseRef: string, cwd: string = REPO_ROOT): string[] {
     return (r.stdout ?? '')
         .split('\n')
         .map((s) => s.trim())
-        .filter(Boolean)
-        .filter(isReviewablePath);
+        .filter(Boolean);
 }
 
 /**
@@ -758,6 +775,8 @@ export interface ReviewPlan {
     requests: number;
     /** Files no request will carry, with the reason. */
     unreviewed: { path: string; reason: string }[];
+    /** Changed paths under `REVIEW_COPY_PREFIX` — copies of a reviewed diff, sent to no request. */
+    reviewCopies: string[];
     promptChars: number;
     note: string;
     escalation: string[];
@@ -787,6 +806,7 @@ export function buildPlan(baseRef: string, cwd: string = REPO_ROOT): ReviewPlan
     }
 
     const files = analysisBase === baseRef ? packagingFiles : changedFiles(analysisBase, cwd);
+    const reviewCopies = allChangedFiles(analysisBase, cwd).filter(isReviewCopyPath);
     const diff = diffText(analysisBase, files, cwd);
     const escalation = escalationReasons(files, changedLineCount(analysisBase, files, cwd));
     const systemPrompt = buildSystemPrompt(release, baseRef);
@@ -810,6 +830,7 @@ export function buildPlan(baseRef: string, cwd: string = REPO_ROOT): ReviewPlan
         facts,
         requests: partition.chunks.length,
         unreviewed: partition.unreviewed,
+        reviewCopies,
         skills: [...REVIEW_SKILLS],
         files,
         analysisBase,
@@ -904,6 +925,12 @@ export function coverageBlock(coverage?: ReviewCoverage): string {
         `\n\n**Coverage.** ${String(coverage.chunks)} request(s) over ` +
             `${String(coverage.filesReviewed)} of ${String(coverage.filesTotal)} changed file(s).`,
     ];
+    if ((coverage.reviewCopies ?? 0) > 0) {
+        parts.push(
+            ` ${String(coverage.reviewCopies)} further path(s) under \`${REVIEW_COPY_PREFIX}\` are ` +
+                'copies of an already-reviewed diff and were not re-read.',
+        );
+    }
     if (coverage.unreviewed.length > 0) {
         parts.push(
             ` **NOT reviewed (${String(coverage.unreviewed.length)}):**\n` +
@@ -927,6 +954,12 @@ export interface ReviewCoverage {
     /** Files the span changed, so the reader sees the fraction, not a bare count. */
     filesTotal: number;
     unreviewed: { path: string; reason: string }[];
+    /**
+     * Changed paths under `REVIEW_COPY_PREFIX`, not re-read because each is a
+     * copy of a diff already reviewed. Neither reviewed nor unreviewed, and not
+     * in `filesTotal`. Optional: a record written before this field has none.
+     */
+    reviewCopies?: number;
 }
 
 export function renderReview(findings: Finding[], enforce: boolean, escalation: readonly string[] = [], coverage?: ReviewCoverage): string {
@@ -1089,6 +1122,9 @@ export function main(argv: string[]): 0 | 2 {
                       `packaging diff ${plan.release.packagingFiles.length} file(s))\n`
                     : '') +
                 `  files:  ${plan.files.length}\n` +
+                (plan.reviewCopies.length > 0
+                    ? `  review copies (not re-read): ${String(plan.reviewCopies.length)}\n`
+                    : '') +
                 `  calls:  ${plan.requests} (budget ${String(PROMPT_BUDGET_CHARS)} chars/request, ` +
                 `ceiling ${String(MAX_REVIEW_CHUNKS)})\n` +
                 (plan.unreviewed.length > 0
@@ -1242,6 +1278,7 @@ export function main(argv: string[]): 0 | 2 {
             filesReviewed: filesRead,
             filesTotal: plan.files.length,
             unreviewed,
+            reviewCopies: plan.reviewCopies.length,
         };
         // Ground-truth pass, ONCE, before anything reads the finding set. A
         // deletion claim the range and the tree both disprove is annotated

package/src/scripts/skill_tools/score_skill_relevance.ts

@@ -40,7 +40,9 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 // the disk half — globbing, frontmatter, the CLI — which stays here.
 import {
     buildTermStats,
-    scoreSkill,
+    compareRanked,
+    rawSkillScore,
+    roundHalfToEven,
     skillTerms as _sharedSkillTerms,
     tokenize as _sharedTokenize,
     triggerTextFromFlatLines,
@@ -510,15 +512,15 @@ function _terms(skill: Skill, opts: RankOptions): ReadonlySet<string> {
     return widensTermSource(opts) ? _sharedSkillTerms(_rankable(skill), opts) : skill.terms;
 }
 
-function _score(
+function _rawScore(
     taskTerms: Set<string>,
     skill: Skill,
     terms: ReadonlySet<string>,
     opts: RankOptions = {},
     stats?: TermStats,
 ): number {
-    // Single-sourced in `src/shared/skillRanking.ts`.
-    return scoreSkill(taskTerms, _rankable(skill), terms, opts, stats);
+    // Single-sourced in `src/shared/skillRanking.ts`; `scoreSkill` rounds this.
+    return rawSkillScore(taskTerms, _rankable(skill), terms, opts, stats);
 }
 
 export type RankRow = [string, number, string[]];
@@ -538,6 +540,20 @@ export function rank(
     opts: RankOptions = {},
     ctx?: NeighbourContext,
 ): RankRow[] {
+    return rankDetailed(task, skillsDir, opts, ctx).rows;
+}
+
+/**
+ * {@link rank}, plus each ranked skill's unrounded score. The tie metrics of
+ * `report_skill_ranker_confusion` need the second half to tell a tie the
+ * ordering key still cannot break from one the unrounded score already broke.
+ */
+export function rankDetailed(
+    task: string,
+    skillsDir: string | readonly string[],
+    opts: RankOptions = {},
+    ctx?: NeighbourContext,
+): { rows: RankRow[]; raw: ReadonlyMap<string, number> } {
     const taskTerms = _tokenize(task);
     const skills = _load_skills_across(
         typeof skillsDir === 'string' ? [skillsDir] : skillsDir,
@@ -549,27 +565,20 @@ export function rank(
     const termSets = skills.map((s) => _terms(s, opts));
     const stats = opts.idfWeighting ? buildTermStats(skills.map(_rankable), termSets) : undefined;
     const rows: RankRow[] = [];
+    const raw = new Map<string, number>();
     for (let i = 0; i < skills.length; i += 1) {
         const s = skills[i] as Skill;
-        const score = _score(taskTerms, s, termSets[i] as ReadonlySet<string>, opts, stats);
+        const unrounded = _rawScore(taskTerms, s, termSets[i] as ReadonlySet<string>, opts, stats);
+        const score = roundHalfToEven(unrounded);
         if (score > 0) {
             rows.push([s.qualified, score, [...s.personas]]);
+            raw.set(s.qualified, unrounded);
         }
     }
-    // rows.sort(key=lambda r: (-r[1], r[0])) — Python stable tuple sort.
-    rows.sort((a, b) => {
-        if (b[1] !== a[1]) {
-            return b[1] - a[1];
-        }
-        if (a[0] < b[0]) {
-            return -1;
-        }
-        if (a[0] > b[0]) {
-            return 1;
-        }
-        return 0;
-    });
-    return rows;
+    // rows.sort(key=lambda r: (-r[1], r[0])) — Python stable tuple sort, with
+    // the opt-in unrounded tie-break between the two keys.
+    rows.sort((a, b) => compareRanked(a[0], a[1], b[0], b[1], opts, raw));
+    return { rows, raw };
 }
 
 /** Mirror Python `f"{s:<{w}}"` (left-justify) over code-point width. */