sortie-dogs 0.1.1

package/dist/core/initialize.js

@@ -0,0 +1,371 @@
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, rm, rmdir } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+const assets = await import(`../runtime-assets.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+const { runtimeAssets } = assets;
+const OPEN_CODE_DIRECTORY = ".opencode";
+const VERSION_MARKER = `${OPEN_CODE_DIRECTORY}/sortie-dogs.version`;
+const LEGACY_RUNTIME_ASSETS = [
+    {
+        relativePath: ".opencode/agent/coordinator-mk2a2.md",
+        markerVersions: ["0.2.0-card04"],
+        sha256: "464e58c4973073937493d6a2205dc8594236b38d83cf63a8bba2965afe7c011c",
+    },
+    {
+        relativePath: ".opencode/agent/sol-worker-mk2a2.md",
+        markerVersions: ["0.2.0-card04"],
+        sha256: "32391b899a2b1a39bcd03653adfcfe9e5d7343e1494cab020b16e5784b8bc0ba",
+    },
+];
+export class ProjectInitializationError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "ProjectInitializationError";
+        this.code = code;
+    }
+}
+function assetVersion() {
+    const versions = new Set(runtimeAssets.map(({ version }) => version));
+    if (versions.size !== 1) {
+        throw new ProjectInitializationError("write-failed", "Runtime assets do not share one version.");
+    }
+    return versions.values().next().value;
+}
+function safeAssetPath(installPath) {
+    const unified = installPath.replaceAll("\\", "/");
+    const segments = unified.split("/");
+    if (isAbsolute(installPath) || /^[A-Za-z]:/u.test(unified) ||
+        segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new ProjectInitializationError("unsafe-path", "A runtime asset has an unsafe install path.");
+    }
+    return `${OPEN_CODE_DIRECTORY}/${unified}`;
+}
+function parseMarker(content) {
+    const match = /^([^\r\n]+)\r?\n$/u.exec(content);
+    if (match === null || parseVersion(match[1]) === undefined) {
+        throw new ProjectInitializationError("conflict", "The Sortie-dogs version marker is invalid.");
+    }
+    return match[1];
+}
+function parseVersion(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value);
+    if (match === null)
+        return undefined;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4]?.split(".") ?? [],
+    };
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return left.length === right.length ? 0 : left.length === 0 ? 1 : -1;
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined || rightPart === undefined)
+            return leftPart === undefined ? -1 : 1;
+        if (leftPart === rightPart)
+            continue;
+        const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : undefined;
+        const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : undefined;
+        if (leftNumber !== undefined && rightNumber !== undefined)
+            return leftNumber < rightNumber ? -1 : 1;
+        if (leftNumber !== undefined || rightNumber !== undefined)
+            return leftNumber !== undefined ? -1 : 1;
+        return leftPart < rightPart ? -1 : 1;
+    }
+    return 0;
+}
+function compareVersions(left, right) {
+    for (const key of ["major", "minor", "patch"]) {
+        if (left[key] !== right[key])
+            return left[key] < right[key] ? -1 : 1;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+function classifyVersionTransition(installedValue, currentValue) {
+    const installed = parseVersion(installedValue);
+    const current = parseVersion(currentValue);
+    if (installed === undefined || current === undefined)
+        return "incompatible";
+    const order = compareVersions(installed, current);
+    if (order === 0)
+        return "same";
+    if (order > 0)
+        return "incompatible";
+    // SemVer-compatible update line: stable releases share a major; 0.x releases also share a minor.
+    const sameLine = installed.major === current.major &&
+        (installed.major !== 0 || installed.minor === current.minor);
+    return sameLine ? "compatible-update" : "incompatible";
+}
+async function metadata(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function insideRoot(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (!path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path));
+}
+async function assertSafeExistingPath(root, relativePath, file) {
+    const segments = relativePath.split("/");
+    let candidate = root;
+    for (let index = 0; index < segments.length; index += 1) {
+        candidate = resolve(candidate, segments[index]);
+        if (!insideRoot(root, candidate)) {
+            throw new ProjectInitializationError("unsafe-path", "An initialization path escapes the project root.");
+        }
+        const info = await metadata(candidate);
+        if (info === undefined)
+            return false;
+        if (info.isSymbolicLink()) {
+            throw new ProjectInitializationError("unsafe-path", "Initialization paths must not contain symbolic links.");
+        }
+        const isLast = index === segments.length - 1;
+        if (isLast && file) {
+            if (!info.isFile()) {
+                throw new ProjectInitializationError("conflict", "An initialization file path is not a regular file.");
+            }
+        }
+        else if (!info.isDirectory()) {
+            throw new ProjectInitializationError("conflict", "An initialization directory path is not a directory.");
+        }
+    }
+    return true;
+}
+async function readableOwnedLegacyFile(root, asset) {
+    let candidate = root;
+    const segments = asset.relativePath.split("/");
+    for (let index = 0; index < segments.length; index += 1) {
+        candidate = resolve(candidate, segments[index]);
+        if (!insideRoot(root, candidate))
+            return "preserve";
+        const info = await metadata(candidate);
+        if (info === undefined)
+            return "absent";
+        if (info.isSymbolicLink())
+            return "preserve";
+        const isLast = index === segments.length - 1;
+        if (isLast ? !info.isFile() : !info.isDirectory())
+            return "preserve";
+    }
+    const content = await readFile(candidate);
+    return createHash("sha256").update(content).digest("hex") === asset.sha256 ? content : "preserve";
+}
+async function ensureDirectory(root, relativePath, createdDirectories) {
+    let candidate = root;
+    for (const segment of relativePath.split("/")) {
+        candidate = resolve(candidate, segment);
+        const info = await metadata(candidate);
+        if (info !== undefined) {
+            if (info.isSymbolicLink()) {
+                throw new ProjectInitializationError("unsafe-path", "Initialization paths must not contain symbolic links.");
+            }
+            if (!info.isDirectory()) {
+                throw new ProjectInitializationError("conflict", "An initialization directory path is not a directory.");
+            }
+            continue;
+        }
+        try {
+            await mkdir(candidate);
+            createdDirectories.push(candidate);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const raced = await lstat(candidate);
+            if (raced.isSymbolicLink() || !raced.isDirectory()) {
+                throw new ProjectInitializationError("unsafe-path", "An initialization directory changed during init.");
+            }
+        }
+    }
+}
+async function rollback(root, createdFiles, modifiedFiles, removedFiles, createdDirectories) {
+    const failures = [];
+    for (const file of [...createdFiles].reverse()) {
+        await rm(file, { force: true }).catch((error) => failures.push(error));
+    }
+    for (const file of [...modifiedFiles].reverse()) {
+        await overwriteFileSafely(root, file.relativePath, file.content).catch((error) => failures.push(error));
+    }
+    for (const file of [...removedFiles].reverse()) {
+        const path = resolve(root, file.relativePath);
+        let handle;
+        try {
+            handle = await open(path, "wx");
+            await handle.writeFile(file.content);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        finally {
+            await handle?.close().catch((error) => failures.push(error));
+        }
+    }
+    for (const directory of [...createdDirectories].reverse()) {
+        await rmdir(directory).catch((error) => {
+            if (error.code !== "ENOENT")
+                failures.push(error);
+        });
+    }
+    if (failures.length > 0)
+        throw new AggregateError(failures, "Initialization rollback failed.");
+}
+async function createFile(path, content, createdFiles) {
+    let handle;
+    try {
+        handle = await open(path, "wx");
+        createdFiles.push(path);
+        await handle.writeFile(content, "utf8");
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function overwriteFileSafely(root, relativePath, content, beforeMutation) {
+    await assertSafeExistingPath(root, relativePath, true);
+    const path = resolve(root, relativePath);
+    let handle;
+    try {
+        // O_NOFOLLOW closes the race between the final lstat above and opening the destination.
+        handle = await open(path, constants.O_WRONLY | constants.O_NOFOLLOW);
+        if (!(await handle.stat()).isFile()) {
+            throw new ProjectInitializationError("conflict", "An initialization file path is not a regular file.");
+        }
+        beforeMutation?.();
+        await handle.truncate(0);
+        await handle.writeFile(content);
+    }
+    catch (error) {
+        if (error.code === "ELOOP") {
+            throw new ProjectInitializationError("unsafe-path", "Initialization paths must not contain symbolic links.", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+/** Installs the packaged runtime into one existing project without changing user settings. */
+export async function initializeProject(projectRoot = process.cwd()) {
+    const root = resolve(projectRoot);
+    const rootInfo = await metadata(root);
+    if (rootInfo === undefined || !rootInfo.isDirectory() || rootInfo.isSymbolicLink()) {
+        throw new ProjectInitializationError("invalid-project", "Project root must be an existing non-symlink directory.");
+    }
+    const version = assetVersion();
+    const assetEntries = runtimeAssets.map(({ installPath, content }) => ({
+        relativePath: safeAssetPath(installPath),
+        content,
+    }));
+    const entries = [
+        ...assetEntries,
+        { relativePath: VERSION_MARKER, content: `${version}\n` },
+    ];
+    const existing = await Promise.all(entries.map(async (entry) => {
+        const present = await assertSafeExistingPath(root, entry.relativePath, true);
+        return present ? await readFile(resolve(root, entry.relativePath)) : undefined;
+    }));
+    const markerIndex = entries.length - 1;
+    const markerText = existing[markerIndex];
+    const matches = (entry, index) => existing[index]?.equals(Buffer.from(entry.content)) ?? false;
+    const assetsMatch = assetEntries.every(matches);
+    if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch) {
+        return {
+            status: "unchanged",
+            version,
+            installedPaths: entries.map(({ relativePath }) => relativePath),
+            preservedLegacyPaths: [],
+        };
+    }
+    if (markerText === undefined) {
+        if (existing.some((content) => content !== undefined)) {
+            throw new ProjectInitializationError("conflict", "Existing Sortie-dogs runtime files have unknown ownership.");
+        }
+    }
+    else {
+        const installedVersion = parseMarker(markerText.toString("utf8"));
+        if (classifyVersionTransition(installedVersion, version) === "incompatible") {
+            throw new ProjectInitializationError("incompatible-version", `Installed Sortie-dogs ${installedVersion} cannot be updated to ${version}.`);
+        }
+    }
+    const installedVersion = markerText === undefined ? undefined : parseMarker(markerText.toString("utf8"));
+    const removableLegacyFiles = [];
+    const preservedLegacyPaths = [];
+    if (installedVersion !== undefined) {
+        for (const asset of LEGACY_RUNTIME_ASSETS) {
+            if (!asset.markerVersions.includes(installedVersion))
+                continue;
+            const state = await readableOwnedLegacyFile(root, asset);
+            if (Buffer.isBuffer(state))
+                removableLegacyFiles.push({ asset, content: state });
+            else if (state === "preserve")
+                preservedLegacyPaths.push(asset.relativePath);
+        }
+    }
+    const createdFiles = [];
+    const modifiedFiles = [];
+    const removedFiles = [];
+    const createdDirectories = [];
+    try {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            if (matches(entry, index))
+                continue;
+            const parent = dirname(entry.relativePath).replaceAll("\\", "/");
+            await ensureDirectory(root, parent, createdDirectories);
+            await assertSafeExistingPath(root, parent, false);
+            const target = resolve(root, entry.relativePath);
+            if (existing[index] === undefined) {
+                await createFile(target, entry.content, createdFiles);
+            }
+            else {
+                await overwriteFileSafely(root, entry.relativePath, entry.content, () => {
+                    modifiedFiles.push({ relativePath: entry.relativePath, content: existing[index] });
+                });
+            }
+        }
+        for (const { asset } of removableLegacyFiles) {
+            const state = await readableOwnedLegacyFile(root, asset);
+            if (!Buffer.isBuffer(state)) {
+                if (state === "preserve" && !preservedLegacyPaths.includes(asset.relativePath)) {
+                    preservedLegacyPaths.push(asset.relativePath);
+                }
+                continue;
+            }
+            await rm(resolve(root, asset.relativePath));
+            removedFiles.push({ relativePath: asset.relativePath, content: state });
+        }
+    }
+    catch (error) {
+        try {
+            await rollback(root, createdFiles, modifiedFiles, removedFiles, createdDirectories);
+        }
+        catch (rollbackError) {
+            throw new ProjectInitializationError("write-failed", "Initialization failed and rollback was incomplete.", {
+                cause: new AggregateError([error, rollbackError]),
+            });
+        }
+        if (error instanceof ProjectInitializationError)
+            throw error;
+        const code = error.code === "EEXIST" ? "conflict" : "write-failed";
+        throw new ProjectInitializationError(code, "Initialization failed without changing the project.", { cause: error });
+    }
+    return {
+        status: "installed",
+        version,
+        installedPaths: entries.map(({ relativePath }) => relativePath),
+        preservedLegacyPaths,
+    };
+}

package/dist/core/path.d.ts

@@ -0,0 +1,10 @@
+export type RelativePathErrorReason = "empty" | "absolute" | "traversal";
+export declare class RelativePathError extends Error {
+    readonly reason: RelativePathErrorReason;
+    constructor(reason: RelativePathErrorReason);
+}
+/**
+ * Produces a platform-independent repository-relative path without resolving
+ * filesystem links. Input values are intentionally omitted from errors.
+ */
+export declare function normalizeRelativePath(input: string): string;

package/dist/core/path.js

@@ -0,0 +1,27 @@
+export class RelativePathError extends Error {
+    reason;
+    constructor(reason) {
+        super("Path must be a non-empty repository-relative path without traversal.");
+        this.name = "RelativePathError";
+        this.reason = reason;
+    }
+}
+/**
+ * Produces a platform-independent repository-relative path without resolving
+ * filesystem links. Input values are intentionally omitted from errors.
+ */
+export function normalizeRelativePath(input) {
+    const unified = input.replaceAll("\\", "/");
+    if (unified.startsWith("/") || /^[A-Za-z]:/.test(unified)) {
+        throw new RelativePathError("absolute");
+    }
+    const segments = unified.split("/");
+    if (segments.includes("..")) {
+        throw new RelativePathError("traversal");
+    }
+    const normalized = segments.filter((segment) => segment !== "" && segment !== ".").join("/");
+    if (normalized === "") {
+        throw new RelativePathError("empty");
+    }
+    return normalized;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,114 @@
+export type HandoffVersion = "0.1.0";
+export type HandoffProfile = "minimal" | "full";
+export interface HandoffTask {
+    title: string;
+    objective: string;
+}
+export interface HandoffScope {
+    paths: string[];
+    excludes?: string[];
+}
+export interface HandoffBlocker {
+    reason: string;
+    needed: string;
+}
+export interface HandoffState {
+    done: string[];
+    next: string[];
+    blocked: HandoffBlocker[];
+}
+export interface HandoffSource {
+    path: string;
+    rev: string;
+    hash?: string;
+}
+export type RiskSeverity = "low" | "medium" | "high";
+export interface HandoffRisk {
+    severity: RiskSeverity;
+    description: string;
+    mitigation?: string;
+}
+export type VerificationStatus = "pass" | "fail" | "not_run";
+export interface HandoffVerification {
+    check: string;
+    status: VerificationStatus;
+    exit_code?: number | null;
+    summary: string;
+}
+export interface Handoff {
+    version: HandoffVersion;
+    profile: HandoffProfile;
+    ext?: Record<string, unknown>;
+    id: string;
+    created_at: string;
+    task: HandoffTask;
+    scope?: HandoffScope;
+    state: HandoffState;
+    sources?: HandoffSource[];
+    risks: HandoffRisk[];
+    verification: HandoffVerification[];
+}
+export type OperationManifestVersion = "0.1.0";
+export interface OperationManifest {
+    version: OperationManifestVersion;
+    task_id: string;
+    read: string[];
+    write: string[];
+    validation: string[];
+}
+export type SchemaKind = "handoff" | "operation-manifest";
+export type SchemaDiagnosticCode = `schema_${string}`;
+/** A structural validation diagnostic, intentionally separate from semantic lint. */
+export interface SchemaDiagnostic {
+    code: SchemaDiagnosticCode;
+    severity: "error";
+    pointer: string;
+    message: string;
+}
+export interface SchemaValidationSuccess<T> {
+    ok: true;
+    value: T;
+    diagnostics: [];
+}
+export interface SchemaValidationFailure {
+    ok: false;
+    value: unknown;
+    diagnostics: SchemaDiagnostic[];
+}
+export type SchemaValidationResult<T> = SchemaValidationSuccess<T> | SchemaValidationFailure;
+export type SemanticIssueCode = "H001" | "H002" | "H003" | "H004" | "H005" | "H006" | "H007" | "H008" | "H009" | "H010";
+export type ManifestDiagnosticCode = "H001_PATH_RELATIVE" | "H011_VALIDATION_MISSING" | "M002_SCOPE_NOT_ALLOWED" | "M003_SOURCE_NOT_DECLARED" | "M004_VERIFICATION_NOT_DECLARED" | "M005_CHANGED_PATH_NOT_WRITABLE" | "M007_CHANGED_PATHS_MISSING";
+export type DiagnosticCode = SemanticIssueCode | ManifestDiagnosticCode;
+export interface SemanticIssue {
+    code: SemanticIssueCode;
+    path: string;
+    message: string;
+}
+export type Severity = "error" | "warning" | "info";
+export interface Diagnostic {
+    code: DiagnosticCode;
+    severity: Severity;
+    pointer: string;
+    message: string;
+}
+export interface ManifestDiagnostic extends Diagnostic {
+    code: ManifestDiagnosticCode;
+    severity: "error" | "warning";
+}
+export interface LintOptions {
+    codes?: readonly SemanticIssueCode[];
+    severity?: Partial<Record<SemanticIssueCode, Severity>>;
+}
+export interface LintResult {
+    diagnostics: Diagnostic[];
+    counts: Record<Severity, number>;
+    ok: boolean;
+}
+/** A diagnostic after the CLI has associated it with an input document. */
+export interface CliDiagnostic {
+    file: string;
+    code: string;
+    severity: Severity;
+    pointer: string;
+    message: string;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/validate-manifest.d.ts

@@ -0,0 +1,3 @@
+import type { Handoff, ManifestDiagnostic, OperationManifest } from "./types.js";
+/** Compare one schema-valid handoff with one schema-valid operation manifest. */
+export declare function validateManifest(handoff: Handoff, manifest: OperationManifest, changedPaths: readonly string[] | undefined, changedPathsProvided: boolean): ManifestDiagnostic[];

package/dist/core/validate-manifest.js

@@ -0,0 +1,139 @@
+const pathUtils = await import(`./path.${import.meta.url.endsWith(".ts") ? "ts" : "js"}`);
+const MESSAGES = {
+    H001_PATH_RELATIVE: "Manifest path must be a valid repository-relative path.",
+    H011_VALIDATION_MISSING: "A required manifest validation has not passed.",
+    M002_SCOPE_NOT_ALLOWED: "Scope path is not declared in the operation manifest.",
+    M003_SOURCE_NOT_DECLARED: "Source path is not declared in the operation manifest.",
+    M004_VERIFICATION_NOT_DECLARED: "Verification check is not declared in the operation manifest.",
+    M005_CHANGED_PATH_NOT_WRITABLE: "Changed path is not writable according to the operation manifest.",
+    M007_CHANGED_PATHS_MISSING: "Changed paths were not provided.",
+};
+function normalizePath(path) {
+    try {
+        return pathUtils.normalizeRelativePath(path);
+    }
+    catch (error) {
+        if (error instanceof pathUtils.RelativePathError)
+            return undefined;
+        throw error;
+    }
+}
+function collectManifestPaths(paths, pointer, diagnostics) {
+    const normalizedPaths = new Set();
+    paths.forEach((path, index) => {
+        const normalized = normalizePath(path);
+        if (normalized === undefined) {
+            diagnostics.push({
+                code: "H001_PATH_RELATIVE",
+                severity: "error",
+                pointer: `/manifest/${pointer}/${index}`,
+                message: MESSAGES.H001_PATH_RELATIVE,
+            });
+        }
+        else {
+            normalizedPaths.add(normalized);
+        }
+    });
+    return normalizedPaths;
+}
+function comparePointers(left, right) {
+    const leftSegments = left.split("/");
+    const rightSegments = right.split("/");
+    const length = Math.min(leftSegments.length, rightSegments.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftSegment = leftSegments[index];
+        const rightSegment = rightSegments[index];
+        if (leftSegment === rightSegment)
+            continue;
+        if (/^\d+$/.test(leftSegment) && /^\d+$/.test(rightSegment)) {
+            return BigInt(leftSegment) < BigInt(rightSegment) ? -1 : 1;
+        }
+        return leftSegment < rightSegment ? -1 : 1;
+    }
+    return leftSegments.length - rightSegments.length;
+}
+function compareDiagnostics(left, right) {
+    const pointerOrder = comparePointers(left.pointer, right.pointer);
+    if (pointerOrder !== 0)
+        return pointerOrder;
+    return left.code < right.code ? -1 : left.code > right.code ? 1 : 0;
+}
+function addPathDiagnostics(diagnostics, paths, allowed, code, pointer) {
+    const reported = new Set();
+    paths.forEach((path, index) => {
+        const normalized = normalizePath(path);
+        if (normalized !== undefined && (allowed.has(normalized) || reported.has(normalized)))
+            return;
+        if (normalized !== undefined)
+            reported.add(normalized);
+        diagnostics.push({
+            code,
+            severity: "error",
+            pointer: pointer(index),
+            message: MESSAGES[code],
+        });
+    });
+}
+/** Compare one schema-valid handoff with one schema-valid operation manifest. */
+export function validateManifest(handoff, manifest, changedPaths, changedPathsProvided) {
+    const diagnostics = [];
+    const readable = collectManifestPaths(manifest.read, "read", diagnostics);
+    const writable = collectManifestPaths(manifest.write, "write", diagnostics);
+    const readableOrWritable = new Set([...readable, ...writable]);
+    const declaredValidation = new Set(manifest.validation);
+    if (handoff.scope !== undefined) {
+        addPathDiagnostics(diagnostics, handoff.scope.paths, readableOrWritable, "M002_SCOPE_NOT_ALLOWED", (index) => `/scope/paths/${index}`);
+    }
+    const reportedSources = new Set();
+    handoff.sources?.forEach((source, index) => {
+        const normalized = normalizePath(source.path);
+        if (normalized !== undefined &&
+            (readableOrWritable.has(normalized) || reportedSources.has(normalized)))
+            return;
+        if (normalized !== undefined)
+            reportedSources.add(normalized);
+        diagnostics.push({
+            code: "M003_SOURCE_NOT_DECLARED",
+            severity: "error",
+            pointer: `/sources/${index}/path`,
+            message: MESSAGES.M003_SOURCE_NOT_DECLARED,
+        });
+    });
+    const reportedChecks = new Set();
+    handoff.verification.forEach((verification, index) => {
+        if (declaredValidation.has(verification.check) || reportedChecks.has(verification.check))
+            return;
+        reportedChecks.add(verification.check);
+        diagnostics.push({
+            code: "M004_VERIFICATION_NOT_DECLARED",
+            severity: "error",
+            pointer: `/verification/${index}/check`,
+            message: MESSAGES.M004_VERIFICATION_NOT_DECLARED,
+        });
+    });
+    if (handoff.profile === "full") {
+        const passedChecks = new Set(handoff.verification
+            .filter(({ status }) => status === "pass")
+            .map(({ check }) => check));
+        if (manifest.validation.some((check) => !passedChecks.has(check))) {
+            diagnostics.push({
+                code: "H011_VALIDATION_MISSING",
+                severity: "error",
+                pointer: "/verification",
+                message: MESSAGES.H011_VALIDATION_MISSING,
+            });
+        }
+    }
+    if (changedPathsProvided) {
+        addPathDiagnostics(diagnostics, changedPaths ?? [], writable, "M005_CHANGED_PATH_NOT_WRITABLE", (index) => `/changedPaths/${index}`);
+    }
+    else {
+        diagnostics.push({
+            code: "M007_CHANGED_PATHS_MISSING",
+            severity: "warning",
+            pointer: "/changedPaths",
+            message: MESSAGES.M007_CHANGED_PATHS_MISSING,
+        });
+    }
+    return diagnostics.sort(compareDiagnostics);
+}

package/dist/core/validate-schema.d.ts

@@ -0,0 +1,5 @@
+import type { Handoff, OperationManifest, SchemaKind, SchemaValidationResult } from "./types.js";
+/** Validate structure only. The input object is returned unchanged and is never mutated. */
+export declare function validateSchema<T>(kind: SchemaKind, value: unknown): SchemaValidationResult<T>;
+export declare function validateHandoffSchema(value: unknown): SchemaValidationResult<Handoff>;
+export declare function validateOperationManifestSchema(value: unknown): SchemaValidationResult<OperationManifest>;