mirror of
https://github.com/garrytan/gstack.git
synced 2026-10-31 22:14:25 +01:00
garrytanandDavon Johnson
3e55fb8d8a
Bare mktemp, mktemp -t and literal /tmp templates in the learnings,
question and preference logs (plus jsonl-merge, distill, the two
dashboards, /ship's PR body and /document-release's run dir) now use
"${TMPDIR:-/tmp}/<name>.XXXXXX", the form the INV-3 lint accepts. When
the temp file cannot be created, the learnings, question and preference
logs now say the entry was not recorded and how to fix TMPDIR instead of
exiting with only mktemp's own error. Three tests that pinned the bare
PR_BODY_FILE=$(mktemp) and one that pinned the /tmp run dir migrate.
GNU and BSD mktemp already honor TMPDIR without a template, so the
macOS-sandbox drop in #2952 is unverified here; the template makes the
temp location explicit on every mktemp.
Co-authored-by: Davon Johnson <d.johnson@dayofshow.net>
341 lines
22 KiB
TypeScript
341 lines
22 KiB
TypeScript
import { describe, expect, test } from 'bun:test';
|
||
import { ASK_QUESTIONS_HEADING, ENG_REVIEW_EXCERPT, readWorkflowExcerpt } from './helpers/workflow-excerpt';
|
||
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
|
||
import { tmpdir } from 'os';
|
||
import { join } from 'path';
|
||
import { spawnSync } from 'child_process';
|
||
|
||
function expectOutsideReviewControlFlow(text: string, promptHeading: string): void {
|
||
const ceo = text.includes('**Record the disabled outcome:**');
|
||
const markers = [ceo ? '**Record the disabled outcome:**' : '**Disabled is a terminal branch', promptHeading, '**If `CODEX_MODE: ready`', '\n**Native fallback —'];
|
||
const indices = markers.map(marker => text.indexOf(marker));
|
||
expect(indices.every(index => index >= 0)).toBe(true);
|
||
expect(indices).toEqual([...indices].sort((a, b) => a - b));
|
||
const disabled = text.slice(indices[0], indices[1]);
|
||
if (ceo) {
|
||
expect(disabled).toContain('"outside_status":"disabled"');
|
||
expect(disabled.replace(/\s+/g, ' ')).toMatch(/without a challenge, CLI invocation, Agent\/Task fallback/i);
|
||
expect(disabled).toContain('_DISABLED_REVIEW_MODE=');
|
||
expect(disabled).toContain('if [ "$_DISABLED_REVIEW_MODE" = disabled ]');
|
||
} else {
|
||
expect(disabled).toContain('persist `outside_status: disabled`');
|
||
expect(disabled.replace(/\s+/g, ' ')).toMatch(/do not construct a (?:review prompt|challenge), invoke an outside CLI, dispatch an Agent\/Task fallback/i);
|
||
}
|
||
expect(text.slice(indices[1], indices[2])).toContain('(skip only on `disabled`)');
|
||
|
||
const fallback = text.slice(indices[3]);
|
||
if (text.includes('**Outcome routing:**')) {
|
||
expect(fallback.replace(/\s+/g, ' ')).toMatch(/immediately before dispatch, check the preflight result again: disabled means no replacement/i);
|
||
} else if (ceo) {
|
||
expect(fallback.replace(/\s+/g, ' ')).toMatch(/do not block the review; they use the bounded fallback/i);
|
||
} else {
|
||
expect(fallback).toMatch(/the disabled branch never reaches this fallback/i);
|
||
expect(fallback.replace(/\s+/g, ' ')).toMatch(/use this fallback for missing\/broken CLI/i);
|
||
}
|
||
const dispatch = fallback.indexOf('Dispatch via the Agent tool');
|
||
expect(dispatch).toBeGreaterThan(0);
|
||
const recheck = fallback.slice(0, dispatch).replace(/\s+/g, ' ');
|
||
if (ceo) {
|
||
expect(recheck).toMatch(/immediately before dispatch, recheck the preflight result/i);
|
||
expect(recheck).toMatch(/`CODEX_MODE: disabled`, return to \*\*Record the disabled outcome\*\* without dispatching/i);
|
||
} else if (!text.includes('**Outcome routing:**')) {
|
||
expect(recheck).toMatch(/immediately before dispatching, check the preflight result again/i);
|
||
expect(recheck).toContain('`CODEX_MODE: disabled`, finish this section with `outside_status: disabled`;');
|
||
expect(recheck).toMatch(/do not dispatch/i);
|
||
}
|
||
expect(fallback).toMatch(/availability\/native fallback is not outside completion/i);
|
||
}
|
||
|
||
describe('workflow judge excerpts', () => {
|
||
test('expands ship sections in execution order, not alphabetical order', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
const headings = ['## Step 3:', '## Step 4:', '## Step 7:', '## Step 8:', '## Step 9:', '## Step 10:', '## Step 11:', '## Step 11.5:', '## Step 12:', '## Step 13:', '## Step 14:'];
|
||
const indices = headings.map(heading => text.indexOf(heading));
|
||
expect(indices.every(index => index >= 0)).toBe(true);
|
||
expect(indices).toEqual([...indices].sort((a, b) => a - b));
|
||
});
|
||
|
||
test('ship uses project-native commands and never jumps over mandatory gates', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
expect(text).toMatch(/test commands discovered in Step 4/i);
|
||
expect(text).toContain('**Project-native path:**');
|
||
expect(text).not.toMatch(/skipping evals[^\n]*Step 9/);
|
||
const reviewAndTriage = text.slice(text.indexOf('## Step 9:'), text.indexOf('## Step 11:'));
|
||
expect(reviewAndTriage.match(/continue to Step 12/i)).toBeNull();
|
||
expect(text).not.toContain('Steps 4-6:');
|
||
expect(text).toContain('`baseVersion` as `BASE_VERSION`');
|
||
expect(text).not.toContain('GIT_SEQUENCE_EDITOR');
|
||
expect(text).not.toContain("--exec 'true'");
|
||
expect(text).not.toContain('-X ours');
|
||
expect(text).toContain('````text\nYou are running a ship-workflow');
|
||
});
|
||
|
||
test('ship review shortcuts retain dedup and fixes repeat the whole review cycle', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
const flat = text.replace(/\s+/g, ' ');
|
||
expect(flat).toMatch(/Continue to Step 9\.2 [^.]*then the parent's Exploratory QA step and Step 9\.3/i);
|
||
expect(text).toContain('## Step 9.4: Fix-First and persistence');
|
||
const cycle = flat.slice(flat.indexOf('specialists (9.1)'));
|
||
const order = ['(9.1)', '(9.2)', '(9.2.1)', '(9.3)', '(9.4)'].map(step => cycle.indexOf(step));
|
||
expect(order.every(index => index >= 0)).toBe(true);
|
||
expect(order).toEqual([...order].sort((a, b) => a - b));
|
||
expect(flat).toContain('**Fixes applied below the cap:** Insert Step 5, affected Steps 6–8 and all of Step 9 before the pending Step 10');
|
||
const audit = text.slice(text.indexOf('## Step 7:'), text.indexOf('## Step 8:'));
|
||
expect(audit).not.toContain('Scope Challenge');
|
||
expect(flat).toContain('VERIFY_RESULT stays fail');
|
||
});
|
||
|
||
test('ship excerpt preserves readable detours, audit fallback and final input decisions', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules').replace(/\s+/g, ' ');
|
||
expect(text).toContain('`5 → 6 → 7 → 8 → 9 → 10 → 11 → 11.5`');
|
||
expect(text).toMatch(/all three snapshots must match/i);
|
||
expect(text).toMatch(/does not mean the failed or unrun probes passed/i);
|
||
expect(text).toMatch(/does not pass or bypass the coverage gate/i);
|
||
expect(text).toMatch(/skip only the plan completion audit/i);
|
||
expect(text).toContain('Step 8.1');
|
||
expect(text).toMatch(/Step 9 QA still runs/i);
|
||
expect(text).not.toContain('Every listed change below is metadata:');
|
||
expect(text).not.toContain('No plan file found:** Skip entirely');
|
||
});
|
||
|
||
test('a sliced section is not appended again with its generated header', () => {
|
||
const text = readWorkflowExcerpt('plan-design-review/SKILL.md', '## Review Sections', ASK_QUESTIONS_HEADING);
|
||
expect(text.match(/## Review Sections/g)).toHaveLength(1);
|
||
expect(text).not.toMatch(ASK_QUESTIONS_HEADING);
|
||
expect(text).not.toContain('AUTO-GENERATED');
|
||
});
|
||
|
||
test('ship publishes existing PRs only after shared body composition and scan', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
const publish = text.slice(text.indexOf('## Step 19:'), text.indexOf('## Step 20:'));
|
||
const compose = publish.indexOf('PR_BODY_FILE=$(mktemp');
|
||
const scan = publish.indexOf('gstack-redact --from-file "$PR_BODY_FILE"');
|
||
const edit = publish.indexOf('gh pr edit --body-file');
|
||
expect(compose).toBeGreaterThan(0);
|
||
expect(scan).toBeGreaterThan(compose);
|
||
expect(edit).toBeGreaterThan(scan);
|
||
expect(publish.indexOf('Print the existing URL')).toBeGreaterThan(edit);
|
||
expect(text).not.toContain('Phase 8e.5');
|
||
expect(text).toMatch(/never create an empty commit/i);
|
||
const review = text.slice(text.indexOf('## Step 9:'), text.indexOf('## Step 10:'));
|
||
expect(review.indexOf('## Confidence Calibration')).toBeLessThan(review.indexOf('1. Read'));
|
||
const flat = review.replace(/\s+/g, ' ');
|
||
expect(flat).toContain('**No edits in this pass:**');
|
||
expect(flat).toMatch(/only after it clears may you continue to Step 10/i);
|
||
expect(flat).toMatch(/\*\*Dispatched reviewer output missing:\*\* stop\b/i);
|
||
expect(flat).toMatch(/\*\*Third fixing cycle reached \(`CYCLES >= 3`\):\*\* stop\b[^.]*`converged:false`/i);
|
||
expect(flat).toMatch(/do not run a fourth fixing cycle/i);
|
||
expect(flat).toMatch(/failed\/unavailable required probes block continuation/i);
|
||
});
|
||
|
||
test('ship approval gates stay outside the subagent prompts', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
for (const [step, next, gate] of [[7, 8, '**7. Coverage gate:**'], [8, 9, '### Gate Logic']] as const) {
|
||
const section = text.slice(text.indexOf(`## Step ${step}:`), text.indexOf(`## Step ${next}:`));
|
||
const prompt = section.match(/````text\n([\s\S]*?)\n````/)![1];
|
||
expect(prompt).not.toContain(gate);
|
||
expect(prompt).not.toContain('Use AskUserQuestion:');
|
||
expect(prompt).not.toContain('commit as');
|
||
expect(section.indexOf(gate)).toBeGreaterThan(section.indexOf('\n````\n'));
|
||
}
|
||
expect(text).toContain('"partial":N,"not_done":N');
|
||
expect(text).toContain('"intentionally dropped"');
|
||
});
|
||
|
||
test('expands a body before the end marker in the skeleton', () => {
|
||
const text = readWorkflowExcerpt('document-release/SKILL.md', '# Document Release:', '## Important Rules');
|
||
expect(text).toContain('## Step 2:');
|
||
expect(text).toContain('## Step 9:');
|
||
});
|
||
|
||
test('documentation review precedes publication and keeps changelog protection', () => {
|
||
const text = readWorkflowExcerpt('document-release/SKILL.md', '# Document Release:', '## Important Rules');
|
||
expect(text).toContain('DOC_DIFF_BASE=$(git merge-base origin/<base> HEAD 2>/dev/null || git merge-base <base> HEAD) || exit 1');
|
||
const reviewStart = text.indexOf('## Codex Documentation Review');
|
||
const commit = text.indexOf('## Step 9:');
|
||
expect(reviewStart).toBeGreaterThanOrEqual(0);
|
||
expect(commit).toBeGreaterThan(reviewStart);
|
||
const review = text.slice(reviewStart, commit);
|
||
expectOutsideReviewControlFlow(review, '**Construct the doc-review prompt**');
|
||
for (const token of ['`status: unavailable`', '`outside_status: unavailable`', '`source: none`']) expect(review).toContain(token);
|
||
expect(review).toMatch(/AskUserQuestion once/i);
|
||
expect(review).toMatch(/on A or per-finding approvals/i);
|
||
expect(text).toContain('Step 9 then commits');
|
||
expect(text).toMatch(/needs?\s+attention,?\s+not\s+replacement/i);
|
||
expect(text).not.toContain('Flag and rewrite');
|
||
expect(text).toMatch(/if VERSION is absent, use the completion date only/i);
|
||
});
|
||
|
||
test('Eng preparation and decision procedure precede the four review sections', async () => {
|
||
const { marked } = await import('marked');
|
||
const { skillPath, startMarker, endMarker } = ENG_REVIEW_EXCERPT;
|
||
const eng = readWorkflowExcerpt(skillPath, startMarker, endMarker);
|
||
const stages = ['## Review preparation', '## Retrospective learning', '## Confidence Calibration', '## Decision procedure',
|
||
'### Prepare an unanswered choice', '## Scope Challenge', '### A. Assess the target',
|
||
'### B. Resolve complexity selectors', '### C. Resolve findings', '## Review Sections',
|
||
'### 1. Architecture review', '### 2. Code quality review', '### 3. Test review', '### 4. Performance review']
|
||
.map(heading => eng.indexOf(heading));
|
||
expect(stages.every(index => index >= 0)).toBe(true);
|
||
expect(stages).toEqual([...stages].sort((a, b) => a - b));
|
||
expect(eng.match(/^## Decision procedure$/gm)).toHaveLength(1);
|
||
const procedure = eng.slice(eng.indexOf('## Decision procedure'), eng.indexOf('## Scope Challenge'));
|
||
const headings = marked.lexer(procedure).filter(token => token.type === 'heading' && token.depth === 3);
|
||
expect(headings.map(token => token.text)).toEqual(['Prepare an unanswered choice', 'Send once and wait', 'Record the answer']);
|
||
expect(procedure).toContain("**Pending-record checkpoint.**");
|
||
expect(procedure).toContain('### Send once and wait');
|
||
expect(procedure).toContain("### Record the answer");
|
||
const outputs = ['### TODOS.md updates', '## Approval readiness', '## Required outputs', '## Implementation Tasks',
|
||
'### Unresolved decisions', '### Completion summary', '## Plan File Review Report',
|
||
'### Write to the report file', '## Review Log'].map(heading => eng.indexOf(heading));
|
||
expect(outputs.every(index => index > stages[stages.length - 1]!)).toBe(true);
|
||
expect(outputs).toEqual([...outputs].sort((a, b) => a - b));
|
||
});
|
||
|
||
test('CEO mode handoff precedes its route and spec review stays within persistence', () => {
|
||
const ceo = readWorkflowExcerpt('plan-ceo-review/SKILL.md', '## Step 0: Nuclear Scope Challenge', '## Review Sections');
|
||
const positions = ['### 0D.', '### 0E. Mode Selection', '**Mode handoff:**',
|
||
'Follow the selected mode\'s route:', '### 0F.', '### 0G. Mode-Specific Analysis',
|
||
'### 0H.', '#### Spec Review Loop', '### 0I. Temporal Interrogation']
|
||
.map(heading => ceo.indexOf(heading));
|
||
expect(positions.every(index => index >= 0)).toBe(true);
|
||
expect(positions).toEqual([...positions].sort((a, b) => a - b));
|
||
const persistence = ceo.slice(positions[6], positions[8]);
|
||
expect(persistence.match(/^#### Spec Review Loop$/gm)).toHaveLength(1);
|
||
expect(persistence).not.toMatch(/^## Spec Review Loop$/m);
|
||
expect(ceo.slice(positions[2], positions[3])).toContain('Auto-decided review mode → <selected mode> (your preference)');
|
||
expect(ceo.slice(positions[2], positions[3])).toContain('Mode: <selected mode>; approved decisions: <rows or none>');
|
||
});
|
||
|
||
test('CEO Step 0 headings follow their sequential execution labels', () => {
|
||
const ceo = readWorkflowExcerpt('plan-ceo-review/SKILL.md', '## Step 0: Nuclear Scope Challenge', '## Review Sections');
|
||
const labels = [...ceo.matchAll(/^### (0[A-Z](?:-[A-Za-z]+)?)\. /gm)].map(match => match[1]);
|
||
expect(labels).toEqual(['0A', '0B', '0C', '0D', '0E', '0F', '0G', '0H', '0I']);
|
||
});
|
||
|
||
test('CEO capture locates Mode Selection by name for current and frozen skill copies', () => {
|
||
const dir = mkdtempSync(join(tmpdir(), 'ceo-semantic-capture-'));
|
||
const helper = join(import.meta.dir, 'helpers', 'auq-sdk-capture.ts');
|
||
const runner = join(import.meta.dir, 'helpers', 'agent-sdk-runner.ts');
|
||
const script = join(dir, 'capture.ts');
|
||
writeFileSync(script, `import { mock } from 'bun:test';
|
||
import * as fs from 'node:fs';
|
||
import * as path from 'node:path';
|
||
const calls = [];
|
||
mock.module(${JSON.stringify(runner)}, () => ({resolveClaudeBinary:()=>'/fixture/claude',runAgentSdkTest: async options => {
|
||
calls.push(options);
|
||
void options.canUseTool('AskUserQuestion', {questions:[{header:'Mode',question:'captured mode choice',
|
||
options:['SCOPE EXPANSION','SELECTIVE EXPANSION','HOLD SCOPE','SCOPE REDUCTION'].map(label=>({label,description:''}))}]},
|
||
{toolUseID:'native-mode',signal:options.signal});
|
||
options.signal.throwIfAborted();
|
||
throw Error('capture failed to stop before answering');
|
||
}}));
|
||
const {captureModeSelectionAuq, verboseSkill} = await import(${JSON.stringify(helper)});
|
||
const current = fs.readFileSync(${JSON.stringify(join(import.meta.dir, '..', 'plan-ceo-review', 'SKILL.md'))}, 'utf8');
|
||
const results = [];
|
||
for (const [variant, skill] of [['current', current], ['frozen', verboseSkill()]]) {
|
||
const planDir = path.join(${JSON.stringify(dir)}, variant);
|
||
fs.mkdirSync(path.join(planDir, 'plan-ceo-review'), {recursive:true});
|
||
fs.writeFileSync(path.join(planDir, 'plan-ceo-review', 'SKILL.md'), skill);
|
||
fs.writeFileSync(path.join(planDir, 'plan.md'), 'Review this plan.');
|
||
results.push({variant, heading:skill.match(/^### (0[A-Z])\\. Mode Selection/m)?.[1],
|
||
captured:await captureModeSelectionAuq({planDir, testName:'free-semantic-capture', model:'fake-model'})});
|
||
}
|
||
console.log(JSON.stringify({calls, results}));
|
||
`);
|
||
try {
|
||
const child = spawnSync(process.execPath, [script], { encoding: 'utf8', timeout: 10_000 });
|
||
expect(child.status, `${child.error ?? ''}\n${child.stderr}`).toBe(0);
|
||
const { calls, results } = JSON.parse(child.stdout.trim().split('\n').at(-1)!);
|
||
expect(results).toEqual([
|
||
{ variant: 'current', heading: expect.stringMatching(/^0[A-Z]$/), captured: expect.stringContaining('captured mode choice') },
|
||
{ variant: 'frozen', heading: '0F', captured: expect.stringContaining('captured mode choice') },
|
||
]);
|
||
expect(calls).toHaveLength(2);
|
||
for (const call of calls) {
|
||
expect(call.userPrompt).toContain('Proceed to Mode Selection,');
|
||
expect(call.userPrompt).not.toMatch(/Step 0[A-Z]/);
|
||
expect(call.userPrompt).toContain(join(call.workingDirectory, 'plan-ceo-review', 'SKILL.md'));
|
||
expect(call.userPrompt).toMatch(/read any other SKILL\.md/i);
|
||
expect(call.userPrompt).toMatch(/AskUserQuestion tool and wait for their answer/i);
|
||
expect(call).toMatchObject({ allowedTools: ['Read', 'Write', 'AskUserQuestion'], maxTurns: 12, maxRetries: 0, model: 'fake-model' });
|
||
}
|
||
} finally { rmSync(dir, { recursive: true, force: true }); }
|
||
});
|
||
|
||
test('Eng LLM scope and pending decisions precede the test artifact', () => {
|
||
const eng = readWorkflowExcerpt('plan-eng-review/SKILL.md', '## Scope gate', '## Section self-check');
|
||
const tests = eng.slice(eng.indexOf('### 3. Test review'), eng.indexOf('### 4. Performance review'));
|
||
const scope = tests.indexOf('### LLM/eval scope');
|
||
const decisions = tests.indexOf('**Step 5. Add missing tests to the plan:**');
|
||
const stop = decisions + tests.slice(decisions).search(/stop for each pending decision/i);
|
||
const artifact = tests.indexOf('### Test Plan Artifact');
|
||
expect(0 <= scope && scope < decisions && decisions < stop && stop < artifact).toBe(true);
|
||
expect(tests.match(/For LLM\/prompt changes:/g)).toHaveLength(1);
|
||
expect(tests.slice(artifact)).not.toMatch(/stop for each pending decision/i);
|
||
const fastPath = tests.slice(tests.indexOf('**Fast path:**'), scope);
|
||
expect(fastPath).toMatch(/still check LLM\/eval scope/i);
|
||
});
|
||
|
||
test('plan review evidence and design approval rules precede their use', () => {
|
||
const eng = readWorkflowExcerpt('plan-eng-review/SKILL.md', '## Scope gate', '## Section self-check');
|
||
expect(eng.indexOf('## Confidence Calibration')).toBeLessThan(eng.indexOf('### 1. Architecture review'));
|
||
expectOutsideReviewControlFlow(eng, '**Construct the plan review prompt**');
|
||
expect(eng).toMatch(/evidence, not approval/i);
|
||
expect(eng).toMatch(/new or reopened choices still need their own answers/i);
|
||
const pendingDecision = eng.slice(eng.indexOf('### Send once and wait'), eng.indexOf("### Record the answer"));
|
||
expect(pendingDecision).toMatch(/stop until the actual answer arrives/i);
|
||
expect(pendingDecision.replace(/\s+/g, ' ')).toMatch(/do not apply a remedy, make another call, start the next section or call ExitPlanMode while the choice awaits an answer/i);
|
||
expect(eng.replace(/\s+/g, ' ')).toMatch(/only the authorized working-plan amendments/i);
|
||
const design = readWorkflowExcerpt('plan-design-review/SKILL.md', '## Review Sections', ASK_QUESTIONS_HEADING);
|
||
expect(design).toMatch(/wait for approval, then edit the plan/i);
|
||
const pass4 = design.slice(design.indexOf('### Pass 4:'), design.indexOf('### Pass 5:'));
|
||
expect(pass4.match(/^### /gm)).toHaveLength(1);
|
||
expect(pass4).toMatch(/^#### Design Hard Rules$/m);
|
||
expect(pass4.indexOf('**Pass 4 evaluation:**')).toBeLessThan(pass4.indexOf('\n#### Design Hard Rules'));
|
||
expect(pass4.indexOf('#### Design Hard Rules')).toBeLessThan(pass4.indexOf('FIX TO 10:'));
|
||
expect(pass4).toContain('caps this pass below 8');
|
||
});
|
||
|
||
test('fails closed for missing excerpt markers', () => {
|
||
expect(() => readWorkflowExcerpt('ship/SKILL.md', '# missing', null)).toThrow('Start marker not found');
|
||
expect(() => readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '# missing')).toThrow('End marker not found');
|
||
});
|
||
|
||
test('retro judge includes compare semantics and unambiguous report inputs', () => {
|
||
const text = readWorkflowExcerpt('retro/SKILL.md', '## Instructions', '## Tone');
|
||
expect(text).toContain('## Compare Mode');
|
||
expect(text).toMatch(/one second before the current start/i);
|
||
expect(text).toContain('prs_merged: null');
|
||
expect(text).toContain('`streak_days`');
|
||
expect(text).toContain('### Shipping Streaks');
|
||
expect(text).toContain('### Shortcut Debt');
|
||
expect(text.indexOf('## Capture Learnings')).toBeGreaterThan(text.indexOf('### Step 14:'));
|
||
expect(text).not.toContain('$(date');
|
||
expect(text.match(/today="<today>"/g)).toHaveLength(2);
|
||
const judge = readFileSync(join(import.meta.dir, 'skill-llm-eval.test.ts'), 'utf8');
|
||
expect(judge).toMatch(/skillPath: 'retro\/SKILL.md',[\s\S]*?endMarker: '## Tone'/);
|
||
});
|
||
|
||
test('deploy gates and navigation timing formulas are executable as documented', () => {
|
||
const land = readFileSync(join(import.meta.dir, '../land-and-deploy/SKILL.md.tmpl'), 'utf8');
|
||
expect(land).not.toContain('Skip Step 3, go to Step 4');
|
||
expect(land).toContain('continue to Step 3.4, then Step 3.5 before merging');
|
||
const benchmark = readFileSync(join(import.meta.dir, '../benchmark/SKILL.md.tmpl'), 'utf8');
|
||
const timings = { startTime: 0, domInteractive: 600, domComplete: 1200, loadEventEnd: 1400 };
|
||
for (const [label, expected] of [['DOM Interactive', 600], ['DOM Complete', 1200], ['Full Load', 1400]] as const) {
|
||
const formula = benchmark.match(new RegExp(`\\*\\*${label}\\*\\*: \x60([^\x60]+)\x60`))![1];
|
||
const actual = new Function(...Object.keys(timings), `return ${formula}`)(...Object.values(timings));
|
||
expect(actual).toBe(expected);
|
||
}
|
||
});
|
||
|
||
test('ship commits logical chunks without rewriting existing checkpoint commits', () => {
|
||
const text = readWorkflowExcerpt('ship/SKILL.md', '# Ship:', '## Important Rules');
|
||
const commit = text.slice(text.indexOf('## Step 15:'), text.indexOf('## Step 16:'));
|
||
expect(commit).toMatch(/bisectable commits/i);
|
||
expect(commit).toContain('continue to Step 16');
|
||
expect(commit).not.toMatch(/rebase|reset|squash|fixup|WIP_TODO|gstack-context/);
|
||
expect(text).not.toContain('Step 15.0');
|
||
});
|
||
});
|