@b00dea/cockpit 0.1.0 → 0.1.1

package/dist/surfaces/projection.d.ts

@@ -16,7 +16,7 @@ export interface GuideObservation {
     readonly contentSha256: string;
     readonly contentIdentity: string;
 }
-export type GuideObservationResult = {
+type GuideObservationResult = {
     readonly kind: 'complete';
     readonly observations: readonly GuideObservation[];
     readonly missing: readonly string[];
@@ -24,7 +24,7 @@ export type GuideObservationResult = {
     readonly kind: 'refusal' | 'unavailable';
     readonly diagnostic: ProjectionDiagnostic;
 };
-export interface ProjectionSiblingInput {
+interface ProjectionSiblingInput {
     slug: string;
     mount: Mount;
     directoryAuthority: string;
@@ -58,21 +58,21 @@ export interface ProjectionPlannerInput {
     /** The tools cockpit.toml lists; grants and start-up costs cover exactly these. Every shipped tool when absent. */
     targets?: readonly SurfaceTarget[];
 }
-export interface LoadCostCharacterization {
+interface LoadCostCharacterization {
     measuredOn: string;
     provenance: string;
     metric: 'lines';
     scopeSemantics: 'conditional' | 'full';
 }
-export interface ProjectionDiagnostic {
-    readonly code: 'PROJECTION_INPUT_INVALID' | 'PROJECTION_GUIDE_UNAVAILABLE' | 'PROJECTION_GUIDE_CHANGED' | 'PROJECTION_GUIDE_ESCAPE' | 'PROJECTION_GUIDE_READ_FAILED' | 'PROJECTION_GUIDE_CLOSE_FAILED' | 'PROJECTION_ROOT_AMBIGUOUS' | 'PROJECTION_RESULT_BOUNDS' | 'PROJECTION_MOUNT_MISMATCH' | 'PROJECTION_GRANT_MISMATCH';
+interface ProjectionDiagnostic {
+    readonly code: 'PROJECTION_INPUT_INVALID' | 'PROJECTION_GUIDE_UNAVAILABLE' | 'PROJECTION_GUIDE_CHANGED' | 'PROJECTION_GUIDE_ESCAPE' | 'PROJECTION_GUIDE_SECRET' | 'PROJECTION_GUIDE_READ_FAILED' | 'PROJECTION_GUIDE_CLOSE_FAILED' | 'PROJECTION_ROOT_AMBIGUOUS' | 'PROJECTION_RESULT_BOUNDS' | 'PROJECTION_MOUNT_MISMATCH' | 'PROJECTION_GRANT_MISMATCH';
     readonly message: string;
     readonly target?: string;
     readonly expected?: string;
     readonly actual?: string;
 }
 /** A sibling guide copied into the region of the root AGENTS.md that cockpit owns. */
-export interface ProjectedGuide {
+interface ProjectedGuide {
     readonly sibling: string;
     /** The guide's path inside its sibling, as declared. */
     readonly guide: string;
@@ -82,7 +82,7 @@ export interface ProjectedGuide {
     /** The block written into the root AGENTS.md: a heading, a provenance marker and the guide's text. */
     readonly bytes: string;
 }
-export interface ShippedInstructionCapability {
+interface ShippedInstructionCapability {
     readonly target: SurfaceTarget;
     readonly mechanism: 'root-agents-guide' | 'rulesync-rules';
     readonly capability: 'instructed' | 'generated';

package/dist/surfaces/projection.js

@@ -6,6 +6,7 @@ import { SURFACE_TARGETS } from './contract.js';
 import { GUARD_SURFACE_TARGETS as INSTRUCTION_TARGETS, HARNESS_REGISTRY } from './harness-registry.js';
 import { INSTRUCTION_POINTER_MARKERS } from '../environment/instruction-pointer.js';
 import { exactKeys } from '../exact-keys.js';
+import { foldGuardSpelling } from '../guards/evaluator.js';
 const GUIDE_BYTE_LIMIT = 65_536;
 const GUIDE_COUNT_LIMIT = 256;
 const OBSERVATION_CONTENT_BYTE_LIMIT = 786_432;
@@ -51,15 +52,32 @@ function contained(root, path) {
     const fromRoot = relative(root, path);
     return fromRoot === '' || !fromRoot.startsWith('..') && !isAbsolute(fromRoot);
 }
+// A guide is copied into every agent's instructions, so it never reaches what the guard keeps out of
+// their context: a `.env` or `.env.*` file, anything below a `.secrets` directory, or a declared
+// environment instance. `fromRoot` is the path inside its sibling root; `instances` are folded.
+function secretGuide(fromRoot, path, instances) {
+    const segments = foldGuardSpelling(fromRoot).split('/');
+    const name = segments.at(-1);
+    if (instances.has(foldGuardSpelling(path)))
+        return 'a declared environment instance';
+    if (segments.includes('.secrets'))
+        return 'below a .secrets directory';
+    if (name === '.env' || name.startsWith('.env.'))
+        return 'an environment file';
+    return undefined;
+}
 function snapshotRequests(input) {
     const snapshot = snapshotJson(input);
-    if (!isObject(snapshot) || !exactKeys(snapshot, ['allowedRoots', 'requests']) || !Array.isArray(snapshot.requests)
+    if (!isObject(snapshot) || !exactKeys(snapshot, ['allowedRoots', 'requests'], ['instances']) || !Array.isArray(snapshot.requests)
         || snapshot.requests.length > GUIDE_COUNT_LIMIT)
         return undefined;
     const allowedRoots = stringArray(snapshot.allowedRoots);
     if (!allowedRoots || allowedRoots.length === 0 || allowedRoots.length > GUIDE_COUNT_LIMIT
         || new Set(allowedRoots).size !== allowedRoots.length || allowedRoots.some(root => !isAbsolute(root)))
         return undefined;
+    const instances = snapshot.instances === undefined ? [] : stringArray(snapshot.instances);
+    if (!instances || instances.length > GUIDE_COUNT_LIMIT || instances.some(path => !isAbsolute(path)))
+        return undefined;
     const result = [];
     const identities = new Set();
     for (const request of snapshot.requests) {
@@ -77,7 +95,7 @@ function snapshotRequests(input) {
         identities.add(identity);
         result.push({ slug: request.slug, root: request.root, sourcePath });
     }
-    return { requests: result, allowedRoots };
+    return { requests: result, allowedRoots, instances };
 }
 function statIdentity(stat) {
     return `${stat.dev}:${stat.ino}:${stat.mode}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
@@ -168,7 +186,15 @@ async function pathIdentity(sourcePath) {
     const target = await lstat(contentPath, { bigint: true });
     return { entry, entryType, ...(linkTarget === undefined ? {} : { linkTarget }), contentPath, target };
 }
-async function readGuide(request, requestRoot) {
+function secretGuideDiagnostic(request, reason, resolved) {
+    return diagnostic('PROJECTION_GUIDE_SECRET', `guide ${request.sourcePath} ${resolved === undefined ? 'is' : `resolves to ${resolved},`} ${reason}, `
+        + 'which the guard keeps out of agent context, and sync would copy it into the root AGENTS.md; '
+        + `${resolved === undefined ? '' : 'replace the link with a file of guidance, or '}remove it from the guides of sibling ${request.slug} in cockpit.toml`, { target: request.sourcePath });
+}
+async function readGuide(request, requestRoot, instances) {
+    const named = secretGuide(relative(request.root, request.sourcePath), request.sourcePath, instances);
+    if (named)
+        return secretGuideDiagnostic(request, named);
     if (!await rootAuthorityStable(requestRoot)) {
         return diagnostic('PROJECTION_GUIDE_CHANGED', `declared sibling root changed before guide observation: ${request.root}`, { target: request.root });
     }
@@ -189,6 +215,10 @@ async function readGuide(request, requestRoot) {
             target: request.sourcePath, expected: requestRoot.canonical, actual: pathBefore.contentPath,
         });
     }
+    // A link spelled like a guide reaches its target's bytes.
+    const resolved = secretGuide(relative(requestRoot.canonical, pathBefore.contentPath), pathBefore.contentPath, instances);
+    if (resolved)
+        return secretGuideDiagnostic(request, resolved, pathBefore.contentPath);
     let handle;
     let result;
     try {
@@ -307,6 +337,11 @@ export async function observeSiblingGuides(input) {
     if (new Set(allowedRoots.map(root => root.canonical)).size !== allowedRoots.length) {
         return finishRootObservation(allowedRoots, observedOutcome({ kind: 'refusal', diagnostic: diagnostic('PROJECTION_ROOT_AMBIGUOUS', 'declared sibling roots resolve to the same canonical authority') }));
     }
+    // Each instance under every spelling a guide can reach it by: as declared, and below its root's real path.
+    const instances = new Set(captured.instances.flatMap(path => {
+        const root = allowedRoots.find(candidate => contained(candidate.declared, path));
+        return root ? [path, join(root.canonical, relative(root.declared, path))] : [path];
+    }).map(foldGuardSpelling));
     const observations = [];
     const missing = [];
     let contentBytes = 0;
@@ -321,11 +356,11 @@ export async function observeSiblingGuides(input) {
             return finishRootObservation(allowedRoots, observedOutcome({ kind: 'refusal', diagnostic: diagnostic('PROJECTION_INPUT_INVALID', `guide request is not bound to its most-specific sibling root: ${request.sourcePath}`, { target: request.sourcePath }) }));
         }
         const requestRoot = allowedRoots.find(root => root.declared === request.root);
-        const observed = await readGuide(request, requestRoot);
+        const observed = await readGuide(request, requestRoot, instances);
         if (observed === 'missing')
             missing.push(request.sourcePath);
         else if ('code' in observed) {
-            const refusal = ['PROJECTION_GUIDE_CHANGED', 'PROJECTION_GUIDE_ESCAPE', 'PROJECTION_GUIDE_READ_FAILED',
+            const refusal = ['PROJECTION_GUIDE_CHANGED', 'PROJECTION_GUIDE_ESCAPE', 'PROJECTION_GUIDE_SECRET', 'PROJECTION_GUIDE_READ_FAILED',
                 'PROJECTION_GUIDE_CLOSE_FAILED', 'PROJECTION_RESULT_BOUNDS'].includes(observed.code);
             return finishRootObservation(allowedRoots, observedOutcome({ kind: refusal ? 'refusal' : 'unavailable', diagnostic: observed }));
         }
@@ -365,7 +400,7 @@ function capturePlannerInput(input) {
         return undefined;
     const activeProfiles = stringArray(value.activeProfiles);
     if (!activeProfiles || new Set(activeProfiles).size !== activeProfiles.length
-        || activeProfiles.some(profile => !/^[a-z0-9][a-z0-9.-]*$/.test(profile)))
+        || activeProfiles.some(profile => !/^[a-z0-9][a-z0-9_.-]*$/.test(profile)))
         return undefined;
     const siblings = [];
     const siblingSlugs = new Set();

package/dist/surfaces/render.d.ts

@@ -1,10 +1,5 @@
-import { type CustomHarness as CustomHarnessValue } from '../schema.js';
 import { type SurfaceFeature, type SurfaceTarget } from './contract.js';
-import { type SurfaceGenerationOutcome, type SurfaceGenerationWarning } from './generator-adapter.js';
-import type { SurfaceMergeResult } from './merge.js';
-import type { McpCollectionOutcome } from './mcp.js';
-import type { ProjectionPlanResult } from './projection.js';
-import type { RestrictionExpansionResult } from './restrictions.js';
+import { type SurfaceGenerationWarning } from './generator-adapter.js';
 import { type SurfaceDesiredEntry, type SurfaceDiagnostic } from './ownership.js';
 export type SurfaceInputEvidence = Readonly<{
     kind: 'guide';
@@ -29,7 +24,7 @@ export type SurfaceInputEvidence = Readonly<{
     sourceSha256: string;
     resultSha256: string;
 }>;
-export interface NativeSurfaceFragment {
+interface NativeSurfaceFragment {
     readonly target: SurfaceTarget;
     readonly path: string;
     readonly baseSha256: string;
@@ -52,7 +47,7 @@ export interface CustomSurfaceReceipt {
         scope: 'always' | 'scoped';
     }>[];
 }
-export type SurfaceRenderResult = Readonly<{
+type SurfaceRenderResult = Readonly<{
     kind: 'complete';
     entries: readonly SurfaceDesiredEntry[];
     inputs: readonly SurfaceInputEvidence[];
@@ -65,43 +60,8 @@ export interface NativeFragmentSet {
     readonly modelSha256: string;
     readonly fragments: readonly NativeSurfaceFragment[];
 }
-/** A reference file pulled on demand by one shipped skill; rendered beside that skill's entry point on every built-in harness. */
-export interface SkillReference {
-    readonly skill: string;
-    readonly path: string;
-    readonly bytes: string;
-}
-export interface SurfaceRenderInput {
-    readonly configuredHarnesses: readonly string[];
-    readonly merge: Extract<SurfaceMergeResult, {
-        kind: 'complete';
-    }>;
-    readonly generated: Extract<SurfaceGenerationOutcome, {
-        kind: 'complete';
-    }>;
-    readonly projection: Extract<ProjectionPlanResult, {
-        kind: 'complete';
-    }>;
-    readonly mcp: Extract<McpCollectionOutcome, {
-        kind: 'complete';
-    }>;
-    readonly restrictions: Extract<RestrictionExpansionResult, {
-        kind: 'complete';
-    }>;
-    readonly nativeMcp: NativeFragmentSet;
-    readonly nativeGrants: NativeFragmentSet;
-    readonly browser: unknown | null;
-    readonly browserReference: string | null;
-    readonly skillReferences: readonly SkillReference[];
-    readonly testing: unknown | null;
-    readonly customHarnesses: readonly CustomHarnessValue[];
-    readonly customReceipts: readonly CustomSurfaceReceipt[];
-    readonly sourceEvidence: readonly Extract<SurfaceInputEvidence, {
-        kind: 'guide' | 'mcp';
-    }>[];
-}
 export declare function surfaceModelSha256(value: unknown): string | undefined;
-export type HookSettingsComposition = Readonly<{
+type HookSettingsComposition = Readonly<{
     kind: 'complete';
     value: Record<string, unknown>;
 }> | Readonly<{
@@ -116,3 +76,4 @@ export type HookSettingsComposition = Readonly<{
  */
 export declare function composeHookSettings(values: readonly unknown[]): HookSettingsComposition;
 export declare function renderSurfaceSet(input: unknown): SurfaceRenderResult;
+export {};

package/dist/surfaces/render.js

@@ -364,8 +364,10 @@ export function renderSurfaceSet(input) {
         if (harness.servers.length > 0)
             mcpTargets.add(harness.target);
     }
-    if (captured.mcp.result.servers.length > 0 && mcpTargets.size === 0)
+    // A remote server may fit none of the listed tools, and says so; a local one fits every tool.
+    if (captured.mcp.result.servers.some(server => object(server) && server.transport !== 'http') && mcpTargets.size === 0) {
         return refuse('SURFACE_INPUT_INVALID', 'MCP model has no matching native transport');
+    }
     const mcpModelDigest = surfaceModelSha256(captured.mcp.result);
     if (!mcpModelDigest)
         return refuse('SURFACE_BOUNDS', 'MCP model cannot be captured for native binding');
@@ -475,8 +477,9 @@ export function renderSurfaceSet(input) {
     for (const wrapper of captured.mcp.result.wrappers) {
         if (!validFile(wrapper))
             return refuse('SURFACE_INPUT_INVALID', 'MCP wrapper output is malformed');
+        // A local server's wrapper starts it; a remote server's wrapper runs its headers helper.
         const server = captured.mcp.result.servers.find(row => object(row) && typeof row.name === 'string'
-            && wrapper.path === `.cockpit/mcp/${sha256Hex(row.name)}.sh`);
+            && wrapper.path === `.cockpit/mcp/${sha256Hex(row.name)}${row.transport === 'http' ? '.headers' : ''}.sh`);
         const harnesses = object(server) ? captured.mcp.result.harnesses.filter(row => object(row)
             && Array.isArray(row.servers) && row.servers.some(transport => object(transport) && transport.name === server.name))
             .map(row => row.target) : [];

package/dist/team-metadata.js

@@ -253,7 +253,8 @@ async function ignoreBlock(root, config) {
     const siblingsRoot = config.cockpit.siblings_root;
     if (/[\0\r\n]/.test(siblingsRoot))
         return undefined;
-    const patterns = ['/node_modules/', '/.cockpit/local/', '/env/.secrets/*', '!/env/.secrets/.gitignore'];
+    // Claude Code's machine-local settings, where `cockpit use` grants a served checkout.
+    const patterns = ['/node_modules/', '/.cockpit/local/', '/.claude/settings.local.json', '/env/.secrets/*', '!/env/.secrets/.gitignore'];
     const inside = (path, kind = 'directory') => {
         const local = relative(root, path);
         if (local === '' || local === '..' || local.startsWith(`..${sep}`) || isAbsolute(local))

package/dist/testing/test-protection.d.ts

@@ -0,0 +1,34 @@
+export interface DiffFile {
+    old: string;
+    next: string;
+    hunk: boolean;
+    removed: boolean;
+    removedLines: string[];
+    added: string[];
+    renamed: boolean;
+    deleted: boolean;
+}
+export interface WeakeningFinding {
+    readonly path: string;
+    readonly kind: WeakeningKind;
+    readonly reason: string;
+}
+type WeakeningKind = 'test-file-removed' | 'test-skipped' | 'check-suppressed' | 'tests-removed' | 'assertions-removed' | 'assertions-loosened' | 'assertion-vacuous' | 'test-selection-narrowed';
+/** Reads `git diff` output (taken with --unified=0 and core.quotePath=true) into one record per file. */
+export declare function parseDiff(diff: string): DiffFile[];
+/**
+ * Why added lines turn off or short-circuit what runs. Only explicit added-line forms are measured;
+ * this is not JavaScript dataflow analysis.
+ */
+export declare function additiveBypassReasons(added: readonly string[]): string[];
+export interface TestRoles {
+    readonly isTest: (path: string) => boolean;
+    /** A runner's configuration, or a manifest that carries a test script. */
+    readonly isTestConfig: (path: string) => boolean;
+}
+/**
+ * The findings a diff earns over the files `roles` calls tests. A diff cannot prove that a
+ * replacement keeps its force, so a removal is flagged and a person acknowledges the legitimate ones.
+ */
+export declare function classifyTestWeakening(files: readonly DiffFile[], roles: TestRoles): WeakeningFinding[];
+export {};

package/dist/testing/test-protection.js

@@ -0,0 +1,137 @@
+// Detects a change that makes tests pass by weakening them. It has no imports on purpose: CI runs
+// the base revision's copy of scripts/check-test-protection.mjs beside this file, so the detector
+// that judges a change is never the one the change edited, and the same code judges a consumer's
+// checkout when `work grade` runs.
+function gitPath(value) {
+    if (!value.startsWith('"'))
+        return value;
+    // Git quotes paths as C strings, including octal UTF-8 bytes.
+    const bytes = [];
+    for (let i = 1; i < value.length - 1; i++) {
+        if (value[i] !== '\\') {
+            bytes.push(...Buffer.from(value[i]));
+            continue;
+        }
+        const octal = /^[0-7]{1,3}/.exec(value.slice(i + 1))?.[0];
+        if (octal) {
+            bytes.push(Number.parseInt(octal, 8));
+            i += octal.length;
+            continue;
+        }
+        const escaped = value[++i];
+        const controls = { t: '\t', n: '\n', r: '\r', b: '\b', f: '\f', v: '\v', '\\': '\\', '"': '"' };
+        if (!(escaped in controls))
+            throw new Error('unsupported Git path escape');
+        bytes.push(...Buffer.from(controls[escaped]));
+    }
+    return Buffer.from(bytes).toString('utf8');
+}
+/** Reads `git diff` output (taken with --unified=0 and core.quotePath=true) into one record per file. */
+export function parseDiff(diff) {
+    const files = [];
+    let file;
+    for (const line of diff.split('\n')) {
+        if (line.startsWith('diff --git ')) {
+            const names = /^diff --git ("(?:\\.|[^"])*"|a\/\S+) ("(?:\\.|[^"])*"|b\/\S+)$/.exec(line);
+            file = { old: names ? gitPath(names[1]).slice(2) : '', next: names ? gitPath(names[2]).slice(2) : '', hunk: false, removed: false, removedLines: [], renamed: false, deleted: false, added: [] };
+            files.push(file);
+        }
+        else if (file) {
+            if (line.startsWith('@@ '))
+                file.hunk = true;
+            else if (!file.hunk && line.startsWith('--- '))
+                file.old = gitPath(line.slice(4)).replace(/^a\//, '');
+            else if (!file.hunk && line.startsWith('+++ '))
+                file.next = gitPath(line.slice(4)).replace(/^b\//, '');
+            else if (line.startsWith('rename from ')) {
+                file.old = gitPath(line.slice(12));
+                file.renamed = true;
+            }
+            else if (line.startsWith('rename to '))
+                file.next = gitPath(line.slice(10));
+            else if (line.startsWith('deleted file mode '))
+                file.deleted = true;
+            else if (line.startsWith('-') && line.slice(1).trim()) {
+                file.removed = true;
+                file.removedLines.push(line.slice(1));
+            }
+            else if (line.startsWith('+'))
+                file.added.push(line.slice(1));
+            else if (line.startsWith('Binary files '))
+                file.removed = true;
+        }
+    }
+    return files;
+}
+/**
+ * Why added lines turn off or short-circuit what runs. Only explicit added-line forms are measured;
+ * this is not JavaScript dataflow analysis.
+ */
+export function additiveBypassReasons(added) {
+    const reasons = [];
+    if (/(?:\.\s*|\[\s*['"])(?:skip|todo|only|skipIf|runIf|fails)\b|\b(?:skip|todo|only)\s*:\s*true/.test(added.join('\n'))) {
+        reasons.push('test selection or expected-failure semantics added');
+    }
+    if (added.some(line => /^[ \t]*return[ \t]*;?[ \t]*(?:\/\/.*)?$/.test(line))) {
+        reasons.push('potential additive control-flow bypass: bare return added');
+    }
+    if (added.some(line => /^[ \t]*(?:if\s*\(\s*(?:true|1)\s*\)\s*(?:\{\s*)?return\s*;?(?:\s*\})?\s*(?:\/\/.*)?$|if\s*\(\s*(?:false|0|null|undefined)\s*\)\s*\{|(?:false\s*&&|true\s*\|\|)\s*(?:describe|test|it|suite)\s*\(|process\s*\.\s*exit\s*\(\s*(?:0\s*)?\))/.test(line))) {
+        reasons.push('potential additive control-flow bypass: explicit static bypass added');
+    }
+    return reasons;
+}
+// JS/TS first, then the Python forms that mean the same. A match in an added comment still counts:
+// a directive is a comment.
+const SKIPPED = /\b(?:it|test|describe|suite|context|bench)\s*\.\s*(?:skip|only|todo|skipIf|runIf|fails|failing|fixme)\b|\b(?:xit|xtest|xdescribe|xcontext|fit|fdescribe)\s*\(|\b(?:skip|only)\s*:\s*true|\bpytest\s*\.\s*(?:mark\s*\.\s*(?:skip|skipif|xfail)|skip)\b|\bunittest\s*\.\s*(?:skip|skipIf|skipUnless|expectedFailure)\b|^\s*@(?:skip|skipIf|skipUnless|expectedFailure)\b|\bself\s*\.\s*skipTest\s*\(/;
+const SUPPRESSED = /@ts-ignore|@ts-nocheck|eslint-disable|\bnoqa\b|\btype:\s*ignore\b|\bpylint:\s*disable\b/;
+const TEST_DECLARATION = /^\s*(?:(?:it|test)\s*(?:\.\s*\w+)*\s*(?:\.\s*each\s*\([^)]*\))?\s*\(|def\s+test_|async\s+def\s+test_)/;
+const ASSERTION = /\bexpect\s*\(|\bassert\b|\bassert[A-Z]\w*\s*\(|\.should\b|\bt\.(?:is|true|deepEqual|equal|throws)\s*\(/;
+const STRONG = /\.(?:toBe|toEqual|toStrictEqual|toMatchObject|toHaveBeenCalledWith|toHaveLength|toThrow\w*|toContain\w*|toMatch)\s*\(|\bassert(?:Equal|Equals|In|Raises|IsNone)\b|\bassert\s+\S+\s*(?:==|!=|in)\s/;
+const WEAK = /\.(?:toBeDefined|toBeTruthy|toBeFalsy|toBeUndefined)\s*\(|\bexpect\.(?:anything|any)\s*\(|\.not\.toBeNull\s*\(|\bassert\s+\w+\s*$|\bassertTrue\s*\(\s*\w+\s*\)/;
+const VACUOUS = /\bexpect\s*\(\s*(?:true|1|false|0|null|'[^']*'|"[^"]*")\s*\)\s*\.\s*(?:toBe|toEqual|toStrictEqual)\s*\(|\bassert\s+(?:True|1|not\s+False)\s*$|\bassert\s*\(?\s*true\s*\)?\s*;?\s*$|\bassertTrue\s*\(\s*True\s*\)/;
+// What a test runner's own configuration says about which files it runs.
+const NARROWING = /\b(?:exclude|testPathIgnorePatterns|testIgnore|ignore|deselect|norecursedirs|skip)\b|--ignore\b|--deselect\b|--exclude\b|--passWithNoTests|\|\|\s*true\b|\bexit\s+0\b/;
+const WIDENING = /\b(?:include|testMatch|testRegex|testpaths|projects)\b/;
+const TEST_SCRIPT = /^\s*"(?:pre|post)?test[^"]*"\s*:/;
+const count = (lines, pattern) => lines.filter(line => pattern.test(line)).length;
+/**
+ * The findings a diff earns over the files `roles` calls tests. A diff cannot prove that a
+ * replacement keeps its force, so a removal is flagged and a person acknowledges the legitimate ones.
+ */
+export function classifyTestWeakening(files, roles) {
+    const findings = [];
+    for (const file of files) {
+        const path = file.deleted || file.next === '/dev/null' ? file.old : file.next;
+        const finding = (kind, reason) => findings.push({ path, kind, reason });
+        const wasTest = roles.isTest(file.old);
+        if (wasTest && (file.deleted || file.next === '/dev/null' || file.renamed && !roles.isTest(file.next))) {
+            finding('test-file-removed', 'a test file was deleted or moved out of the tests');
+            continue;
+        }
+        if (roles.isTest(path)) {
+            if (count(file.added, SKIPPED))
+                finding('test-skipped', 'a test was skipped, focused, marked todo or expected to fail');
+            if (count(file.added, SUPPRESSED))
+                finding('check-suppressed', 'a type or lint check was suppressed in a test');
+            if (count(file.removedLines, TEST_DECLARATION) > count(file.added, TEST_DECLARATION))
+                finding('tests-removed', 'more tests were removed than added');
+            if (count(file.removedLines, ASSERTION) > count(file.added, ASSERTION))
+                finding('assertions-removed', 'more assertions were removed than added');
+            else if (count(file.removedLines, STRONG) > count(file.added, STRONG) && count(file.added, WEAK) > count(file.removedLines, WEAK)) {
+                finding('assertions-loosened', 'specific assertions were replaced by weaker ones');
+            }
+            if (count(file.added, VACUOUS))
+                finding('assertion-vacuous', 'an assertion that cannot fail was added');
+        }
+        else if (roles.isTestConfig(path)) {
+            const manifest = /(?:^|\/)package\.json$/.test(path);
+            const scriptsAdded = manifest ? file.added.filter(line => TEST_SCRIPT.test(line)) : file.added;
+            if (count(scriptsAdded, NARROWING))
+                finding('test-selection-narrowed', 'test configuration now excludes, ignores or tolerates the absence of tests');
+            else if (manifest ? count(file.removedLines, TEST_SCRIPT) > count(scriptsAdded, TEST_SCRIPT)
+                : count(file.removedLines, WIDENING) > count(file.added, WIDENING))
+                finding('test-selection-narrowed', 'test configuration no longer selects what it selected');
+        }
+    }
+    return findings;
+}

package/dist/testing/weakening.d.ts

@@ -0,0 +1,15 @@
+import { type DiffFile, type WeakeningFinding } from './test-protection.js';
+export interface TestFilePatterns {
+    readonly tests: readonly string[];
+    readonly configuration: readonly string[];
+    /** Where the test-file patterns came from, stated beside every finding. */
+    readonly source: string;
+}
+export declare function testFilePatterns(declared: readonly string[] | undefined): TestFilePatterns;
+export declare function weakeningFindings(files: readonly DiffFile[], patterns: TestFilePatterns): WeakeningFinding[];
+export interface RepositoryWeakening extends WeakeningFinding {
+    readonly repository: string;
+}
+/** The digest an acknowledgement binds: exactly these findings, and no others, are acknowledged. */
+export declare function testWeakeningDigest(findings: readonly RepositoryWeakening[]): string;
+export declare const describeWeakening: (row: RepositoryWeakening) => string;

package/dist/testing/weakening.js

@@ -0,0 +1,30 @@
+// Owns which files a checkout treats as tests and how a finding is identified: the patterns a
+// consumer declared under [testing] test_files or, failing that, the common layouts, plus the digest
+// a person's acknowledgement binds to. The detection itself is test-protection.ts.
+import { sha256Hex } from '../sha256.js';
+import { scopeMatcher } from '../work-orders/contract.js';
+import { classifyTestWeakening } from './test-protection.js';
+const DEFAULT_TEST_FILES = Object.freeze([
+    '**/*.test.*', '**/*.spec.*', '**/__tests__/**', '**/tests/**', '**/test/**', '**/e2e/**',
+    '**/test_*.py', '**/*_test.py', '**/conftest.py', '**/*_test.go', '**/*Test.java', '**/*_spec.rb',
+]);
+// What decides which tests run; a declared test_files list does not replace these.
+const TEST_CONFIGURATION = Object.freeze([
+    '**/vitest.config.*', '**/vitest.workspace.*', '**/jest.config.*', '**/playwright.config.*', '**/.mocharc*',
+    '**/pytest.ini', '**/tox.ini', '**/package.json',
+]);
+export function testFilePatterns(declared) {
+    return declared?.length
+        ? { tests: declared, configuration: TEST_CONFIGURATION, source: '[testing] test_files in cockpit.toml' }
+        : { tests: DEFAULT_TEST_FILES, configuration: TEST_CONFIGURATION, source: 'the built-in test-file patterns for common layouts (no [testing] test_files declared)' };
+}
+export function weakeningFindings(files, patterns) {
+    const roles = { isTest: scopeMatcher(patterns.tests), isTestConfig: scopeMatcher(patterns.configuration) };
+    return classifyTestWeakening(files, roles);
+}
+/** The digest an acknowledgement binds: exactly these findings, and no others, are acknowledged. */
+export function testWeakeningDigest(findings) {
+    const rows = findings.map(row => `${row.repository}\0${row.path}\0${row.kind}`).sort();
+    return sha256Hex(JSON.stringify(rows));
+}
+export const describeWeakening = (row) => `${row.repository === '.' ? row.path : `${row.repository}:${row.path}`}: ${row.kind} (${row.reason})`;

package/dist/work-orders/application-closure.d.ts

@@ -0,0 +1,7 @@
+import type { WorkRecord } from './store.js';
+import { type WorkApplicationOutcome, type WorkContext, type WorkRequest } from './application-context.js';
+export declare const pendingCi: (record: WorkRecord) => string[];
+export declare function signoff(request: Extract<WorkRequest, {
+    operation: 'work-signoff';
+}>, context: WorkContext): Promise<WorkApplicationOutcome>;
+export declare function verify(context: WorkContext): Promise<WorkApplicationOutcome>;

package/dist/work-orders/application-closure.js

@@ -0,0 +1,76 @@
+// How an order closes: `work signoff` closes it as done, partial or abandoned, and `work verify`, the CI
+// job, checks every closure and confirms the steps that awaited CI.
+import { runningInCi } from '../autonomy.js';
+import { RefusalError } from '../environment/contract.js';
+import { complete, now, refusal, TERMINAL, unsatisfied } from './application-context.js';
+import { decisions, recordProblem, unresolvedDecisions } from './application-decisions.js';
+const CLOSURE = Object.freeze({ independent: 'graded', checks: 'checks-passed', self: 'self-reported' });
+export const pendingCi = (record) => [
+    ...record.acknowledgements.filter(row => row.by === 'ci').map(() => 'acknowledge'),
+    ...record.accepted.by === 'ci' ? ['accept'] : [], ...record.amendments.filter(row => row.by === 'ci').map(() => 'amend'),
+    ...record.notes.filter(row => row.kind === 'answer' && row.by === 'ci').map(() => 'answer'), ...record.closure?.by === 'ci' ? ['signoff'] : [],
+];
+export async function signoff(request, context) {
+    const { composition, operation, policy, store, current, gated } = context;
+    const record = await store.read(request.workOrderId);
+    if (!record)
+        return refusal(operation, `${request.workOrderId} is not accepted`);
+    if (TERMINAL.has(record.state))
+        return refusal(operation, `${request.workOrderId} is already closed (${record.state})`);
+    let how;
+    if (request.close === 'done') {
+        const { order } = await current(request.workOrderId);
+        if (record.state !== 'graded' || !record.grade?.passed || record.grade.digest !== record.accepted.digest) {
+            return refusal(operation, `${order.id} is ${record.state}, not graded; run npx --no cockpit work grade --config <your cockpit.toml> --work-order ${order.id}`);
+        }
+        const open = await Promise.all(order.depends_on.map(async (dependency) => (await store.read(dependency))?.state === 'done' ? undefined : dependency));
+        if (open.some(Boolean))
+            return refusal(operation, `${order.id} depends on ${open.filter(Boolean).join(', ')}, which ${open.filter(Boolean).length === 1 ? 'is' : 'are'} not done`);
+        how = CLOSURE[record.grade.mode];
+    }
+    else {
+        if (!request.note)
+            return refusal(operation, `closing ${request.workOrderId} as ${request.close} needs --note saying what was and was not done`);
+        how = request.close;
+    }
+    // Every closure, partial and abandoned too, settles the order's decisions: work that stops still made them.
+    const open = await unresolvedDecisions(record, composition);
+    if (open.length)
+        return refusal(operation, `${request.workOrderId} cannot close while ${open.join('; ')}`);
+    // A grade found the agent's own amendments lowered the bar; a re-grade must not let it close the order unseen.
+    const failedReview = record.amendmentsFailedReview;
+    const decider = failedReview && policy.gates.signoff === 'agent' ? 'person' : policy.gates.signoff;
+    return gated('signoff', decider, [`Close ${request.workOrderId} as ${request.close} (${how})`, ...request.note ? [`Note: ${request.note}`] : [],
+        ...failedReview ? [`A grade found the agent's amendments lower the bar: ${failedReview.note}`] : [],
+        ...record.grade ? record.grade.criteria.map(row => `${row.id}: ${row.verdict} — ${row.note}`) : [],
+        ...decisions(record).map(row => `Decision ${row.decision} (${row.title}): ${row.resolution.record ? `recorded in ${row.resolution.record}` : `no lasting decision — ${row.resolution.text}`}`)], 'signoff', async (by) => store.update(request.workOrderId, async (existing) => {
+        if (!existing || existing.state !== record.state || existing.accepted.digest !== record.accepted.digest || existing.notes.length !== record.notes.length) {
+            throw new RefusalError(`${request.workOrderId} changed while this prompt was open`);
+        }
+        const state = request.close;
+        return { record: { ...existing, state, closure: { at: now(), by, how, ...request.note ? { note: request.note } : {} } },
+            value: complete(operation, { id: request.workOrderId, state, closedAs: how, by }) };
+    }));
+}
+export async function verify(context) {
+    const { composition, operation, store, observe } = context;
+    const problems = [];
+    const awaiting = [];
+    for (const record of await store.list()) {
+        const row = await observe(record.id);
+        if (!TERMINAL.has(record.state) && row.digest !== record.accepted.digest)
+            problems.push(`${record.id} changed since it was accepted; accept the change or revert it`);
+        if (record.state === 'done' && (!record.grade?.passed || record.grade.digest !== record.accepted.digest || !record.closure))
+            problems.push(`${record.id} is done without a passing grade of its accepted contract`);
+        for (const row of decisions(record)) {
+            const cited = row.resolution?.record;
+            const problem = cited && recordProblem(await composition.readDocsFile(cited), cited, record.id, false);
+            if (problem)
+                problems.push(`${record.id} decision ${row.decision}: ${problem}`);
+        }
+        awaiting.push(...pendingCi(record).map(step => `${record.id} ${step}`));
+    }
+    const ci = runningInCi(composition.env);
+    const value = { ci, problems, ...ci ? { confirmed: awaiting } : { awaitingCi: awaiting } };
+    return problems.length ? unsatisfied(operation, value, problems.join('; ')) : complete(operation, value);
+}