mirror of
https://github.com/garrytan/gstack.git
synced 2026-09-27 15:11:47 +02:00
v1.89.0.0 feat: add shared-code extraction audit (#2925)
* feat: bind shared-code review advice to source and branch * feat: add shared-code extraction audit and scoped review checks * test: recognize complete source reads and explicit coverage legends * chore: bump version and changelog (v1.88.0.0) Co-Authored-By: OpenAI Codex <noreply@openai.com> * test: capture native review questions and retain public evidence Capture the actual first public native question with strict ownership and display matching. Preserve terminal failures and raw evidence, and retain SDK completion checks. * test: recognize verified review evidence and complete fixtures Recognize complete source and diagram evidence, concrete design and developer-experience decisions, and the complete planted scenario contracts. Preserve negative controls and grading thresholds. * fix: preserve decision brief structure in native questions Keep the required pros-and-cons heading and final Net field in native question text. Regenerate host outputs and document the release and evaluation repairs. Co-Authored-By: OpenAI Codex <noreply@openai.com> * docs: update project documentation for v1.88.0.0 Co-Authored-By: OpenAI Codex <noreply@openai.com> * fix: correct eval retry accounting and ship workflow gates * fix: capture native eval evidence and stabilize CI fixtures * fix: keep shared-code eval skips read-only Choose explicit no-change answers instead of mixed fix/preservation options. Reuse the bounded revalidation prompt for path fixtures so required review metadata is available without repeated discovery. Preserve source checks, retry limits, and failed native terminal outcomes. Add captured-question and callback regressions, plus evaluation selection coverage for the affected fixtures. --------- Co-authored-by: OpenAI Codex <noreply@openai.com>
This commit is contained in:
Garry Tan
co-authored by
OpenAI Codex
OpenAI Codex
parent
b9706f3635
commit
06ed920a97
@@ -0,0 +1,108 @@
|
||||
import type { SharedQuestionSelector } from './shared-libs-eval-fixture';
|
||||
|
||||
/** Separate explicit exclusions from proposals; do not erase a following "but" clause. */
|
||||
function affirmativeCommitments(text: string): string {
|
||||
return text.split(/\n|;|(?<=[.!?])\s+|\s+but\s+|\s+however,?\s+/i).map(raw => {
|
||||
let clause = raw.replace(/^[✅❌\s]+/, '').trim();
|
||||
if (/^(?:do not|don't|never|no\b|without\b)/i.test(clause)) return '';
|
||||
if (/\b(?:is|are|remains?)\s+(?:outside\b|out of scope\b|excluded\b|not part\b)/i.test(clause)) return '';
|
||||
clause = clause.replace(/\b(?:without|do not|don't|never)\b.*$/i, '');
|
||||
return clause;
|
||||
}).filter(Boolean).join('\n');
|
||||
}
|
||||
|
||||
/** A repeated option menu is context, not approval of every displayed alternative. */
|
||||
function questionParts(text: string, optionIndex: number): { context: string; option: string } {
|
||||
let copiedOption: number | undefined;
|
||||
const context: string[] = [], option: string[] = [];
|
||||
for (const line of text.split('\n')) {
|
||||
const selector = line.match(/^\s*([A-D])[).]\s+/);
|
||||
if (selector) copiedOption = selector[1].charCodeAt(0) - 65;
|
||||
if (/^\s*Net:/i.test(line)) copiedOption = undefined;
|
||||
if (copiedOption === undefined || copiedOption === optionIndex) context.push(line);
|
||||
if (copiedOption === optionIndex) option.push(line);
|
||||
}
|
||||
return { context: context.join('\n'), option: option.join('\n') };
|
||||
}
|
||||
|
||||
/** This fixture actor can approve reuse under the fixed scheduler contract, not redesign it. */
|
||||
export function createSharedPlanReuseSelector(): SharedQuestionSelector {
|
||||
let answered = false;
|
||||
return input => {
|
||||
const refuse = (why: string): never => { throw new Error(`shared-libs-plan-callers actor: ${why}`); };
|
||||
if (answered) refuse('only the bounded parser-reuse choice is supported; another choice needs a different fixture');
|
||||
const questions = input.questions;
|
||||
if (!Array.isArray(questions) || questions.length !== 1) refuse('expected one native question for one reuse choice');
|
||||
const question = questions[0];
|
||||
if (!question || typeof question.question !== 'string' || question.multiSelect === true ||
|
||||
!Array.isArray(question.options) || question.options.length < 2 || question.options.length > 4 ||
|
||||
question.options.some((option: any) => typeof option?.label !== 'string' || typeof option?.description !== 'string')) {
|
||||
refuse('unsupported native question shape');
|
||||
}
|
||||
const choices = question.options.map((option: any, index: number) => {
|
||||
const parts = questionParts(question.question, index);
|
||||
return { option, index, context: parts.context + '\n' + (question.header || ''),
|
||||
commitment: option.label + '\n' + option.description + '\n' + parts.option };
|
||||
});
|
||||
const candidates = choices.filter(({ option, commitment, context }: any) =>
|
||||
!/\b(?:do not|don't|never|avoid|reject|skip|decline)\b.*\b(?:reuse|use|import|delegate|share|call)\b/i.test(option.label) &&
|
||||
/\b(?:reus(?:e|es|ing)|us(?:e|es|ing)|import(?:s|ing)?|delegat(?:e|es|ing)|shar(?:e|es|ing)|call(?:s|ing)?)\b/i.test(affirmativeCommitments(commitment)) &&
|
||||
(/lib\/retry-after\.ts|\bretrySeconds\b/.test(commitment) ||
|
||||
(/\b(?:helper|parser)\b/i.test(commitment) && /lib\/retry-after\.ts|\bretrySeconds\b/.test(context))));
|
||||
|
||||
// Recommendation placement is not part of the native schema. Accept its
|
||||
// explicit brief, repeated menu or label form, and reconcile every form present.
|
||||
const recommendations = new Set<number>();
|
||||
choices.forEach(({ option, index }: any) => { if (/\(recommended\)/i.test(option.label)) recommendations.add(index); });
|
||||
for (const marker of question.question.matchAll(/^\s*([A-D])[).]\s+[^\n]*\(recommended\)/gim)) recommendations.add(marker[1].toUpperCase().charCodeAt(0) - 65);
|
||||
for (const statement of question.question.matchAll(/^\s*Recommendation:\s*(.+)$/gim)) {
|
||||
const value = statement[1].trim();
|
||||
const selector = value.match(/^(?:option\s+)?([A-D])\b/i);
|
||||
if (selector) recommendations.add(selector[1].toUpperCase().charCodeAt(0) - 65);
|
||||
else {
|
||||
const matches = choices.filter(({ option }: any) => value.toLowerCase().startsWith(option.label.replace(/\s*\(recommended\)/ig, '').trim().toLowerCase()));
|
||||
if (matches.length !== 1) refuse('explicit recommendation is ambiguous or does not name an offered option');
|
||||
recommendations.add(matches[0].index);
|
||||
}
|
||||
}
|
||||
if (recommendations.size > 1) refuse('explicit recommendation does not identify one supported reuse option');
|
||||
const recommendedIndex = [...recommendations][0];
|
||||
const selected = recommendedIndex === undefined ? (candidates.length === 1 ? candidates[0] : undefined)
|
||||
: candidates.find(({ index }: any) => index === recommendedIndex);
|
||||
if (!selected) {
|
||||
refuse('explicit recommendation does not identify the supported reuse option');
|
||||
}
|
||||
if (candidates.length > 1 && !candidates.every(({ commitment }: any) => /\b(?:proof|test\w*|coverage|verification)\b/i.test(commitment))) {
|
||||
refuse('multiple reuse options must differ only in proof depth');
|
||||
}
|
||||
// All reuse alternatives must keep the same runtime contract. Only their
|
||||
// proof depth may differ; recommendation cannot authorize another behavior.
|
||||
for (const { context, commitment } of candidates) {
|
||||
// The supplied PLAN owns the two future caller identities and fixed scope.
|
||||
// Native questions may refer to them without repeating file names, and an
|
||||
// option may inherit unchanged semantics from its complete decision brief.
|
||||
if (/\b(?:not|never|no longer)\s+(?:identical|the same|unchanged|preserv\w*|match\w*)\b/i.test(commitment) ||
|
||||
!/\b(?:identical|same|unchanged|preserv\w*|match\w*|keep\w*)\b[^.!?\n]{0,120}\b(?:scheduler|semantics|behavior|contract)\b|\b(?:scheduler|semantics|behavior|contract)\b[^.!?\n]{0,120}\b(?:identical|same|unchanged|preserv\w*|match\w*|keep\w*)\b/i.test(affirmativeCommitments(context + '\n' + commitment))) {
|
||||
refuse('the selected option must explicitly preserve the current scheduler contract');
|
||||
}
|
||||
// Inspect the question as well as the selected option: a harmless label must
|
||||
// not authorize an extra commitment hidden in its brief or description.
|
||||
const proposed = affirmativeCommitments(context + '\n' + commitment);
|
||||
const expansions = [
|
||||
/\b(?:harden\w*|tighten\w*|strict(?:er)?|saniti[sz]\w*|coerc\w*)\b/i,
|
||||
/\b(?:add(?:s|ing)?|insert(?:s|ing)?|introduc(?:e|es|ing)|implement(?:s|ing)?|appl(?:y|ies|ying)|enabl(?:e|es|ing)|creat(?:e|es|ing))\s+(?:(?:a|an|the|one|new|shared|extra|explicit|validation|numeric|malformed|input|parser)\s+)*(?:guard|validator|validation|normalization)\b/i,
|
||||
/\b(?:chang(?:e|es|ing)|alter(?:s|ing)?|modif(?:y|ies|ying)|patch(?:es|ing)?|fix(?:es|ing)?|updat(?:e|es|ing)|replac(?:e|es|ing))\s+(?:(?:the|existing|shared|current|its|our)\s+)*(?:(?:retry-after|numeric|malformed|header)\s+)*(?:helper|parser|scheduler|behavior|semantics|contract|parsing|fallback|ceiling|cap|retrySeconds|lib\/retry-after\.ts)\b/i,
|
||||
/\b(?:raise|lower|increase|decrease|remove|drop|bypass|disable)\b[^.!?\n]{0,60}\b(?:ceiling|cap|fallback|limit|bound)\b/i,
|
||||
/\b(?:reject|normalize|convert|round|clamp)\b[^.!?\n]{0,60}\b(?:malformed|numeric|invalid|header|input)\b/i,
|
||||
/\b(?:migrat\w*|rewir\w*|refactor\w*)\b[^.!?\n]{0,100}\b(?:existing|current|scheduler|retry-worker|retry-route)\b/i,
|
||||
/\b(?:header|input|value|numeric|retrySeconds|scheduler|helper|parser|fallback|ceiling|cap)\w*\b[^.!?\n,;]{0,100}\b(?:now|will)\s+(?:return|use|be|wait|fallback|zero|limit|cap)\b/i,
|
||||
/\b(?:existing|current|retry-worker\.ts|retry-route\.ts)\b[^\n;]{0,100}\b(?:will|now|also)\s+(?:import|use|call|delegate|share)\b/i,
|
||||
/\bsrc\/(?!import-worker\.ts\b|sync-route\.ts\b)[\w.-]+\.ts\b[^\n;]{0,100}\b(?:will|now|also)\s+(?:import|use|call|delegate|share)\b/i,
|
||||
];
|
||||
const expansion = expansions.map(pattern => proposed.match(pattern)?.[0]).find(Boolean);
|
||||
if (expansion) refuse(`question expands beyond unchanged-helper reuse and its required proof: ${expansion}`);
|
||||
}
|
||||
answered = true;
|
||||
return { [question.question]: selected.option.label };
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user