@skill-harness/core 0.17.0 → 0.18.0

package/dist/investigation.d.ts

@@ -1,94 +0,0 @@
-/** Bounded operator envelope; duplicate keys and over-expanded/cyclic objects are refused before dispatch. */
-export declare function parseLearningRequest(text: string): unknown;
-export interface HypothesisProposal {
-    archiveSnapshot: string;
-    caseIds: string[];
-    population: string;
-    intervention: string;
-    alternatives: string[];
-    prediction: string;
-    downside: string;
-    disproof: string;
-    rollback: string;
-    limits: {
-        subjectCalls: number;
-        judgeCalls: number;
-        wallMs: number;
-    };
-    effectProfile: string | null;
-}
-export interface Hypothesis {
-    version: "factory-hypothesis-v1";
-    id: string;
-    proposal: HypothesisProposal;
-    status: "proposed";
-}
-export declare function buildHypothesis(input: HypothesisProposal): Hypothesis;
-export interface InvestigationAuthority {
-    id: string;
-    investigations: readonly string[];
-    promotions: readonly string[];
-}
-/** Independent host declarations, not approval fields on a proposal and never adoption/activation authority. */
-export declare function authorizeInvestigation(h: Hypothesis, authority: InvestigationAuthority | null): {
-    version: string;
-    hypothesisId: string;
-    authorityId: string;
-    scope: "investigation-only";
-};
-export interface InvestigationScenarioPreview {
-    version: "investigation-scenario-preview-v1";
-    hypothesisId: string;
-    specPath: string;
-    baseSha256: string;
-    afterSha256: string;
-    scenario: Record<string, unknown>;
-    block: string;
-    digest: string;
-}
-export declare function previewInvestigationScenario(h: Hypothesis, specPath: string, scenario: Record<string, unknown>): InvestigationScenarioPreview;
-/** Exact preview consent includes destination, existing spec and complete scenario bytes. No automatic sanitization claim. */
-export declare function applyInvestigationScenario(h: Hypothesis, preview: InvestigationScenarioPreview, authority: InvestigationAuthority | null): {
-    scenarioId: string;
-    replayed: boolean;
-    sha256: string;
-    scope: "scenario-only";
-};
-export interface FrozenInvestigationInputs {
-    specSha256: string;
-    rubricSha256: string;
-    judgePolicySha256: string;
-    heldoutSha256: string;
-    configurationSha256: string;
-}
-export declare function freezeInvestigation(h: Hypothesis, inputs: FrozenInvestigationInputs, authority: InvestigationAuthority | null): {
-    digest: string;
-    version: string;
-    hypothesisId: string;
-    authorityId: string;
-    inputs: FrozenInvestigationInputs;
-    executionReady: false;
-};
-export declare function assertFrozenInvestigation(frozen: ReturnType<typeof freezeInvestigation>, current: FrozenInvestigationInputs): void;
-export interface WeeklyInvestigationInput {
-    week: string;
-    population: string;
-    policyDigest: string;
-    archiveSnapshot: string;
-    eligibleCaseIds: string[];
-    maxCases: number;
-}
-export interface WeeklyInvestigationSelection {
-    version: "weekly-investigation-selection-v1";
-    id: string;
-    key: string;
-    inputDigest: string;
-    week: string;
-    population: string;
-    policyDigest: string;
-    archiveSnapshot: string;
-    selectedCaseIds: string[];
-    sampling: "exploratory-sha256-order-v1";
-}
-/** The host persists these immutable selections; this function neither schedules a process nor spends tokens. */
-export declare function selectWeeklyInvestigation(history: readonly WeeklyInvestigationSelection[], input: WeeklyInvestigationInput): WeeklyInvestigationSelection;

package/dist/investigation.js

@@ -1,148 +0,0 @@
-import { createHash } from "node:crypto";
-import yaml from "js-yaml";
-import { readFileSync, realpathSync } from "node:fs";
-import { appendScenario, renderScenarioBlock, specSha256 } from "./spec-write.js";
-import { parseSpec } from "./spec.js";
-const SHA = /^[a-f0-9]{64}$/;
-const keys = (x, expected) => Object.keys(x).sort().join() === [...expected].sort().join();
-const text = (x, max = 4000) => typeof x === "string" && x.length > 0 && x.length <= max;
-function json(input) {
-    let nodes = 0;
-    const visit = (x, depth) => {
-        if (++nodes > 4096 || depth > 16)
-            throw new Error("investigation JSON exceeds bounds");
-        if (x === null || typeof x === "boolean" || typeof x === "string" || (typeof x === "number" && Number.isFinite(x)))
-            return x;
-        if (!x || typeof x !== "object" || (!Array.isArray(x) && ![Object.prototype, null].includes(Object.getPrototypeOf(x))))
-            throw new Error("plain investigation JSON required");
-        const descriptors = Object.getOwnPropertyDescriptors(x);
-        if (Array.isArray(x)) {
-            if (Object.getPrototypeOf(x) !== Array.prototype || x.length > 256 || Reflect.ownKeys(x).length !== x.length + 1)
-                throw new Error("bounded dense JSON array required");
-            return Array.from({ length: x.length }, (_, i) => { const d = descriptors[String(i)]; if (!d || !('value' in d))
-                throw new Error("plain JSON array required"); return visit(d.value, depth + 1); });
-        }
-        const out = {};
-        for (const key of Reflect.ownKeys(descriptors).sort((a, b) => String(a) < String(b) ? -1 : 1)) {
-            const d = descriptors[key];
-            if (typeof key !== "string" || !d.enumerable || !('value' in d))
-                throw new Error("plain JSON properties required");
-            Object.defineProperty(out, key, { value: visit(d.value, depth + 1), enumerable: true });
-        }
-        return out;
-    };
-    const result = visit(input, 0);
-    if (Buffer.byteLength(JSON.stringify(result)) > 65536)
-        throw new Error("investigation JSON exceeds byte bound");
-    return result;
-}
-/** Bounded operator envelope; duplicate keys and over-expanded/cyclic objects are refused before dispatch. */
-export function parseLearningRequest(text) {
-    if (typeof text !== "string" || Buffer.byteLength(text) > 65536)
-        throw new Error("learning request exceeds bound");
-    let value;
-    try {
-        value = yaml.load(text, { schema: yaml.JSON_SCHEMA, json: false });
-    }
-    catch {
-        throw new Error("invalid learning request");
-    }
-    return json(value);
-}
-const digest = (x) => createHash("sha256").update(JSON.stringify(json(x))).digest("hex");
-function freeze(value) { if (value && typeof value === "object") {
-    Object.values(value).forEach(freeze);
-    Object.freeze(value);
-} return value; }
-export function buildHypothesis(input) {
-    const p = json(input);
-    if (!keys(p, ["archiveSnapshot", "caseIds", "population", "intervention", "alternatives", "prediction", "downside", "disproof", "rollback", "limits", "effectProfile"])
-        || !SHA.test(p.archiveSnapshot) || !Array.isArray(p.caseIds) || !p.caseIds.length || p.caseIds.some(id => typeof id !== "string" || !SHA.test(id))
-        || ![p.population, p.intervention, p.prediction, p.downside, p.disproof, p.rollback].every(s => text(s))
-        || !Array.isArray(p.alternatives) || !p.alternatives.length || p.alternatives.some(a => !text(a))
-        || !p.limits || !keys(p.limits, ["subjectCalls", "judgeCalls", "wallMs"])
-        || !Object.values(p.limits).every(n => Number.isSafeInteger(n) && n >= 0 && n <= 1000000000)
-        || !(p.effectProfile === null || text(p.effectProfile, 512)))
-        throw new Error("invalid bounded hypothesis");
-    return freeze({ version: "factory-hypothesis-v1", id: digest({ version: "factory-hypothesis-v1", proposal: p }), proposal: p, status: "proposed" });
-}
-function authorize(h, authority) {
-    const value = json(h);
-    if (!keys(value, ["version", "id", "proposal", "status"]) || value.version !== "factory-hypothesis-v1" || value.status !== "proposed" || buildHypothesis(value.proposal).id !== value.id)
-        throw new Error("hypothesis identity changed");
-    if (!authority || !text(authority.id, 512) || !Array.isArray(authority.investigations) || !Array.isArray(authority.promotions)
-        || authority.investigations.length > 256 || authority.promotions.length > 256
-        || [...authority.investigations, ...authority.promotions].some(id => typeof id !== "string" || !SHA.test(id))
-        || !authority.investigations.includes(value.id))
-        throw new Error("independent investigation authority required");
-    return authority;
-}
-/** Independent host declarations, not approval fields on a proposal and never adoption/activation authority. */
-export function authorizeInvestigation(h, authority) {
-    const selected = authorize(h, authority);
-    return freeze({ version: "investigation-approval-v1", hypothesisId: h.id, authorityId: selected.id, scope: "investigation-only" });
-}
-export function previewInvestigationScenario(h, specPath, scenario) {
-    if (buildHypothesis(h.proposal).id !== h.id)
-        throw new Error("hypothesis identity changed");
-    const path = realpathSync(specPath), current = readFileSync(path, "utf8"), safe = json(scenario), block = renderScenarioBlock(safe);
-    parseSpec(current + block, path);
-    const value = { version: "investigation-scenario-preview-v1", hypothesisId: h.id, specPath: path, baseSha256: specSha256(current), afterSha256: specSha256(current + block), scenario: safe, block };
-    return freeze({ ...value, digest: digest(value) });
-}
-/** Exact preview consent includes destination, existing spec and complete scenario bytes. No automatic sanitization claim. */
-export function applyInvestigationScenario(h, preview, authority) {
-    const selected = authorize(h, authority), copy = json(preview), { digest: claimed, ...body } = copy;
-    if (!keys(copy, ["version", "hypothesisId", "specPath", "baseSha256", "afterSha256", "scenario", "block", "digest"])
-        || body.version !== "investigation-scenario-preview-v1" || body.hypothesisId !== h.id || digest(body) !== claimed
-        || renderScenarioBlock(body.scenario) !== body.block || !selected.promotions.includes(claimed))
-        throw new Error("exact privacy/promotion preview authority required");
-    if (realpathSync(body.specPath) !== body.specPath)
-        throw new Error("promotion destination changed");
-    const current = readFileSync(body.specPath, "utf8");
-    if (specSha256(current) === body.afterSha256)
-        return { scenarioId: String(body.scenario.id), replayed: true, sha256: body.afterSha256, scope: "scenario-only" };
-    const result = appendScenario({ specPath: body.specPath, scenario: body.scenario, baseSha256: body.baseSha256 });
-    return { scenarioId: result.id, replayed: false, sha256: result.sha256, scope: "scenario-only" };
-}
-function frozenInputs(input) {
-    const value = json(input);
-    if (!keys(value, ["specSha256", "rubricSha256", "judgePolicySha256", "heldoutSha256", "configurationSha256"]) || Object.values(value).some(v => typeof v !== "string" || !SHA.test(v)))
-        throw new Error("invalid frozen evaluation inputs");
-    return value;
-}
-export function freezeInvestigation(h, inputs, authority) {
-    const approved = authorizeInvestigation(h, authority), value = { version: "frozen-investigation-v1", hypothesisId: h.id, authorityId: approved.authorityId, inputs: frozenInputs(inputs), executionReady: false };
-    return freeze({ ...value, digest: digest(value) });
-}
-export function assertFrozenInvestigation(frozen, current) {
-    const { digest: recorded, ...value } = json(frozen);
-    if (!keys(value, ["version", "hypothesisId", "authorityId", "inputs", "executionReady"]) || !SHA.test(value.hypothesisId) || !text(value.authorityId, 512)
-        || value.version !== "frozen-investigation-v1" || value.executionReady !== false || digest(value) !== recorded || digest(value.inputs) !== digest(frozenInputs(current)))
-        throw new Error("frozen investigation changed or invalid");
-}
-/** The host persists these immutable selections; this function neither schedules a process nor spends tokens. */
-export function selectWeeklyInvestigation(history, input) {
-    const value = json(input);
-    if (!keys(value, ["week", "population", "policyDigest", "archiveSnapshot", "eligibleCaseIds", "maxCases"])
-        || !/^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/.test(value.week) || !text(value.population, 512)
-        || !SHA.test(value.policyDigest) || !SHA.test(value.archiveSnapshot) || !Array.isArray(value.eligibleCaseIds)
-        || !value.eligibleCaseIds.length || value.eligibleCaseIds.some(id => typeof id !== "string" || !SHA.test(id))
-        || !Number.isSafeInteger(value.maxCases) || value.maxCases < 1 || value.maxCases > 32 || history.length > 4096)
-        throw new Error("invalid weekly investigation selection");
-    const eligible = [...new Set(value.eligibleCaseIds)].sort();
-    const key = digest({ week: value.week, population: value.population, policyDigest: value.policyDigest });
-    const inputDigest = digest({ ...value, eligibleCaseIds: eligible });
-    const selectedCaseIds = eligible.sort((a, b) => { const ka = digest([key, value.archiveSnapshot, a]), kb = digest([key, value.archiveSnapshot, b]); return ka < kb ? -1 : ka > kb ? 1 : 0; }).slice(0, value.maxCases);
-    const body = { version: "weekly-investigation-selection-v1", key, inputDigest, week: value.week, population: value.population,
-        policyDigest: value.policyDigest, archiveSnapshot: value.archiveSnapshot, selectedCaseIds, sampling: "exploratory-sha256-order-v1" };
-    const result = freeze({ ...body, id: digest(body) });
-    const previous = history.filter(record => record.key === key);
-    for (const record of previous) {
-        const { id, ...old } = json(record);
-        if (digest(old) !== id || id !== result.id)
-            throw new Error("weekly investigation already frozen or history invalid");
-    }
-    return previous.length ? freeze(json(previous[0])) : result;
-}
-//# sourceMappingURL=investigation.js.map

package/dist/judge-agreement.d.ts

@@ -1,19 +0,0 @@
-import type { ResultsFile } from "./results.js";
-import type { Verdict } from "./score.js";
-export interface JudgeAgreementCell {
-    scenario: string;
-    status: "agree" | "disagree" | "error";
-    judges: string[];
-    verdicts: Verdict[];
-    detail: string;
-}
-export interface JudgeAgreementReport {
-    cells: JudgeAgreementCell[];
-    agree: number;
-    disagree: number;
-    error: number;
-    comparable: number;
-    rate: number | null;
-}
-/** Pure/offline projection of judgments already persisted in results.yaml. */
-export declare function judgeAgreement(results: ResultsFile): JudgeAgreementReport;

package/dist/judge-agreement.js

@@ -1,31 +0,0 @@
-/** Pure/offline projection of judgments already persisted in results.yaml. */
-export function judgeAgreement(results) {
-    const cells = results.scenarios.map((scenario) => {
-        const judgments = scenario.judge_history ?? scenario.adjudication?.judgments ?? [];
-        const distinct = new Map();
-        for (const judgment of judgments) {
-            const key = `${judgment.judge.provider}:${judgment.judge.model}`;
-            distinct.delete(key); // insertion order now reflects each judge's latest persisted vote
-            distinct.set(key, judgment);
-        }
-        const pair = [...distinct.entries()].slice(-2);
-        if (pair.length < 2 || pair.some(([, judgment]) => judgment.suspect || judgment.verdict === "ERROR" || judgment.verdict === "NOT-MEASURED" || judgment.verdict === "JUDGE-AMBIGUOUS")) {
-            return {
-                scenario: scenario.id, status: "error", judges: pair.map(([judge]) => judge),
-                verdicts: pair.map(([, judgment]) => judgment.verdict),
-                detail: pair.length < 2 ? "fewer than two distinct persisted judges" : "one or more judgments is not a clean vote",
-            };
-        }
-        const status = pair[0][1].verdict === pair[1][1].verdict ? "agree" : "disagree";
-        return {
-            scenario: scenario.id, status, judges: pair.map(([judge]) => judge),
-            verdicts: pair.map(([, judgment]) => judgment.verdict), detail: `${pair[0][1].verdict} vs ${pair[1][1].verdict}`,
-        };
-    });
-    const agree = cells.filter((cell) => cell.status === "agree").length;
-    const disagree = cells.filter((cell) => cell.status === "disagree").length;
-    const error = cells.filter((cell) => cell.status === "error").length;
-    const comparable = agree + disagree;
-    return { cells, agree, disagree, error, comparable, rate: comparable ? agree / comparable : null };
-}
-//# sourceMappingURL=judge-agreement.js.map

package/dist/qualification-capture.d.ts

@@ -1,44 +0,0 @@
-export interface QualificationOutputReceipt {
-    path: string;
-    total_bytes: number;
-    captured_bytes: number;
-    truncated: boolean;
-    sha256: string;
-}
-export interface QualificationBoundedCapture {
-    path: string;
-    total_bytes: number;
-    captured_bytes: number;
-    truncated: boolean;
-    write(chunk: Buffer): void;
-    close(): void;
-}
-export interface QualificationArtifactAttestation {
-    ok: boolean;
-    actual: {
-        provider: string;
-        model: string;
-    } | null;
-    fallback: boolean;
-    refused: boolean;
-    error: string | null;
-}
-export declare function redactQualificationOutput(text: string, secretValues?: readonly string[]): string;
-export declare function openQualificationBoundedCapture(path: string, limit: number, redact: (text: string) => string): QualificationBoundedCapture;
-export declare function qualificationOutputReceipt(spoolRoot: string, path: string, capture: QualificationBoundedCapture): QualificationOutputReceipt;
-export declare function verifyQualificationOutputReceipt(spoolRoot: string, receipt: QualificationOutputReceipt): void;
-export declare function attestQualificationPiJsonl(text: string, requested: {
-    provider: string;
-    model: string;
-}): QualificationArtifactAttestation;
-export declare function spawnQualificationCapture(command: string, argv: string[], options: {
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    timeout_ms: number;
-    output_limit_bytes: number;
-}): Promise<{
-    stdout: string;
-    stderr: string;
-    code: number | null;
-    timed_out: boolean;
-}>;

package/dist/qualification-capture.js

@@ -1,163 +0,0 @@
-import { spawn } from "node:child_process";
-import { closeSync, constants, fstatSync, fsyncSync, openSync, readFileSync, writeSync } from "node:fs";
-import { join } from "node:path";
-import { StringDecoder } from "node:string_decoder";
-import { redactText } from "./capture.js";
-import { qualificationSha256 } from "./qualification-config.js";
-export function redactQualificationOutput(text, secretValues = []) {
-    let output = text;
-    for (const secret of [...new Set(secretValues)].sort((left, right) => right.length - left.length)) {
-        if (secret.length >= 8)
-            output = output.split(secret).join("[REDACTED credential]");
-    }
-    output = output
-        .replace(/\b([A-Z][A-Z0-9_]*(?:API_KEY|ACCESS_KEY|SECRET_KEY|AUTH_TOKEN|BEARER_TOKEN|SESSION_TOKEN))\s*[:=]\s*[^\s,;"']+/gi, "$1=[REDACTED credential]")
-        .replace(/\bBearer\s+[A-Za-z0-9._~+\/-]{8,}/gi, "Bearer [REDACTED credential]")
-        .replace(/\b(?:sk|sess|key|token)-[A-Za-z0-9._-]{8,}/gi, "[REDACTED credential]")
-        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, "[REDACTED credential]");
-    return redactText(output);
-}
-export function openQualificationBoundedCapture(path, limit, redact) {
-    const fd = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
-    const decoder = new StringDecoder("utf8");
-    let pending = "";
-    let acceptedRawBytes = 0;
-    let closed = false;
-    const persist = (text) => {
-        if (!text)
-            return;
-        const sanitized = Buffer.from(redact(text), "utf8");
-        const remaining = Math.max(0, limit - state.captured_bytes);
-        const part = sanitized.subarray(0, remaining);
-        if (part.length > 0) {
-            writeSync(fd, part);
-            state.captured_bytes += part.length;
-            fsyncSync(fd);
-        }
-        if (sanitized.length > remaining)
-            state.truncated = true;
-    };
-    const flushLines = () => {
-        let newline = pending.indexOf("\n");
-        while (newline >= 0) {
-            persist(pending.slice(0, newline + 1));
-            pending = pending.slice(newline + 1);
-            newline = pending.indexOf("\n");
-        }
-    };
-    const state = {
-        path, total_bytes: 0, captured_bytes: 0, truncated: false,
-        write(chunk) {
-            state.total_bytes += chunk.length;
-            const remainingRaw = Math.max(0, limit - acceptedRawBytes);
-            const accepted = chunk.subarray(0, remainingRaw);
-            acceptedRawBytes += accepted.length;
-            if (accepted.length > 0) {
-                pending += decoder.write(accepted);
-                flushLines();
-            }
-            if (chunk.length > remainingRaw)
-                state.truncated = true;
-        },
-        close() {
-            if (closed)
-                return;
-            pending += decoder.end();
-            // If the raw limit split a line, discard that incomplete tail rather than
-            // persisting a credential prefix that cannot be matched as a whole value.
-            if (!state.truncated)
-                persist(pending);
-            pending = "";
-            fsyncSync(fd);
-            closeSync(fd);
-            closed = true;
-        },
-    };
-    return state;
-}
-export function qualificationOutputReceipt(spoolRoot, path, capture) {
-    const bytes = readFileSync(path);
-    return {
-        path: path.slice(spoolRoot.length + 1),
-        total_bytes: capture.total_bytes,
-        captured_bytes: bytes.length,
-        truncated: capture.truncated,
-        sha256: qualificationSha256(bytes),
-    };
-}
-export function verifyQualificationOutputReceipt(spoolRoot, receipt) {
-    const path = join(spoolRoot, receipt.path);
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-        const stat = fstatSync(fd);
-        if (!stat.isFile())
-            throw new Error(`qualification output ${receipt.path} must be a regular non-symlink file`);
-        const bytes = readFileSync(fd);
-        if (bytes.length !== receipt.captured_bytes || qualificationSha256(bytes) !== receipt.sha256) {
-            throw new Error(`qualification output ${receipt.path} digest/size mismatch`);
-        }
-    }
-    finally {
-        if (fd !== undefined)
-            closeSync(fd);
-    }
-}
-export function attestQualificationPiJsonl(text, requested) {
-    const records = [];
-    try {
-        for (const line of text.split("\n")) {
-            if (!line.trim())
-                continue;
-            const value = JSON.parse(line);
-            if (!plainObject(value))
-                throw new Error("event is not an object");
-            records.push(value);
-        }
-    }
-    catch {
-        return { ok: false, actual: null, fallback: false, refused: false, error: "artifact is not valid JSONL" };
-    }
-    const fallback = records.some((record) => record.type === "provider_fallback" || record.type === "model_fallback" || Object.hasOwn(record, "fallback_provider") || Object.hasOwn(record, "fallback_model"));
-    const messages = records
-        .filter((record) => record.type === "message_end" && plainObject(record.message) && record.message.role === "assistant")
-        .map((record) => record.message);
-    if (messages.length === 0)
-        return { ok: false, actual: null, fallback, refused: false, error: "artifact has no authoritative assistant provider/model identity" };
-    const identities = messages.map((message) => ({ provider: stringValue(message.provider), model: stringValue(message.model) }));
-    if (identities.some((identity) => !identity.provider || !identity.model))
-        return { ok: false, actual: null, fallback, refused: false, error: "artifact assistant identity is missing provider or model" };
-    const actual = { provider: identities.at(-1).provider, model: identities.at(-1).model };
-    if (fallback)
-        return { ok: false, actual, fallback: true, refused: false, error: "artifact reports provider/model fallback" };
-    if (identities.some((identity) => identity.provider !== requested.provider))
-        return { ok: false, actual, fallback: false, refused: false, error: `provider substitution: requested ${requested.provider}, observed ${actual.provider}` };
-    if (identities.some((identity) => identity.model !== requested.model))
-        return { ok: false, actual, fallback: false, refused: false, error: `model substitution: requested ${requested.model}, observed ${actual.model}` };
-    const terminal = messages.at(-1);
-    const errorMessage = stringValue(terminal.errorMessage) ?? "";
-    const refused = terminal.stopReason === "error" && /(?:refus|not supported|not available|subscription|usage limit|unauthor)/i.test(errorMessage);
-    if (terminal.stopReason === "error" && !refused)
-        return { ok: false, actual, fallback: false, refused: false, error: errorMessage || "assistant ended with an error" };
-    return { ok: true, actual, fallback: false, refused, error: refused ? errorMessage : null };
-}
-export async function spawnQualificationCapture(command, argv, options) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, argv, { cwd: options.cwd, env: options.env, stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = Buffer.alloc(0), stderr = Buffer.alloc(0), timedOut = false;
-        const append = (current, chunk) => Buffer.concat([current, chunk]).subarray(0, options.output_limit_bytes);
-        child.stdout.on("data", (chunk) => { stdout = append(stdout, chunk); });
-        child.stderr.on("data", (chunk) => { stderr = append(stderr, chunk); });
-        const timer = setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, options.timeout_ms);
-        child.once("error", (error) => { clearTimeout(timer); reject(error); });
-        child.once("close", (code) => { clearTimeout(timer); resolve({ stdout: stdout.toString("utf8"), stderr: stderr.toString("utf8"), code, timed_out: timedOut }); });
-    });
-}
-function plainObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function stringValue(value) { return typeof value === "string" ? value : undefined; }
-//# sourceMappingURL=qualification-capture.js.map