@skill-harness/core 0.17.0 → 0.18.0

package/dist/spec.js

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import yaml from "js-yaml";
 import { parseTraceAssert } from "./trace-gates.js";
-import { parseTrajectoryAssert } from "./trajectory-gates.js";
 /** Thrown on any validation failure. Message always carries the spec file path. */
 export class SpecError extends Error {
     constructor(message, file) {
@@ -89,46 +88,6 @@ function resolveExtensions(env, hasSystemPrompt, id, file) {
  * with empty-git or a fixture — asking for one on a bare cwd is an authoring mistake,
  * not something to silently ignore.
  */
-function resolveEventSources(env, id, file) {
-    const raw = env && typeof env === "object" ? env.event_sources : undefined;
-    if (raw === undefined)
-        return undefined;
-    if (!Array.isArray(raw) || raw.length === 0) {
-        throw new SpecError(`scenario \`${id}\` env.event_sources must be a non-empty list`, file);
-    }
-    const allowedAdapters = new Set([
-        "normalized-v1", "principal-assurance-v1", "pi-daddy-v1", "pi-daddy-ledger-v3",
-    ]);
-    return raw.map((entry, index) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}] must be a mapping`, file);
-        }
-        const source = entry;
-        for (const key of Object.keys(source)) {
-            if (!["adapter", "path", "required"].includes(key)) {
-                throw new SpecError(`scenario \`${id}\` env.event_sources[${index}] has unknown key \`${key}\``, file);
-            }
-        }
-        if (!allowedAdapters.has(source.adapter)) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].adapter is unsupported`, file);
-        }
-        if (typeof source.path !== "string" || !source.path.trim()) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].path must be non-empty`, file);
-        }
-        const path = source.path.trim();
-        if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || path.includes("\\") || path.split("/").some((part) => part === ".." || part === "." || part === "")) {
-            throw new SpecError(`scenario \`${id}\` env.event_sources paths must be workspace-relative without traversal (got \`${path}\`)`, file);
-        }
-        if (source.required !== undefined && typeof source.required !== "boolean") {
-            throw new SpecError(`scenario \`${id}\` env.event_sources[${index}].required must be true or false`, file);
-        }
-        return {
-            adapter: source.adapter,
-            path,
-            required: source.required !== false,
-        };
-    });
-}
 function resolveRemote(env, workspace, id, file) {
     const raw = env && typeof env === "object" ? env.remote : undefined;
     if (raw === undefined)
@@ -220,12 +179,12 @@ export function parseSpec(text, file) {
         // `assert.trace` is legal for inline AND seeded scenarios — it reads the
         // execution trace, which every run produces, not a staged diff.
         const rawAssert = s.assert;
+        if (rawAssert?.trajectory !== undefined) {
+            throw new SpecError(`scenario \`${id}\` uses removed \`assert.trajectory\`; delete it or replace it with an active objective gate`, file);
+        }
         if (rawAssert?.trace !== undefined) {
             scenario.traceAssert = parseTraceAssert(rawAssert.trace, `${file}: scenario \`${id}\``);
         }
-        if (rawAssert?.trajectory !== undefined) {
-            scenario.trajectoryAssert = parseTrajectoryAssert(rawAssert.trajectory, `${file}: scenario \`${id}\``);
-        }
         if (mode === "seeded") {
             if (typeof s.fixture !== "string" || s.fixture.length === 0) {
                 throw new SpecError(`seeded scenario \`${id}\` requires a \`fixture\` path`, file);
@@ -276,12 +235,11 @@ export function parseSpec(text, file) {
                 scenario.assert = assertObj;
             }
         }
+        if (s.env && typeof s.env === "object" && Object.hasOwn(s.env, "event_sources")) {
+            throw new SpecError(`scenario \`${id}\` uses removed \`env.event_sources\`; it is no longer collected`, file);
+        }
         scenario.workspace = resolveWorkspace(s.env, mode, scenario.fixture, id, file);
         scenario.remote = resolveRemote(s.env, scenario.workspace, id, file);
-        scenario.eventSources = resolveEventSources(s.env, id, file);
-        if (scenario.eventSources && !scenario.trajectoryAssert) {
-            throw new SpecError(`scenario \`${id}\` declares env.event_sources without assert.trajectory`, file);
-        }
         if (s.system_prompt_file !== undefined) {
             if (typeof s.system_prompt_file !== "string" || !s.system_prompt_file.trim()) {
                 throw new SpecError(`scenario \`${id}\` \`system_prompt_file\` must be a non-empty string`, file);

package/dist/trajectory-events.d.ts

@@ -0,0 +1,58 @@
+export declare const LEGACY_TRAJECTORY_EVENT_VERSION: "1.0";
+export declare const TRAJECTORY_EVENT_VERSION: "1.1";
+export type TrajectoryEventVersion = typeof LEGACY_TRAJECTORY_EVENT_VERSION | typeof TRAJECTORY_EVENT_VERSION;
+export interface TrajectoryEventSource {
+    adapter: "normalized-v1" | "principal-assurance-v1" | "pi-daddy-v1" | "pi-daddy-ledger-v3";
+    path: string;
+    required: boolean;
+}
+export interface TrajectoryApproval {
+    id?: string;
+    capability?: string;
+    subject?: string;
+    source?: string;
+    scope?: string;
+    approved_at?: string;
+    expires_at?: string;
+    used_at?: string;
+}
+export interface TrajectoryDigests {
+    plan?: string;
+    task?: string;
+    definition?: string;
+    head?: string;
+    tree?: string;
+    [key: string]: string | undefined;
+}
+/** Normalized pi-daddy/principal event retained by adapter consumers. */
+export interface TrajectoryEventV1 {
+    event_version: TrajectoryEventVersion;
+    seq: number;
+    type: string;
+    source: string;
+    at?: string;
+    run_id?: string;
+    task_id?: string;
+    workspace_id?: string;
+    context_id?: string;
+    finding_id?: string;
+    parent_id?: string;
+    child_id?: string;
+    execution_id?: string;
+    parent_execution_id?: string | null;
+    task_from_execution_id?: string;
+    workflow_fact_id?: string;
+    deadline_at?: string;
+    phase?: string;
+    tool?: string;
+    capability?: string;
+    requested_capabilities?: string[];
+    effective_capabilities?: string[];
+    refusal_code?: string;
+    exit_code?: number;
+    digests?: TrajectoryDigests;
+    approval?: TrajectoryApproval;
+    requirements?: string[];
+    attributes?: Record<string, unknown>;
+}
+export declare function deserializeTrajectoryEvents(text: string): TrajectoryEventV1[] | null;

package/dist/trajectory-events.js

@@ -0,0 +1,119 @@
+export const LEGACY_TRAJECTORY_EVENT_VERSION = "1.0";
+export const TRAJECTORY_EVENT_VERSION = "1.1";
+export function deserializeTrajectoryEvents(text) {
+    const out = [];
+    try {
+        for (const line of text.split("\n").filter((entry) => entry.trim())) {
+            const event = JSON.parse(line);
+            if (validateEvent(event) !== null)
+                return null;
+            out.push(event);
+        }
+    }
+    catch {
+        return null;
+    }
+    if (!out.length)
+        return null;
+    const sequences = out.map((event) => event.seq).sort((a, b) => a - b);
+    if (new Set(sequences).size !== out.length || sequences.some((seq, index) => seq !== index + 1))
+        return null;
+    return out;
+}
+const V11_EVENT_KEYS = new Set(["execution_id", "parent_execution_id", "task_from_execution_id", "workflow_fact_id", "deadline_at"]);
+const EVENT_KEYS = new Set([
+    "event_version", "seq", "type", "source", "at", "run_id", "task_id", "workspace_id", "context_id", "finding_id",
+    "parent_id", "child_id", ...V11_EVENT_KEYS,
+    "phase", "tool", "capability", "requested_capabilities", "effective_capabilities", "refusal_code",
+    "exit_code", "digests", "approval", "requirements", "attributes",
+]);
+const APPROVAL_KEYS = new Set(["id", "capability", "subject", "source", "scope", "approved_at", "expires_at", "used_at"]);
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SHA256_RE = /^[a-fA-F0-9]{64}$/;
+const GIT_SHA_RE = /^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/;
+const REFUSAL_RE = /^[A-Z][A-Z0-9_]*$/;
+function validateEvent(event) {
+    if (!event || typeof event !== "object" || Array.isArray(event))
+        return "event must be an object";
+    const object = event;
+    const unknown = Object.keys(object).find((key) => !EVENT_KEYS.has(key));
+    if (unknown)
+        return `unknown field ${unknown}`;
+    if (event.event_version !== LEGACY_TRAJECTORY_EVENT_VERSION && event.event_version !== TRAJECTORY_EVENT_VERSION)
+        return `unsupported event_version ${String(event.event_version)}`;
+    if (event.event_version === LEGACY_TRAJECTORY_EVENT_VERSION) {
+        const versionedField = Object.keys(object).find((key) => V11_EVENT_KEYS.has(key));
+        if (versionedField)
+            return `${versionedField} requires event_version ${TRAJECTORY_EVENT_VERSION}`;
+    }
+    if (!Number.isInteger(event.seq) || event.seq < 1)
+        return "seq must be a positive integer";
+    if (typeof event.type !== "string" || !event.type)
+        return "type must be a non-empty string";
+    if (typeof event.source !== "string" || !event.source)
+        return "source must be a non-empty string";
+    if (event.at !== undefined && !validDate(event.at))
+        return "at must be an RFC 3339 date-time";
+    for (const field of ["run_id", "task_id", "workspace_id", "context_id", "finding_id", "parent_id", "child_id", "execution_id", "task_from_execution_id", "workflow_fact_id"]) {
+        if (event[field] !== undefined && (typeof event[field] !== "string" || !ID_RE.test(event[field])))
+            return `${field} is not a valid bounded identifier`;
+    }
+    if (event.parent_execution_id !== undefined && event.parent_execution_id !== null && (typeof event.parent_execution_id !== "string" || !ID_RE.test(event.parent_execution_id)))
+        return "parent_execution_id is not a valid bounded identifier or null";
+    if (event.deadline_at !== undefined && !validDate(event.deadline_at))
+        return "deadline_at must be an RFC 3339 date-time";
+    for (const field of ["phase", "tool", "capability"])
+        if (event[field] !== undefined && (typeof event[field] !== "string" || !event[field]))
+            return `${field} must be a non-empty string`;
+    for (const field of ["requested_capabilities", "effective_capabilities", "requirements"]) {
+        const values = event[field];
+        if (values !== undefined && (!Array.isArray(values) || values.some((value) => typeof value !== "string" || !value) || new Set(values).size !== values.length))
+            return `${field} must be an array of unique non-empty strings`;
+    }
+    if (event.refusal_code !== undefined && !REFUSAL_RE.test(event.refusal_code))
+        return "refusal_code is invalid";
+    if (event.exit_code !== undefined && !Number.isInteger(event.exit_code))
+        return "exit_code must be an integer";
+    if (event.digests !== undefined) {
+        if (!event.digests || typeof event.digests !== "object" || Array.isArray(event.digests))
+            return "digests must be an object";
+        for (const [key, value] of Object.entries(event.digests)) {
+            if (typeof value !== "string")
+                return `digests.${key} must be a string`;
+            if (["plan", "task", "definition"].includes(key) && !SHA256_RE.test(value))
+                return `digests.${key} must be sha256`;
+            if (["head", "tree"].includes(key) && !GIT_SHA_RE.test(value))
+                return `digests.${key} must be a git object id`;
+        }
+    }
+    if (event.approval !== undefined) {
+        if (!event.approval || typeof event.approval !== "object" || Array.isArray(event.approval))
+            return "approval must be an object";
+        const unknownApproval = Object.keys(event.approval).find((key) => !APPROVAL_KEYS.has(key));
+        if (unknownApproval)
+            return `approval.${unknownApproval} is unknown`;
+        for (const [key, value] of Object.entries(event.approval)) {
+            if (typeof value !== "string" || !value)
+                return `approval.${key} must be a non-empty string`;
+            if (key === "id" && !ID_RE.test(value))
+                return "approval.id is invalid";
+            if (["approved_at", "expires_at", "used_at"].includes(key) && !validDate(value))
+                return `approval.${key} must be an RFC 3339 date-time`;
+        }
+    }
+    if (event.attributes !== undefined && (!event.attributes || typeof event.attributes !== "object" || Array.isArray(event.attributes)))
+        return "attributes must be an object";
+    return null;
+}
+function validDate(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (!match || !Number.isFinite(Date.parse(value)))
+        return false;
+    const [, year, month, day, hour, minute, second] = match.map(Number);
+    if (month < 1 || month > 12 || hour > 23 || minute > 59 || second > 59)
+        return false;
+    return day >= 1 && day <= new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+//# sourceMappingURL=trajectory-events.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/core",
-    "version": "0.17.0",
+    "version": "0.18.0",
     "description": "skill-harness engine — spec, discover, run, LLM-judge grade, score, results (internal API)",
     "type": "module",
     "license": "MIT",