@skill-harness/core 0.17.0 → 0.18.0

package/dist/qualification-panel-store.js

@@ -1,188 +0,0 @@
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { collapseQualificationJudgePanel, aggregateQualificationCell } from "./qualification-panels.js";
-import { readQualificationJudgePanelMember } from "./qualification-runner.js";
-import { atomicWriteCanonical, qualificationSpoolPaths, readCanonicalJson, readQualificationInvocation, readQualificationSpoolConfig } from "./qualification-store.js";
-import { qualificationCanonicalJson } from "./qualification-config.js";
-export function recordQualificationJudgePanel(options) {
-    qualificationDerivedId(options.panel_id, "panel_id");
-    const config = readQualificationSpoolConfig(options.spool_dir);
-    if (!config.judge_panel || !config.board)
-        throw new Error("qualification spool does not select judge panels");
-    const declaredCell = config.board.cells.find((cell) => cell.panels.some((panel) => panel.id === options.panel_id));
-    if (!declaredCell)
-        throw new Error(`qualification panel ${options.panel_id} is not declared by the approved board`);
-    const invocations = options.member_invocation_ids.map((id) => readQualificationInvocation(options.spool_dir, id));
-    if (invocations.length < 2 || invocations.length > 3)
-        throw new Error("qualification panel requires two or three member invocation ids");
-    const first = invocations[0];
-    if (!first.panel || first.panel.id !== options.panel_id)
-        throw new Error("qualification panel id does not match its first member");
-    for (const invocation of invocations)
-        assertInvocationMatchesDeclaredCell(invocation, declaredCell);
-    for (const [index, invocation] of invocations.entries()) {
-        if (!invocation.panel || invocation.panel.id !== options.panel_id || invocation.panel.member_ordinal !== index + 1 ||
-            invocation.panel.subject_invocation_id !== first.panel.subject_invocation_id ||
-            invocation.panel.subject_artifact_sha256 !== first.panel.subject_artifact_sha256 ||
-            invocation.measurement_identity_sha256 !== first.measurement_identity_sha256 ||
-            invocation.scenario.id !== first.scenario.id || invocation.scenario.version !== first.scenario.version ||
-            invocation.scenario.stimulus_sha256 !== first.scenario.stimulus_sha256 || invocation.scenario.rubric_sha256 !== first.scenario.rubric_sha256 ||
-            invocation.repetition !== first.repetition || invocation.arms.subject !== first.arms.subject || invocation.arms.judge !== first.arms.judge) {
-            throw new Error(`qualification panel member ${invocation.invocation_id} binding mismatch`);
-        }
-    }
-    const members = options.member_invocation_ids.map((id) => readQualificationJudgePanelMember(options.spool_dir, id));
-    const result = collapseQualificationJudgePanel({
-        panel_id: options.panel_id,
-        scenario_id: declaredCell.scenario_id,
-        subject_arm: declaredCell.subject_arm,
-        repetition: declaredCell.panels.find((panel) => panel.id === options.panel_id).repetition,
-        critical: declaredCell.critical,
-        members,
-    });
-    if (result.state === "unresolved" && result.disagreement.initial_split)
-        throw new Error(`qualification panel ${options.panel_id} requires its authorized tie-break before a final result can be recorded`);
-    const path = join(qualificationSpoolPaths(options.spool_dir).root, "panels", `${options.panel_id}.json`);
-    atomicWriteCanonical(path, result, true);
-    return result;
-}
-export function recordQualificationCell(options) {
-    qualificationDerivedId(options.cell_id, "cell_id");
-    const config = readQualificationSpoolConfig(options.spool_dir);
-    const declared = config.board?.cells.find((cell) => cell.id === options.cell_id);
-    if (!config.judge_panel || !declared)
-        throw new Error(`qualification cell ${options.cell_id} is not declared by the approved panel board`);
-    const panelIds = declared.panels.map((panel) => panel.id);
-    const panels = panelIds.map((id) => readAndValidatePanel(options.spool_dir, id));
-    if (new Set(panels.map((panel) => panel.repetition)).size !== panels.length)
-        throw new Error("qualification cell contains duplicate repetitions");
-    if (panels.some((panel) => panel.critical !== declared.critical))
-        throw new Error("qualification cell criticality does not match its approved board declaration");
-    const result = aggregateQualificationCell({
-        cell_id: options.cell_id,
-        scenario_id: declared.scenario_id,
-        subject_arm: declared.subject_arm,
-        critical: declared.critical,
-        pass_threshold: declared.pass_threshold,
-        panels,
-    });
-    atomicWriteCanonical(join(qualificationSpoolPaths(options.spool_dir).root, "cells", `${options.cell_id}.json`), result, true);
-    return result;
-}
-export function validateQualificationPanelOutputs(spoolDir) {
-    const root = qualificationSpoolPaths(spoolDir).root;
-    const config = readQualificationSpoolConfig(spoolDir);
-    const invocationIds = readdirSync(qualificationSpoolPaths(spoolDir).invocations, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    const invocations = invocationIds.map((id) => readQualificationInvocation(spoolDir, id));
-    const panelIds = jsonRecordIds(join(root, "panels"));
-    if (config.judge_panel) {
-        if (!config.board)
-            throw new Error("qualification panel configuration lacks its approved board");
-        const expectedPanels = config.board.cells.flatMap((cell) => cell.panels.map((panel) => panel.id)).sort();
-        if (qualificationCanonicalJson(panelIds) !== qualificationCanonicalJson(expectedPanels))
-            throw new Error("qualification panel outputs are incomplete or contain undeclared panels");
-        const expectedSubjectSlots = config.board.cells.flatMap((cell) => cell.panels.map((panel) => ({ cell, repetition: panel.repetition })));
-        const subjectInvocations = invocations.filter((invocation) => invocation.role === "subject");
-        if (subjectInvocations.length !== expectedSubjectSlots.length)
-            throw new Error("qualification approved board subject invocations are incomplete or contain extras");
-        for (const slot of expectedSubjectSlots) {
-            const matching = subjectInvocations.filter((invocation) => invocation.repetition === slot.repetition && invocation.scenario.id === slot.cell.scenario_id && invocation.arms.selected === slot.cell.subject_arm);
-            if (matching.length !== 1)
-                throw new Error("qualification approved board must have exactly one subject invocation per scenario/arm/repetition");
-            assertInvocationMatchesDeclaredCell(matching[0], slot.cell);
-        }
-    }
-    else if (panelIds.length > 0)
-        throw new Error("historical qualification spool contains undeclared panel outputs");
-    for (const id of panelIds)
-        readAndValidatePanel(spoolDir, id);
-    const cellIds = jsonRecordIds(join(root, "cells"));
-    if (config.judge_panel) {
-        const expectedCells = config.board.cells.map((cell) => cell.id).sort();
-        if (qualificationCanonicalJson(cellIds) !== qualificationCanonicalJson(expectedCells))
-            throw new Error("qualification cell outputs are incomplete or contain undeclared cells");
-    }
-    else if (cellIds.length > 0)
-        throw new Error("historical qualification spool contains undeclared cell outputs");
-    for (const id of cellIds) {
-        const path = join(root, "cells", `${id}.json`);
-        const recorded = readCanonicalJson(path, `qualification cell ${id}`);
-        const declared = config.board?.cells.find((cell) => cell.id === id);
-        if (!declared)
-            throw new Error(`qualification cell ${id} is not declared by the approved board`);
-        const panels = declared.panels.map((panel) => readAndValidatePanel(spoolDir, panel.id));
-        const rebuilt = aggregateQualificationCell({
-            cell_id: declared.id,
-            scenario_id: declared.scenario_id,
-            subject_arm: declared.subject_arm,
-            critical: declared.critical,
-            pass_threshold: declared.pass_threshold,
-            panels,
-        });
-        if (qualificationCanonicalJson(recorded) !== qualificationCanonicalJson(rebuilt))
-            throw new Error(`qualification cell ${id} does not match validated panel evidence`);
-    }
-    return { panels: panelIds.length, cells: cellIds.length };
-}
-function readAndValidatePanel(spoolDir, id) {
-    const path = join(qualificationSpoolPaths(spoolDir).root, "panels", `${id}.json`);
-    const recorded = readCanonicalJson(path, `qualification judge panel ${id}`);
-    const config = readQualificationSpoolConfig(spoolDir);
-    const declared = config.board?.cells.find((cell) => cell.panels.some((panel) => panel.id === id));
-    if (!declared)
-        throw new Error(`qualification judge panel ${id} is not declared by the approved board`);
-    const invocations = recorded.members.map((member) => readQualificationInvocation(spoolDir, member.invocation_id));
-    const first = invocations[0];
-    if (!first?.panel || first.panel.id !== id)
-        throw new Error(`qualification judge panel ${id} member binding mismatch`);
-    for (const [index, invocation] of invocations.entries()) {
-        if (!invocation.panel || invocation.panel.id !== id || invocation.panel.member_ordinal !== index + 1 ||
-            invocation.panel.subject_invocation_id !== first.panel.subject_invocation_id ||
-            invocation.panel.subject_artifact_sha256 !== first.panel.subject_artifact_sha256 ||
-            invocation.measurement_identity_sha256 !== first.measurement_identity_sha256 ||
-            invocation.scenario.id !== first.scenario.id || invocation.scenario.version !== first.scenario.version ||
-            invocation.scenario.stimulus_sha256 !== first.scenario.stimulus_sha256 || invocation.scenario.rubric_sha256 !== first.scenario.rubric_sha256 ||
-            invocation.repetition !== first.repetition || invocation.arms.subject !== first.arms.subject || invocation.arms.judge !== first.arms.judge) {
-            throw new Error(`qualification judge panel ${id} member binding mismatch`);
-        }
-    }
-    for (const invocation of invocations)
-        assertInvocationMatchesDeclaredCell(invocation, declared);
-    const members = recorded.members.map((member) => readQualificationJudgePanelMember(spoolDir, member.invocation_id));
-    const rebuilt = collapseQualificationJudgePanel({
-        panel_id: id,
-        scenario_id: declared.scenario_id,
-        subject_arm: declared.subject_arm,
-        repetition: declared.panels.find((panel) => panel.id === id).repetition,
-        critical: declared.critical,
-        members,
-    });
-    if (rebuilt.state === "unresolved" && rebuilt.disagreement.initial_split)
-        throw new Error(`qualification judge panel ${id} is incomplete: its clean split requires an authorized tie-break`);
-    if (qualificationCanonicalJson(recorded) !== qualificationCanonicalJson(rebuilt))
-        throw new Error(`qualification judge panel ${id} does not match validated invocation evidence`);
-    return recorded;
-}
-function assertInvocationMatchesDeclaredCell(invocation, cell) {
-    if (invocation.measurement_identity_sha256 !== cell.measurement_identity_sha256 || invocation.scenario.id !== cell.scenario_id ||
-        invocation.scenario.version !== cell.scenario_version || invocation.scenario.stimulus_sha256 !== cell.stimulus_sha256 ||
-        invocation.scenario.rubric_sha256 !== cell.rubric_sha256 || invocation.arms.subject !== cell.subject_arm ||
-        (invocation.role === "subject" && (invocation.scenario.input_sha256 !== cell.subject_input_sha256 || invocation.arms.selected !== cell.subject_arm)) ||
-        (invocation.role === "judge" && (!invocation.panel || cell.judge_arms[invocation.panel.member_ordinal - 1] !== invocation.arms.selected))) {
-        throw new Error(`qualification invocation ${invocation.invocation_id} does not match its approved board cell identity`);
-    }
-}
-function qualificationDerivedId(value, label) {
-    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value))
-        throw new Error(`qualification ${label} must be a bounded ASCII identifier`);
-}
-function jsonRecordIds(path) {
-    if (!existsSync(path))
-        return [];
-    const entries = readdirSync(path, { withFileTypes: true });
-    const invalid = entries.find((entry) => !entry.isFile() || !entry.name.endsWith(".json"));
-    if (invalid)
-        throw new Error(`qualification derived-output directory contains undeclared entry ${invalid.name}`);
-    return entries.map((entry) => entry.name.slice(0, -5)).sort();
-}
-//# sourceMappingURL=qualification-panel-store.js.map

package/dist/qualification-panels.d.ts

@@ -1,99 +0,0 @@
-import { type PanelVote } from "./vote-panel.js";
-export declare const QUALIFICATION_JUDGE_PANEL_POLICY_VERSION: "qualification-judge-panel-policy-v1";
-export declare const QUALIFICATION_JUDGE_PANEL_RESULT_VERSION: "qualification-judge-panel-result-v1";
-export declare const QUALIFICATION_CELL_RESULT_VERSION: "qualification-cell-result-v1";
-/** Closed policy persisted in qualification configuration. */
-export declare const QUALIFICATION_JUDGE_PANEL_POLICY: {
-    readonly schema_version: "qualification-judge-panel-policy-v1";
-    readonly initial_judge_calls: 2;
-    readonly agreement: "two-matching-clean-votes";
-    readonly split: "one-conditional-tie-break";
-    readonly max_judge_calls: 3;
-    readonly error: "record-as-non-vote";
-    readonly unresolved: "inconclusive-blocks-acceptance";
-    readonly behavioral_failure: "record-and-continue-read-only-board";
-    readonly integrity_failure: "halt";
-    readonly wave_a_call_budget: {
-        readonly artifacts: 54;
-        readonly minimum: 108;
-        readonly maximum: 162;
-    };
-    readonly complete_program_call_budget: {
-        readonly artifacts: 642;
-        readonly minimum: 1284;
-        readonly maximum: 1926;
-    };
-};
-export interface QualificationJudgePanelMember extends PanelVote {
-    invocation_id: string;
-    judge: {
-        provider: string;
-        model: string;
-    };
-    reason: string;
-    artifact: {
-        sha256: string;
-        bytes: number;
-    } | null;
-    terminal_receipt_sha256: string;
-}
-export interface QualificationJudgePanelResult {
-    schema_version: typeof QUALIFICATION_JUDGE_PANEL_RESULT_VERSION;
-    panel_id: string;
-    scenario_id: string;
-    subject_arm: string;
-    repetition: number;
-    critical: boolean;
-    state: "confirmed" | "tie_broken" | "unresolved";
-    verdict?: "PASS" | "FAIL";
-    members: QualificationJudgePanelMember[];
-    judge_calls: number;
-    clean_votes: number;
-    disagreement: {
-        initial_split: boolean;
-        minority_rate: number;
-    };
-    acceptance: "pass" | "fail" | "inconclusive";
-    collection: "continue" | "halt";
-}
-/**
- * Collapse members that have already passed the qualification invocation,
- * OAuth, accounting, receipt, and artifact boundary.
- */
-export declare function collapseQualificationJudgePanel(options: {
-    panel_id: string;
-    scenario_id: string;
-    subject_arm: string;
-    repetition: number;
-    critical: boolean;
-    members: QualificationJudgePanelMember[];
-}): QualificationJudgePanelResult;
-export interface QualificationCellResult {
-    schema_version: typeof QUALIFICATION_CELL_RESULT_VERSION;
-    cell_id: string;
-    scenario_id: string;
-    subject_arm: string;
-    critical: boolean;
-    pass_threshold: number;
-    panels: QualificationJudgePanelResult[];
-    verdict?: "PASS" | "FAIL";
-    critical_failure: boolean;
-    acceptance: "pass" | "fail" | "inconclusive";
-    collection: "continue" | "halt";
-    disagreement: {
-        judge_calls: number;
-        clean_votes: number;
-        split_artifacts: number;
-        artifacts_with_two_clean_initial_votes: number;
-        unresolved_artifacts: number;
-        judge_split_rate: number;
-    };
-}
-export declare function aggregateQualificationCell(options: {
-    cell_id: string;
-    scenario_id: string;
-    subject_arm: string;
-    critical: boolean;
-    pass_threshold: number;
-    panels: QualificationJudgePanelResult[];
-}): QualificationCellResult;

package/dist/qualification-panels.js

@@ -1,91 +0,0 @@
-import { collapseVotePanel } from "./vote-panel.js";
-export const QUALIFICATION_JUDGE_PANEL_POLICY_VERSION = "qualification-judge-panel-policy-v1";
-export const QUALIFICATION_JUDGE_PANEL_RESULT_VERSION = "qualification-judge-panel-result-v1";
-export const QUALIFICATION_CELL_RESULT_VERSION = "qualification-cell-result-v1";
-/** Closed policy persisted in qualification configuration. */
-export const QUALIFICATION_JUDGE_PANEL_POLICY = {
-    schema_version: QUALIFICATION_JUDGE_PANEL_POLICY_VERSION,
-    initial_judge_calls: 2,
-    agreement: "two-matching-clean-votes",
-    split: "one-conditional-tie-break",
-    max_judge_calls: 3,
-    error: "record-as-non-vote",
-    unresolved: "inconclusive-blocks-acceptance",
-    behavioral_failure: "record-and-continue-read-only-board",
-    integrity_failure: "halt",
-    wave_a_call_budget: { artifacts: 54, minimum: 108, maximum: 162 },
-    complete_program_call_budget: { artifacts: 642, minimum: 1284, maximum: 1926 },
-};
-/**
- * Collapse members that have already passed the qualification invocation,
- * OAuth, accounting, receipt, and artifact boundary.
- */
-export function collapseQualificationJudgePanel(options) {
-    const collapse = collapseVotePanel(options.members);
-    if (options.members.length < 2 || options.members.length > 3)
-        throw new Error("qualification judge panel must contain two or three members");
-    if (options.members.some((member, index) => member.ordinal !== index + 1))
-        throw new Error("qualification judge panel member ordinals must be contiguous from one");
-    if (options.members.length === 3 && !collapse.split)
-        throw new Error("qualification judge panel third member is permitted only after a clean initial split");
-    const acceptance = collapse.state === "unresolved" ? "inconclusive" : collapse.verdict === "PASS" ? "pass" : "fail";
-    return {
-        schema_version: QUALIFICATION_JUDGE_PANEL_RESULT_VERSION,
-        panel_id: options.panel_id,
-        scenario_id: options.scenario_id,
-        subject_arm: options.subject_arm,
-        repetition: options.repetition,
-        critical: options.critical,
-        state: collapse.state,
-        ...(collapse.verdict ? { verdict: collapse.verdict } : {}),
-        members: options.members,
-        judge_calls: options.members.length,
-        clean_votes: collapse.clean_votes,
-        disagreement: { initial_split: collapse.split, minority_rate: collapse.minority_rate },
-        acceptance,
-        collection: "continue",
-    };
-}
-export function aggregateQualificationCell(options) {
-    if (!Number.isSafeInteger(options.pass_threshold) || options.pass_threshold < 1)
-        throw new Error("qualification cell pass_threshold must be a positive integer");
-    if (options.panels.length === 0)
-        throw new Error("qualification cell requires at least one panel");
-    if (new Set(options.panels.map((panel) => panel.panel_id)).size !== options.panels.length || new Set(options.panels.map((panel) => panel.repetition)).size !== options.panels.length)
-        throw new Error("qualification cell contains duplicate panels or repetitions");
-    for (const panel of options.panels) {
-        if (panel.scenario_id !== options.scenario_id || panel.subject_arm !== options.subject_arm || panel.critical !== options.critical)
-            throw new Error("qualification cell panel identity or criticality mismatch");
-    }
-    const unresolved = options.panels.filter((panel) => panel.state === "unresolved").length;
-    const passes = options.panels.filter((panel) => panel.verdict === "PASS").length;
-    // Same safety rule as ordinary skill-harness repetitions: a declared threshold
-    // cannot weaken Critical semantics; every clean Critical repetition must pass.
-    const effectiveThreshold = options.critical ? options.panels.length : options.pass_threshold;
-    const verdict = unresolved > 0 ? undefined : passes >= effectiveThreshold ? "PASS" : "FAIL";
-    const denominator = options.panels.filter((panel) => panel.members.filter((member) => member.ordinal <= 2 && !member.suspect && (member.verdict === "PASS" || member.verdict === "FAIL")).length === 2).length;
-    const splitArtifacts = options.panels.filter((panel) => panel.disagreement.initial_split).length;
-    const acceptance = verdict === undefined ? "inconclusive" : verdict === "PASS" ? "pass" : "fail";
-    return {
-        schema_version: QUALIFICATION_CELL_RESULT_VERSION,
-        cell_id: options.cell_id,
-        scenario_id: options.scenario_id,
-        subject_arm: options.subject_arm,
-        critical: options.critical,
-        pass_threshold: effectiveThreshold,
-        panels: options.panels,
-        ...(verdict ? { verdict } : {}),
-        critical_failure: options.critical && verdict === "FAIL",
-        acceptance,
-        collection: "continue",
-        disagreement: {
-            judge_calls: options.panels.reduce((sum, panel) => sum + panel.judge_calls, 0),
-            clean_votes: options.panels.reduce((sum, panel) => sum + panel.clean_votes, 0),
-            split_artifacts: splitArtifacts,
-            artifacts_with_two_clean_initial_votes: denominator,
-            unresolved_artifacts: unresolved,
-            judge_split_rate: denominator === 0 ? 0 : splitArtifacts / denominator,
-        },
-    };
-}
-//# sourceMappingURL=qualification-panels.js.map

package/dist/qualification-process.d.ts

@@ -1,13 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-export interface QualificationProcessIdentity {
-    pid: number;
-    platform: NodeJS.Platform;
-    boot_id: string | null;
-    start_ticks: string | null;
-}
-export declare function qualificationProcessIdentity(pid: number): QualificationProcessIdentity;
-export declare function qualificationProcessMatches(identity: QualificationProcessIdentity): boolean;
-export declare function cleanupQualificationProcessGroupAfterLeaderExit(pid: number | undefined, original: QualificationProcessIdentity | null): Promise<void>;
-export declare function terminateQualificationProcess(child: ChildProcess, identity: QualificationProcessIdentity | null): void;
-export declare function terminateQualificationByIdentity(identity: QualificationProcessIdentity): void;
-export declare function terminateInterruptedQualificationProcessGroup(identity: QualificationProcessIdentity): Promise<void>;

package/dist/qualification-process.js

@@ -1,190 +0,0 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { setTimeout as sleep } from "node:timers/promises";
-export function qualificationProcessIdentity(pid) {
-    if (!Number.isInteger(pid) || pid < 1)
-        throw new Error(`qualification process ${String(pid)} is not live`);
-    if (process.platform === "linux") {
-        let stat;
-        try {
-            stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-        }
-        catch {
-            throw new Error(`qualification process ${pid} is not live`);
-        }
-        const close = stat.lastIndexOf(")");
-        if (close < 0)
-            throw new Error(`qualification process ${pid} identity is unreadable`);
-        const remainder = stat.slice(close + 2).trim().split(/\s+/);
-        const startTicks = remainder[19]; // field 22; remainder starts at field 3
-        if (!/^\d+$/.test(startTicks ?? ""))
-            throw new Error(`qualification process ${pid} start identity is unreadable`);
-        let bootId;
-        try {
-            bootId = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
-        }
-        catch {
-            throw new Error("qualification Linux boot identity is unreadable");
-        }
-        return { pid, platform: process.platform, boot_id: bootId, start_ticks: startTicks };
-    }
-    try {
-        process.kill(pid, 0);
-    }
-    catch {
-        throw new Error(`qualification process ${pid} is not live`);
-    }
-    return { pid, platform: process.platform, boot_id: null, start_ticks: null };
-}
-export function qualificationProcessMatches(identity) {
-    try {
-        const current = qualificationProcessIdentity(identity.pid);
-        return sameProcessIdentity(current, identity);
-    }
-    catch {
-        return false;
-    }
-}
-export async function cleanupQualificationProcessGroupAfterLeaderExit(pid, original) {
-    if (process.platform !== "linux" || !pid)
-        return;
-    const members = qualificationOwnedLinuxProcessGroupMembers(pid, original);
-    signalQualificationOccurrences(members, "SIGTERM");
-    if (members.length === 0)
-        return;
-    await sleep(75);
-    signalQualificationOccurrences(members, "SIGKILL");
-}
-export function terminateQualificationProcess(child, identity) {
-    if (identity && !qualificationProcessMatches(identity))
-        return;
-    if (process.platform === "linux" && child.pid) {
-        const members = qualificationOwnedLinuxProcessGroupMembers(child.pid, identity);
-        signalQualificationOccurrences(members, "SIGTERM");
-        setTimeout(() => signalQualificationOccurrences(members, "SIGKILL"), 75).unref();
-        return;
-    }
-    try {
-        child.kill("SIGTERM");
-    }
-    catch { /* process already exited */ }
-    setTimeout(() => {
-        if (identity && !qualificationProcessMatches(identity))
-            return;
-        try {
-            child.kill("SIGKILL");
-        }
-        catch { /* process already exited */ }
-    }, 75).unref();
-}
-export function terminateQualificationByIdentity(identity) {
-    if (!qualificationProcessMatches(identity))
-        throw new Error(`qualification process identity for pid ${identity.pid} is stale or reused`);
-    if (process.platform === "linux") {
-        const members = qualificationOwnedLinuxProcessGroupMembers(identity.pid, identity);
-        signalQualificationOccurrences(members, "SIGTERM");
-        setTimeout(() => signalQualificationOccurrences(members, "SIGKILL"), 75).unref();
-        return;
-    }
-    try {
-        process.kill(identity.pid, "SIGTERM");
-    }
-    catch { /* supervisor will reconcile the terminal state */ }
-    setTimeout(() => {
-        if (!qualificationProcessMatches(identity))
-            return;
-        try {
-            process.kill(identity.pid, "SIGKILL");
-        }
-        catch { /* process already exited */ }
-    }, 75).unref();
-}
-export async function terminateInterruptedQualificationProcessGroup(identity) {
-    if (qualificationProcessMatches(identity)) {
-        await terminateAndWaitByIdentity(identity);
-        return;
-    }
-    if (process.platform !== "linux")
-        return;
-    const survivingMembers = qualificationLinuxProcessGroupMembers(identity.pid);
-    // If the numeric group leader exists with a different occurrence, the PGID was
-    // reused and is not ours. A leaderless group cannot be recreated while its old
-    // descendants still hold that PGID, so only that leaderless case is safe to reap.
-    if (survivingMembers.some((member) => member.pid === identity.pid))
-        return;
-    signalQualificationOccurrences(survivingMembers, "SIGTERM");
-    await sleep(75);
-    signalQualificationOccurrences(survivingMembers, "SIGKILL");
-}
-async function terminateAndWaitByIdentity(identity) {
-    if (!qualificationProcessMatches(identity))
-        return;
-    if (process.platform === "linux") {
-        const members = qualificationOwnedLinuxProcessGroupMembers(identity.pid, identity);
-        signalQualificationOccurrences(members, "SIGTERM");
-        await sleep(75);
-        signalQualificationOccurrences(members, "SIGKILL");
-    }
-    else {
-        try {
-            process.kill(identity.pid, "SIGTERM");
-        }
-        catch {
-            return;
-        }
-        await sleep(75);
-        if (qualificationProcessMatches(identity)) {
-            try {
-                process.kill(identity.pid, "SIGKILL");
-            }
-            catch { /* process already exited */ }
-        }
-    }
-    const deadline = Date.now() + 2000;
-    while (qualificationProcessMatches(identity) && Date.now() < deadline)
-        await sleep(10);
-}
-function qualificationOwnedLinuxProcessGroupMembers(processGroupId, original) {
-    const members = qualificationLinuxProcessGroupMembers(processGroupId);
-    const currentLeader = members.find((member) => member.pid === processGroupId);
-    if (currentLeader && (!original || !sameProcessIdentity(currentLeader, original)))
-        return [];
-    return members;
-}
-function qualificationLinuxProcessGroupMembers(processGroupId) {
-    if (process.platform !== "linux")
-        return [];
-    const members = [];
-    // Dirent construction may lstat an unrelated disappearing PID before our
-    // per-entry guard runs. Names need no metadata; validate each stat below.
-    for (const name of readdirSync("/proc")) {
-        if (!/^\d+$/.test(name))
-            continue;
-        const pid = Number(name);
-        try {
-            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-            const close = stat.lastIndexOf(")");
-            if (close < 0)
-                continue;
-            const fields = stat.slice(close + 2).trim().split(/\s+/);
-            if (Number(fields[2]) !== processGroupId)
-                continue; // field 5 (pgrp); fields start at field 3
-            members.push(qualificationProcessIdentity(pid));
-        }
-        catch { /* process exited during the scan */ }
-    }
-    return members;
-}
-function signalQualificationOccurrences(identities, signal) {
-    for (const identity of identities) {
-        if (!qualificationProcessMatches(identity))
-            continue;
-        try {
-            process.kill(identity.pid, signal);
-        }
-        catch { /* process exited after occurrence validation */ }
-    }
-}
-function sameProcessIdentity(left, right) {
-    return left.pid === right.pid && left.platform === right.platform && left.boot_id === right.boot_id && left.start_ticks === right.start_ticks;
-}
-//# sourceMappingURL=qualification-process.js.map