omnius 1.0.922 → 1.0.924

package/dist/_types/execution/mcp/types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * mcp/types.ts — MCP Protocol Types (JSON-RPC 2.0)
+ *
+ * Implements the Model Context Protocol specification (MCP 2025-06-18)
+ * without requiring the @modelcontextprotocol/sdk dependency.
+ *
+ * Protocol reference: https://modelcontextprotocol.io/specification/2025-06-18/
+ * Hannover reference: src/services/mcp/types.ts
+ */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface McpStdioConfig {
+    type?: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface McpHttpConfig {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerConfig = McpStdioConfig | McpHttpConfig;
+export interface McpConfig {
+    mcpServers: Record<string, McpServerConfig>;
+}
+export interface McpToolDefinition {
+    name: string;
+    /** Human-readable display name (spec 2025-06-18) */
+    title?: string;
+    description?: string;
+    inputSchema: {
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+    /** Optional output schema for structuredContent validation */
+    outputSchema?: {
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+    annotations?: {
+        title?: string;
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        openWorldHint?: boolean;
+    };
+    _meta?: Record<string, unknown>;
+}
+export interface McpResource {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface McpPrompt {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+export interface McpAnnotations {
+    audience?: ("user" | "assistant")[];
+    priority?: number;
+    lastModified?: string;
+}
+export interface McpTextContent {
+    type: "text";
+    text: string;
+    annotations?: McpAnnotations;
+}
+export interface McpImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+    annotations?: McpAnnotations;
+}
+export interface McpAudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: McpAnnotations;
+}
+export interface McpResourceLinkContent {
+    type: "resource_link";
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: McpAnnotations;
+}
+export interface McpEmbeddedResource {
+    type: "resource";
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+        annotations?: McpAnnotations;
+    };
+}
+export type McpContent = McpTextContent | McpImageContent | McpAudioContent | McpResourceLinkContent | McpEmbeddedResource;
+export interface McpToolCallResult {
+    content: McpContent[];
+    /** Spec 2025-06-18: structured JSON output (for tools with outputSchema) */
+    structuredContent?: unknown;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+export interface McpServerCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+}
+export interface McpServerInfo {
+    name: string;
+    version: string;
+}
+export interface McpInitializeResult {
+    protocolVersion: string;
+    capabilities: McpServerCapabilities;
+    serverInfo: McpServerInfo;
+    instructions?: string;
+}
+export type McpConnectionStatus = "connected" | "failed" | "pending" | "disconnected";
+export interface McpConnection {
+    name: string;
+    status: McpConnectionStatus;
+    config: McpServerConfig;
+    capabilities?: McpServerCapabilities;
+    serverInfo?: McpServerInfo;
+    instructions?: string;
+    tools: McpToolDefinition[];
+    resources: McpResource[];
+    error?: string;
+}

package/dist/_types/execution/mutation-contract.d.ts

@@ -0,0 +1,102 @@
+export type MutationAgentRole = "explorer" | "mutation_worker" | "coordinator" | "proposal";
+export type MutationLeaseState = "active" | "proposal_only" | "pending_merge" | "merged" | "released";
+export interface MutationWorkerContract {
+    role: MutationAgentRole;
+    ownerAgentId: string;
+    taskId?: string;
+    ownedFiles: string[];
+    ownedDirs: string[];
+    forbiddenFiles: string[];
+    forbiddenDirs: string[];
+    expectedArtifacts: string[];
+    verifierCommand?: string;
+    expectedOutputArtifact?: string;
+    mergeStrategy?: string;
+    stopCondition?: string;
+    artifactKeys: string[];
+    leaseState: MutationLeaseState;
+    baseHash?: string;
+    expiresAt?: string;
+    worktreePath?: string;
+    proposalMode: boolean;
+}
+export interface MutationContractValidation {
+    valid: boolean;
+    errors: string[];
+}
+export interface MutationScopeCheck {
+    allowed: boolean;
+    reason?: string;
+    offendingPath?: string;
+    reasonClass?: "mutation_scope_conflict" | "proposal_mode_required";
+}
+export interface ShellMutationPathExtraction {
+    mutates: boolean;
+    paths: string[];
+    unknownMutation: boolean;
+    reason?: string;
+}
+/**
+ * A shell command can syntactically contain a write while leaving no durable
+ * project delta (for example `cat > test/probe.mjs; node test/probe.mjs; rm
+ * test/probe.mjs`).  Safety checks need the attempted write; controller state
+ * needs the observed post-command truth.  Keep those facts separate.
+ */
+export interface ShellMutationObservation {
+    attempted: boolean;
+    attemptedPaths: string[];
+    effectivePaths: string[];
+    transientPaths: string[];
+    unknownPaths: string[];
+    basis: "path_fingerprint" | "unavailable";
+}
+/**
+ * Reduce a static shell-write extraction and pre/post path fingerprints into
+ * durable mutation truth. `missing` is an explicit state, not an absent
+ * sample, so a create-and-remove probe is distinguishable from an unreadable
+ * path.  Callers may use content hashes for files and stat signatures for
+ * directories.
+ */
+export declare function observeShellMutation(extraction: ShellMutationPathExtraction, before: ReadonlyMap<string, string | undefined>, after: ReadonlyMap<string, string | undefined>): ShellMutationObservation;
+export interface DelegationMutationScopeDerivation {
+    args: Record<string, unknown>;
+    changed: boolean;
+    mutationLikely: boolean;
+    proposalOnly: boolean;
+    ownedFiles: string[];
+    ownedDirs: string[];
+    reason?: string;
+}
+export declare function normalizeMutationPath(root: string, pathValue: string): string;
+export declare function parseMutationWorkerContract(args: Record<string, unknown>, options?: {
+    workingDir?: string;
+    ownerAgentId?: string;
+    subagentType?: string;
+    defaultProposalMode?: boolean;
+}): MutationWorkerContract;
+export declare function validateMutationWorkerContract(contract: MutationWorkerContract): MutationContractValidation;
+export declare function mutationScopesOverlap(left: Pick<MutationWorkerContract, "ownedFiles" | "ownedDirs">, right: Pick<MutationWorkerContract, "ownedFiles" | "ownedDirs">): boolean;
+export declare function coordinatorOwnedArtifactReason(pathValue: string): string | null;
+export declare function checkMutationScope(contract: MutationWorkerContract | null | undefined, paths: string[], options?: {
+    workingDir?: string;
+    proposalMode?: boolean;
+}): MutationScopeCheck;
+export declare function checkShellMutationScope(contract: MutationWorkerContract | null | undefined, command: string, options?: {
+    workingDir?: string;
+    proposalMode?: boolean;
+}): MutationScopeCheck & {
+    extraction: ShellMutationPathExtraction;
+};
+export declare function mutationContractToEnv(contract: MutationWorkerContract): Record<string, string>;
+export declare function mutationContractFromEnv(env?: NodeJS.ProcessEnv, workingDir?: string): MutationWorkerContract | null;
+export declare function deriveDelegationMutationScope(args: Record<string, unknown>, options?: {
+    workingDir?: string;
+    defaultVerifierCommand?: string | null;
+    enabled?: boolean;
+}): DelegationMutationScopeDerivation;
+export declare function renderMutationContractForPrompt(contract: MutationWorkerContract): string;
+export declare function detectWorkspaceDestructiveCommand(command: string, workspaceRoot?: string): string | null;
+export declare function extractShellMutationPaths(command: string, options?: {
+    workingDir?: string;
+}): ShellMutationPathExtraction;
+export declare function isShellCommandLikelyMutatingFilesystem(command: string): boolean;

package/dist/_types/execution/nol/artifacts.d.ts

@@ -0,0 +1,39 @@
+import { type NolArtifactRef } from "../../schemas/nol.js";
+export declare const nolJsonDigest: (value: unknown) => string;
+/** Canonical tagged-record identity. A model's friendly ID is excluded; every
+ * other identity-bearing field remains. Its tensor map has a separate digest. */
+export declare function nolRecordDigest(value: unknown): string;
+export declare function assertNolRecordDigest(value: unknown): void;
+/** Explicit construction helper; parsing/verification never rewrites identity. */
+export declare function sealNolRecord<T extends {
+    schema: string;
+}>(value: T): T;
+/** Complete-file digest; no sampled prefix, implicit model loading or inference. */
+export declare function nolFileDigest(path: string, signal?: AbortSignal): Promise<{
+    sha256: string;
+    sizeBytes: number;
+}>;
+/** Private, atomically published content-addressed artifacts. Every read rehashes.
+ * Aggregate experiment storage admission belongs to the coordinator/store. */
+export declare class NolArtifactStore {
+    readonly root: string;
+    readonly maxArtifactBytes: number;
+    constructor(options: {
+        root: string;
+        maxArtifactBytes: number;
+    });
+    private pathFor;
+    private directory;
+    private publish;
+    putBytes(bytes: Uint8Array, mediaType?: string, signal?: AbortSignal): Promise<NolArtifactRef>;
+    putJson(value: unknown, signal?: AbortSignal): Promise<NolArtifactRef>;
+    importFile(path: string, mediaType?: string, options?: {
+        expectedSha256?: string;
+        maxBytes?: number;
+        signal?: AbortSignal;
+    }): Promise<NolArtifactRef>;
+    private readVerified;
+    verify(ref: NolArtifactRef, signal?: AbortSignal): Promise<void>;
+    readBytes(ref: NolArtifactRef, signal?: AbortSignal): Promise<Buffer>;
+    readJson(ref: NolArtifactRef, signal?: AbortSignal): Promise<unknown>;
+}

package/dist/_types/execution/nol/checkpoint-edits.d.ts

@@ -0,0 +1,98 @@
+import { type NolArtifactRef, type NolModelManifest, type NolRecipeRevision } from "../../schemas/nol.js";
+export interface NolCheckpointEditLimits {
+    maxInputBytes: number;
+    /** Aggregate unique operand artifact bytes. */
+    maxArtifactBytes: number;
+    /** Entire exported directory, including its provenance receipt. */
+    maxOutputBytes: number;
+    /** Conservative cumulative tensor-payload/explicit workspace reservation.
+     * Python/Torch runtime objects, allocator/BLAS overhead and baseline process
+     * RSS are outside this limit; it is not a process address-space guarantee. */
+    maxWorkingBytes: number;
+    maxArithmeticUnits: number;
+    maxOperations: number;
+    maxDurationMs: number;
+    maxProtocolBytes: number;
+}
+export interface NolCheckpointEditReceipt {
+    schema: "omnius.nol.checkpoint-edit.v1";
+    exportId: string;
+    parentModelDigest: string;
+    recipeDigest: string;
+    sourceModelDigests: string[];
+    editorSha256: string;
+    runtime: {
+        python: string;
+        torch: string;
+        safetensors: string;
+    };
+    numericalPolicy: string;
+    inferencePerformed: false;
+    cudaUsed: false;
+    files: Array<{
+        path: string;
+        before: {
+            sha256: string;
+            sizeBytes: number;
+        };
+        after: {
+            sha256: string;
+            sizeBytes: number;
+        };
+        changed: boolean;
+        representation: "copied_exact_file" | "safetensors_preserved_untouched_tensor_bytes" | "pytorch_reencoded_verified_tensor_bytes";
+    }>;
+    operations: Array<{
+        operationId: string;
+        operation: string;
+        siteId: string;
+        name: string;
+        beforeTensorSha256: string;
+        afterTensorSha256: string;
+        changedElements: number;
+        /** Difference between this worker's float64 result and its stored dtype
+         * round trip; excludes operand decoding and native BLAS summation error.
+         * This is not a bound against exact real arithmetic or inference behavior. */
+        maxAbsRoundingError: number;
+    }>;
+    usage: {
+        inputBytes: number;
+        artifactBytes: number;
+        outputBytes: number;
+        reservedWorkingBytes: number;
+        arithmeticUnits: number;
+        durationMs: number;
+    };
+}
+export interface NolCheckpointEditInput {
+    pythonPath: string;
+    editorPath?: string;
+    expectedEditorSha256: string;
+    model: NolModelManifest;
+    recipe: NolRecipeRevision;
+    checkpointRoot: string;
+    sourceCheckpoints?: ReadonlyArray<{
+        model: NolModelManifest;
+        root: string;
+    }>;
+    artifactRoot: string;
+    outputDirectory: string;
+    limits: NolCheckpointEditLimits;
+    orthogonalityTolerance: number;
+    signal?: AbortSignal;
+}
+/** Explicit, CPU-only persistent parameter edit. Importing this module does no
+ * I/O and never imports Torch, allocates CUDA or instantiates a model. The final
+ * publish uses Linux renameat2(RENAME_NOREPLACE), with no overwrite fallback.
+ * Cancellation is observed until the atomic commit; a verified committed export
+ * is returned successfully if cancellation arrives after that commit point.
+ * Returned artifact references identify verified LOCAL export files; callers
+ * must import those files into their quota-managed CAS before runtime use or
+ * registration. This function does not register, promote or deploy a model. */
+export declare function editNolCheckpoint(input: NolCheckpointEditInput): Promise<{
+    outputDirectory: string;
+    model: NolModelManifest;
+    receipt: NolCheckpointEditReceipt;
+    receiptArtifact: NolArtifactRef;
+    receiptPath: string;
+}>;

package/dist/_types/execution/nol/distributions.d.ts

@@ -0,0 +1,128 @@
+import { type NolArtifactRef, type NolRuntimeBinding } from "../../schemas/nol.js";
+import { type NolArtifactStore } from "./artifacts.js";
+declare const SCHEMA: "omnius.nol.conditional-distribution.v1";
+declare const RESULT: "omnius.nol.conditional-distribution-comparison.v1";
+export declare const NOL_RAW_DISTRIBUTION_PROCESSING_DIGEST: string;
+/** The native producer must establish these facts. Parsing/hashing this record
+ * establishes immutable metadata and artifact identity, never native authority. */
+export interface NolConditionalDistribution {
+    schema: typeof SCHEMA;
+    observationDigest: string;
+    coverage: "full_vocabulary";
+    values: "logits" | "log_probabilities" | "probabilities";
+    stage: "raw_model" | "processed_sampling";
+    processingDigest: string;
+    vocabularySize: number;
+    conditioning: {
+        mode: "teacher_forced";
+        attentionMask: "causal_unpadded";
+        tokenizerDigest: string;
+        vocabularyDigest: string;
+        chatTemplateDigest: string;
+        inputIds: NolArtifactRef;
+        positionIds: NolArtifactRef;
+        tokenEncoding: "u32_le";
+        inputTokenCount: number;
+        promptTokenCount: number;
+        /** Row r predicts the next token after exactly this many input IDs.
+         * Its native computation position is prefixTokenCounts[r] - 1. */
+        prefixTokenCounts: number[];
+    };
+    source: {
+        binding: NolRuntimeBinding;
+        variantDigest: string;
+        recipeDigest: string | null;
+        computeDtype: "float16" | "bfloat16" | "float32" | "float64";
+    };
+    tensor: {
+        artifact: NolArtifactRef;
+        shape: [
+            number,
+            number
+        ];
+        dtype: "f32" | "f64";
+        encoding: "ieee754_le";
+    };
+    receipts: {
+        source: NolArtifactRef;
+        native: NolArtifactRef;
+        hardware: NolArtifactRef;
+    };
+}
+export interface NolDistributionLimits {
+    maxRows: number;
+    maxVocabularySize: number;
+    maxReadBytes: number;
+    maxWorkingBytes: number;
+    /** Scalar visits, including each normalization and metric pass. */
+    maxWorkUnits: number;
+    maxDurationMs: number;
+    /** Allowed absolute row mass/log-mass error before explicit renormalization. */
+    normalizationTolerance: number;
+    maxAbsLogValue: number;
+}
+export type NolDistributionMeasure = {
+    status: "finite";
+    value: number;
+} | {
+    status: "positive_infinity";
+    reason: "candidate_zero_on_baseline_support";
+};
+export interface NolConditionalDistributionComparison {
+    schema: typeof RESULT;
+    comparisonDigest: string;
+    scope: "same_runtime_intervention";
+    direction: "baseline_to_candidate";
+    units: "nats";
+    normalization: "validated_then_float64_row_renormalization";
+    numericPolicy: {
+        arithmetic: "ieee754_float64";
+        probabilityUnderflow: "finite_log_support_preserved_small_mass_terms_rounded";
+        negativeRoundoffClamp: 1e-10;
+    };
+    acceptanceAuthority: "none";
+    nativeObservationAuthorityVerified: false;
+    baseline: NolConditionalDistribution;
+    candidate: NolConditionalDistribution;
+    conditioningDigest: string;
+    limits: NolDistributionLimits;
+    rows: Array<{
+        prefixTokenCount: number;
+        computationPosition: number;
+        positionId: number;
+        baselineEntropy: NolDistributionMeasure;
+        candidateEntropy: NolDistributionMeasure;
+        crossEntropy: NolDistributionMeasure;
+        kl: NolDistributionMeasure;
+        baselineSupportSize: number;
+        candidateSupportSize: number;
+    }>;
+    mean: {
+        baselineEntropy: NolDistributionMeasure;
+        candidateEntropy: NolDistributionMeasure;
+        crossEntropy: NolDistributionMeasure;
+        kl: NolDistributionMeasure;
+    };
+    accounting: {
+        verifiedArtifactBytes: number;
+        peakWorkingBytesBound: number;
+        scalarVisits: number;
+        rowsCompared: number;
+        completeVocabularyElementsPerRow: number;
+    };
+}
+export declare function sealNolConditionalDistribution(value: Omit<NolConditionalDistribution, "observationDigest">): NolConditionalDistribution;
+export declare function parseNolConditionalDistribution(value: unknown): NolConditionalDistribution;
+/** Compares complete conditional distributions on identical forced prefixes.
+ * Uses public rehashing CAS reads. All artifact bytes and worst-case collected
+ * buffers/row workspaces are admitted before I/O. Rows are evaluated in bounded
+ * incremental passes with cooperative cancellation; no tensor publication,
+ * native observation receipt or scientific acceptance authority is created. */
+export declare function compareNolConditionalDistributions(input: {
+    baseline: NolConditionalDistribution;
+    candidate: NolConditionalDistribution;
+    artifacts: Pick<NolArtifactStore, "readBytes" | "verify">;
+    limits: NolDistributionLimits;
+    signal?: AbortSignal;
+}): Promise<NolConditionalDistributionComparison>;
+export {};