hadara 0.1.0-rc.0

package/dist/providers/fallback-executor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderFallbackError = void 0;
+exports.chatWithProviderFallback = chatWithProviderFallback;
+class ProviderFallbackError extends Error {
+    attempts;
+    constructor(attempts) {
+        super('All provider fallback attempts failed.');
+        this.name = 'ProviderFallbackError';
+        this.attempts = attempts;
+    }
+}
+exports.ProviderFallbackError = ProviderFallbackError;
+async function chatWithProviderFallback(providers, request) {
+    if (providers.length === 0) {
+        throw new ProviderFallbackError([]);
+    }
+    const attempts = [];
+    for (const provider of providers) {
+        try {
+            const response = await provider.chat(request);
+            attempts.push({
+                provider: provider.id,
+                ok: true,
+                model: response.model
+            });
+            return { response, attempts };
+        }
+        catch (error) {
+            attempts.push({
+                provider: provider.id,
+                ok: false,
+                error: normalizeProviderFailure(provider, error)
+            });
+        }
+    }
+    throw new ProviderFallbackError(attempts);
+}
+function normalizeProviderFailure(provider, error) {
+    if (isProviderError(error))
+        return error;
+    return provider.normalizeError(error);
+}
+function isProviderError(error) {
+    return Boolean(error && typeof error === 'object' && 'provider' in error && 'code' in error && 'retriable' in error);
+}

package/dist/providers/mock-provider.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockProvider = void 0;
+class MockProvider {
+    id = 'mock';
+    displayName = 'MockProvider';
+    capabilities = {
+        supportsStreaming: true,
+        supportsToolCalling: false,
+        supportsReasoning: false,
+        supportsVision: false,
+        maxContextTokens: 8192,
+        localOnly: true,
+        costProfile: 'free'
+    };
+    async chat(request) {
+        const last = request.messages.at(-1)?.content ?? '';
+        return {
+            provider: this.id,
+            model: request.model ?? 'mock-model',
+            content: `Mock response for: ${last}`,
+            finishReason: 'stop',
+            usage: {
+                inputTokens: (await this.countTokens(JSON.stringify(request.messages))).tokens,
+                outputTokens: 8
+            }
+        };
+    }
+    async *stream(request) {
+        yield { type: 'start', provider: this.id, model: request.model ?? 'mock-model' };
+        const response = await this.chat(request);
+        for (const token of response.content.split(' ')) {
+            yield { type: 'delta', text: `${token} ` };
+        }
+        yield { type: 'finish', finishReason: response.finishReason };
+    }
+    async countTokens(input) {
+        return { tokens: Math.ceil(input.length / 4), approximate: true };
+    }
+    normalizeError(error) {
+        return {
+            provider: this.id,
+            code: 'MOCK_PROVIDER_ERROR',
+            message: error instanceof Error ? error.message : String(error),
+            retriable: false
+        };
+    }
+}
+exports.MockProvider = MockProvider;

package/dist/providers/provider-contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/providers/provider-preparation.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderCallReportError = exports.ProviderConfigError = void 0;
+exports.createProviderConfig = createProviderConfig;
+exports.normalizeProviderConfig = normalizeProviderConfig;
+exports.createProviderCallReport = createProviderCallReport;
+exports.assertProviderConfigSchema = assertProviderConfigSchema;
+exports.assertProviderCallSchema = assertProviderCallSchema;
+const redaction_1 = require("../core/redaction");
+const schema_1 = require("../core/schema");
+class ProviderConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProviderConfigError';
+    }
+}
+exports.ProviderConfigError = ProviderConfigError;
+class ProviderCallReportError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProviderCallReportError';
+    }
+}
+exports.ProviderCallReportError = ProviderCallReportError;
+const SECRET_VALUE_KEYS = new Set(['apiKey', 'apiKeyValue', 'token', 'secret', 'password', 'authorization']);
+const PROVIDER_CONFIG_INPUT_KEYS = new Set(['providers', 'defaultProvider']);
+const PROVIDER_ADAPTER_CONFIG_INPUT_KEYS = new Set([
+    'id',
+    'kind',
+    'enabled',
+    'baseUrlEnv',
+    'apiKeyEnv',
+    'model',
+    'capabilities',
+    'localOnly',
+    'costProfile'
+]);
+const PROVIDER_CAPABILITY_INPUT_KEYS = new Set(['supportsStreaming', 'supportsToolCalling', 'supportsReasoning', 'supportsVision']);
+const PROVIDER_KIND_VALUES = new Set(['openai-compatible', 'ollama', 'llama-cpp']);
+const COST_PROFILE_VALUES = new Set(['free', 'low', 'medium', 'high', 'unknown']);
+const PROVIDER_ID_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+const ENV_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+function createProviderConfig(input) {
+    rejectUnknownFields(input, PROVIDER_CONFIG_INPUT_KEYS, 'provider config');
+    if (!Array.isArray(input.providers)) {
+        throw new ProviderConfigError('provider config providers must be an array.');
+    }
+    const providers = input.providers.map(normalizeProviderConfig);
+    const defaultProvider = input.defaultProvider ?? null;
+    if (defaultProvider && !providers.some((provider) => provider.id === defaultProvider)) {
+        throw new ProviderConfigError(`Default provider "${defaultProvider}" is not configured.`);
+    }
+    const config = {
+        schemaVersion: 'hadara.provider.config.v1',
+        providers,
+        defaultProvider
+    };
+    return assertProviderConfigSchema(config);
+}
+function normalizeProviderConfig(input) {
+    rejectUnknownFields(input, PROVIDER_ADAPTER_CONFIG_INPUT_KEYS, 'provider adapter config');
+    rejectSecretValueFields(input);
+    const id = normalizeProviderId(input.id, 'provider id', ProviderConfigError);
+    const kind = normalizeProviderKind(input.kind);
+    const model = requireNonEmptyString(input.model, 'provider model', ProviderConfigError);
+    const capabilities = normalizeCapabilities(input.capabilities);
+    const config = {
+        id,
+        kind,
+        enabled: optionalBoolean(input.enabled, 'enabled') ?? false,
+        model,
+        capabilities,
+        localOnly: optionalBoolean(input.localOnly, 'localOnly') ?? kind !== 'openai-compatible',
+        costProfile: normalizeCostProfile(input.costProfile)
+    };
+    if (input.baseUrlEnv)
+        config.baseUrlEnv = normalizeEnvName(input.baseUrlEnv, 'baseUrlEnv');
+    if (input.apiKeyEnv)
+        config.apiKeyEnv = normalizeEnvName(input.apiKeyEnv, 'apiKeyEnv');
+    return config;
+}
+function createProviderCallReport(input) {
+    const provider = normalizeProviderId(input.provider, 'provider', ProviderCallReportError);
+    const model = input.model ?? input.response?.model;
+    const issues = input.error ? [normalizeProviderCallIssue(input.error)] : [];
+    const report = {
+        schemaVersion: 'hadara.provider.call.v1',
+        provider,
+        ...(model ? { model } : {}),
+        ok: issues.length === 0,
+        input: {
+            messages: input.request.messages.length,
+            approxTokens: approximateTokens(JSON.stringify(input.request.messages))
+        },
+        ...(input.response
+            ? {
+                output: {
+                    finishReason: input.response.finishReason,
+                    approxTokens: input.response.usage?.outputTokens ?? approximateTokens(input.response.content)
+                }
+            }
+            : {}),
+        issues
+    };
+    return assertProviderCallSchema(report);
+}
+function assertProviderConfigSchema(config) {
+    const result = (0, schema_1.validateSchema)('hadara.provider.config.v1', config);
+    if (!result.ok) {
+        throw new ProviderConfigError(formatSchemaIssues('Provider config', result.issues));
+    }
+    return config;
+}
+function assertProviderCallSchema(report) {
+    const result = (0, schema_1.validateSchema)('hadara.provider.call.v1', report);
+    if (!result.ok) {
+        throw new ProviderCallReportError(formatSchemaIssues('Provider call report', result.issues));
+    }
+    return report;
+}
+function normalizeProviderCallIssue(error) {
+    if (isProviderError(error)) {
+        return {
+            severity: 'error',
+            code: error.code,
+            message: (0, redaction_1.redactSecrets)(error.message),
+            retriable: error.retriable
+        };
+    }
+    return {
+        severity: 'error',
+        code: 'PROVIDER_UNKNOWN',
+        message: (0, redaction_1.redactSecrets)(error instanceof Error ? error.message : String(error)),
+        retriable: false
+    };
+}
+function rejectSecretValueFields(input) {
+    const candidate = input;
+    for (const key of SECRET_VALUE_KEYS) {
+        if (Object.prototype.hasOwnProperty.call(candidate, key)) {
+            throw new ProviderConfigError(`Provider config must reference secret environment variable names, not "${key}" values.`);
+        }
+    }
+}
+function rejectUnknownFields(input, allowedKeys, label) {
+    if (!isPlainObject(input)) {
+        throw new ProviderConfigError(`${label} must be an object.`);
+    }
+    const unknownKeys = Object.keys(input).filter((key) => !allowedKeys.has(key));
+    if (unknownKeys.length > 0) {
+        throw new ProviderConfigError(`${label} contains unsupported field(s): ${unknownKeys.join(', ')}.`);
+    }
+}
+function normalizeProviderId(value, label, ErrorClass) {
+    const id = requireNonEmptyString(value, label, ErrorClass);
+    if (!PROVIDER_ID_PATTERN.test(id)) {
+        throw new ErrorClass(`${label} must match ${PROVIDER_ID_PATTERN.source}.`);
+    }
+    return id;
+}
+function normalizeProviderKind(value) {
+    if (!PROVIDER_KIND_VALUES.has(value)) {
+        throw new ProviderConfigError(`provider kind must be one of ${Array.from(PROVIDER_KIND_VALUES).join(', ')}.`);
+    }
+    return value;
+}
+function normalizeCostProfile(value) {
+    const costProfile = value ?? 'unknown';
+    if (!COST_PROFILE_VALUES.has(costProfile)) {
+        throw new ProviderConfigError(`costProfile must be one of ${Array.from(COST_PROFILE_VALUES).join(', ')}.`);
+    }
+    return costProfile;
+}
+function normalizeCapabilities(input) {
+    if (input !== undefined) {
+        rejectUnknownFields(input, PROVIDER_CAPABILITY_INPUT_KEYS, 'provider capabilities');
+    }
+    return {
+        streaming: optionalBoolean(input?.supportsStreaming, 'supportsStreaming') ?? false,
+        toolCalling: optionalBoolean(input?.supportsToolCalling, 'supportsToolCalling') ?? false,
+        reasoning: optionalBoolean(input?.supportsReasoning, 'supportsReasoning') ?? false,
+        vision: optionalBoolean(input?.supportsVision, 'supportsVision') ?? false
+    };
+}
+function optionalBoolean(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean') {
+        throw new ProviderConfigError(`${label} must be a boolean.`);
+    }
+    return value;
+}
+function normalizeEnvName(value, fieldName) {
+    const envName = requireNonEmptyString(value, fieldName, ProviderConfigError);
+    if (!ENV_NAME_PATTERN.test(envName)) {
+        throw new ProviderConfigError(`${fieldName} must be an environment variable name.`);
+    }
+    return envName;
+}
+function requireNonEmptyString(value, label, ErrorClass) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new ErrorClass(`${label} must be a non-empty string.`);
+    }
+    return value.trim();
+}
+function approximateTokens(input) {
+    return Math.max(1, Math.ceil(input.length / 4));
+}
+function isProviderError(error) {
+    return Boolean(error && typeof error === 'object' && 'provider' in error && 'code' in error && 'retriable' in error);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function formatSchemaIssues(label, issues) {
+    const firstIssue = issues[0];
+    if (!firstIssue)
+        return `${label} failed schema validation.`;
+    return `${label} failed schema validation: ${firstIssue.path} ${firstIssue.code} ${firstIssue.message}`;
+}

package/dist/providers/scripted-provider.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptedProvider = void 0;
+class ScriptedProvider {
+    script;
+    id = 'scripted';
+    displayName = 'ScriptedProvider';
+    capabilities = {
+        supportsStreaming: true,
+        supportsToolCalling: false,
+        supportsReasoning: false,
+        supportsVision: false,
+        maxContextTokens: 8192,
+        localOnly: true,
+        costProfile: 'free'
+    };
+    currentIndex = 0;
+    constructor(script) {
+        this.script = script;
+    }
+    async chat(request) {
+        const last = request.messages.at(-1)?.content ?? '';
+        const step = this.script[this.currentIndex];
+        if (!step) {
+            throw this.normalizeError(new Error(`ScriptedProvider exhausted after ${this.currentIndex} step(s). Last message: ${last}`));
+        }
+        if (step.match && !last.includes(step.match)) {
+            throw this.normalizeError(new Error(`ScriptedProvider step ${this.currentIndex + 1} expected message containing "${step.match}". Last message: ${last}`));
+        }
+        this.currentIndex += 1;
+        return {
+            provider: this.id,
+            model: request.model ?? 'scripted-model',
+            content: step.response,
+            finishReason: step.finishReason ?? 'stop'
+        };
+    }
+    async *stream(request) {
+        yield { type: 'start', provider: this.id, model: request.model ?? 'scripted-model' };
+        try {
+            const response = await this.chat(request);
+            for (const token of response.content.split(' ')) {
+                yield { type: 'delta', text: `${token} ` };
+            }
+            yield { type: 'finish', finishReason: response.finishReason };
+        }
+        catch (error) {
+            const normalized = this.normalizeError(error);
+            yield { type: 'error', message: normalized.message, retriable: normalized.retriable };
+        }
+    }
+    async countTokens(input) {
+        return { tokens: Math.ceil(input.length / 4), approximate: true };
+    }
+    normalizeError(error) {
+        if (isProviderError(error))
+            return error;
+        return {
+            provider: this.id,
+            code: 'SCRIPTED_PROVIDER_ERROR',
+            message: error instanceof Error ? error.message : String(error),
+            retriable: false
+        };
+    }
+}
+exports.ScriptedProvider = ScriptedProvider;
+function isProviderError(error) {
+    return Boolean(error && typeof error === 'object' && 'provider' in error && 'code' in error && 'retriable' in error);
+}

package/dist/schemas/active-run-projection.schema.json

@@ -0,0 +1,73 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.active_run.projection.v1",
+    "x-hadara-schema-id": "hadara.active_run.projection.v1",
+    "title": "HADARA Active Run Projection Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "path", "activeRun", "handoff", "resume", "issues"],
+    "properties": {
+        "schemaVersion": { "const": "hadara.active_run.projection.v1" },
+        "command": { "const": "active-run.projection" },
+        "ok": { "const": true },
+        "path": { "const": ".hadara/local/state/active-run.json" },
+        "activeRun": {
+            "oneOf": [{ "$ref": "#/$defs/activeRunManifest" }, { "type": "null" }]
+        },
+        "handoff": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["fresh", "staleReason"],
+            "properties": {
+                "fresh": { "type": "boolean" },
+                "staleReason": { "type": ["string", "null"] }
+            }
+        },
+        "resume": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "additionalProperties": true,
+                    "required": ["taskId", "capsule", "nextAction"],
+                    "properties": {
+                        "taskId": { "type": "string", "pattern": "^T-[0-9]{4}$" },
+                        "capsule": { "type": "string" },
+                        "nextAction": { "type": "string", "minLength": 1 }
+                    }
+                },
+                { "type": "null" }
+            ]
+        },
+        "issues": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/issue" }
+        }
+    },
+    "$defs": {
+        "activeRunManifest": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["schemaVersion", "runId", "taskId", "capsule", "status", "startedAt", "updatedAt", "summary"],
+            "properties": {
+                "schemaVersion": { "const": "hadara.active_run.v1" },
+                "runId": { "type": "string", "minLength": 1 },
+                "taskId": { "type": "string", "pattern": "^T-[0-9]{4}$" },
+                "capsule": { "type": "string" },
+                "status": { "type": "string", "enum": ["active", "paused"] },
+                "startedAt": { "type": "string", "minLength": 1 },
+                "updatedAt": { "type": "string", "minLength": 1 },
+                "summary": { "type": "string" }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "type": "string", "enum": ["warning", "error"] },
+                "code": { "type": "string", "minLength": 1 },
+                "message": { "type": "string", "minLength": 1 }
+            }
+        }
+    }
+}

package/dist/schemas/active-run-resume.schema.json

@@ -0,0 +1,68 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.active_run.resume.v1",
+    "x-hadara-schema-id": "hadara.active_run.resume.v1",
+    "title": "HADARA Active Run Resume Guidance Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "activeRun", "resumePrompt", "issues"],
+    "properties": {
+        "schemaVersion": { "const": "hadara.active_run.resume.v1" },
+        "command": { "const": "active-run.resume" },
+        "ok": { "const": true },
+        "activeRun": {
+            "oneOf": [{ "$ref": "#/$defs/activeRunManifest" }, { "type": "null" }]
+        },
+        "resumePrompt": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["summary", "mustRead", "nextActions", "constraints"],
+            "properties": {
+                "summary": { "type": "string", "minLength": 1 },
+                "mustRead": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "nextActions": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "constraints": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 }
+                }
+            }
+        },
+        "issues": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/issue" }
+        }
+    },
+    "$defs": {
+        "activeRunManifest": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["schemaVersion", "runId", "taskId", "capsule", "status", "startedAt", "updatedAt", "summary"],
+            "properties": {
+                "schemaVersion": { "const": "hadara.active_run.v1" },
+                "runId": { "type": "string", "minLength": 1 },
+                "taskId": { "type": "string", "pattern": "^T-[0-9]{4}$" },
+                "capsule": { "type": "string" },
+                "status": { "type": "string", "enum": ["active", "paused"] },
+                "startedAt": { "type": "string", "minLength": 1 },
+                "updatedAt": { "type": "string", "minLength": 1 },
+                "summary": { "type": "string" }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "type": "string", "enum": ["warning", "error"] },
+                "code": { "type": "string", "minLength": 1 },
+                "message": { "type": "string", "minLength": 1 }
+            }
+        }
+    }
+}

package/dist/schemas/clean-checkout-smoke.schema.json

@@ -0,0 +1,126 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.cleanCheckoutSmoke.v1",
+    "x-hadara-schema-id": "hadara.cleanCheckoutSmoke.v1",
+    "title": "HADARA Clean Checkout Smoke Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+        "schemaVersion",
+        "command",
+        "ok",
+        "mode",
+        "execution",
+        "workspace",
+        "source",
+        "steps",
+        "privacy",
+        "issues"
+    ],
+    "properties": {
+        "schemaVersion": { "const": "hadara.cleanCheckoutSmoke.v1" },
+        "command": { "const": "smoke.cleanCheckout" },
+        "ok": { "type": "boolean" },
+        "mode": { "type": "string", "enum": ["execute"] },
+        "execution": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["sourceCopied", "dependencyInstallExecuted", "buildExecuted", "checkExecuted", "builtCliSmokeExecuted", "packageInstallExecuted", "releaseMutationExecuted", "publishExecuted"],
+            "properties": {
+                "sourceCopied": { "type": "boolean" },
+                "dependencyInstallExecuted": { "type": "boolean" },
+                "buildExecuted": { "type": "boolean" },
+                "checkExecuted": { "type": "boolean" },
+                "builtCliSmokeExecuted": { "type": "boolean" },
+                "packageInstallExecuted": { "const": false },
+                "releaseMutationExecuted": { "const": false },
+                "publishExecuted": { "const": false }
+            }
+        },
+        "workspace": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["kind", "displayPath", "pathRedacted", "retention"],
+            "properties": {
+                "kind": { "const": "disposable-clean-checkout" },
+                "displayPath": { "type": "string", "minLength": 1 },
+                "relativePath": { "type": "string", "minLength": 1 },
+                "pathRedacted": { "const": true },
+                "retention": { "type": "string", "enum": ["deleted", "kept-temporary"] }
+            }
+        },
+        "source": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["kind", "displayPath", "pathRedacted", "mutated"],
+            "properties": {
+                "kind": { "const": "source-checkout" },
+                "displayPath": { "type": "string", "minLength": 1 },
+                "relativePath": { "type": "string", "minLength": 1 },
+                "pathRedacted": { "const": true },
+                "mutated": { "const": false }
+            }
+        },
+        "steps": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/step" }
+        },
+        "artifacts": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/artifact" }
+        },
+        "privacy": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["rawLogsIncluded", "privatePathsIncluded", "environmentSecretsIncluded", "privateStorePathsIncluded"],
+            "properties": {
+                "rawLogsIncluded": { "const": false },
+                "privatePathsIncluded": { "const": false },
+                "environmentSecretsIncluded": { "const": false },
+                "privateStorePathsIncluded": { "const": false }
+            }
+        },
+        "issues": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/issue" }
+        }
+    },
+    "$defs": {
+        "step": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "label", "command", "status", "summary"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "label": { "type": "string", "minLength": 1 },
+                "command": { "type": "string", "minLength": 1 },
+                "status": { "type": "string", "enum": ["passed", "failed", "skipped"] },
+                "exitCode": { "type": ["integer", "null"] },
+                "elapsedMs": { "type": "integer" },
+                "summary": { "type": "string", "minLength": 1 }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "type": "string", "enum": ["warning", "error"] },
+                "code": { "type": "string", "minLength": 1 },
+                "message": { "type": "string", "minLength": 1 },
+                "stepId": { "type": "string", "minLength": 1 }
+            }
+        },
+        "artifact": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["kind", "visibility", "evidencePath", "rawContentIncluded"],
+            "properties": {
+                "kind": { "const": "summary" },
+                "visibility": { "const": "public" },
+                "evidencePath": { "type": "string", "pattern": "^tasks/T-[0-9]{4}-.+/artifacts/clean-checkout-smoke/.+" },
+                "rawContentIncluded": { "const": false }
+            }
+        }
+    }
+}