principles-disciple 1.8.0 → 1.8.2

package/dist/core/nocturnal-export.js

@@ -1,275 +0,0 @@
-/**
- * Nocturnal ORPO Export — Approved Dataset to Decision-Point JSONL
- * =================================================================
- *
- * PURPOSE: Export approved nocturnal samples as ORPO-formatted decision-point
- * training JSONL, strictly separated from legacy correction export.
- *
- * ARCHITECTURE:
- *   - Export output: .state/exports/orpo/{exportId}.jsonl
- *   - Export manifest: .state/exports/orpo/{exportId}-manifest.json
- *   - Legacy corrections: untouched, separate path
- *
- * ORPO FORMAT (each line):
- *   {
- *     sampleFingerprint: string,
- *     artifactId: string,
- *     sessionId: string,
- *     principleId: string,
- *     targetModelFamily: string,
- *     prompt: string,        // badDecision (the wrong choice)
- *     chosen: string,        // betterDecision (the right choice)
- *     rejected: string,       // badDecision (for ORPO)
- *     rationale: string,
- *     datasetMetadata: {
- *       sampleFingerprint: string,
- *       artifactPath: string,
- *       createdAt: string,
- *       exportedAt: string,
- *       exportId: string,
- *       datasetFingerprint: string
- *     }
- *   }
- *
- * EXPORT GATING (fail-closed):
- *   - reviewStatus === 'approved_for_training'
- *   - targetModelFamily matches requested target (or any if not specified)
- *   - Lineage fields complete (sampleFingerprint, artifactId, sessionId, principleId)
- *   - Source artifact file exists and is approved
- *
- * DESIGN CONSTRAINTS:
- *   - No trainer invocation
- *   - No automatic training
- *   - No checkpoint deploy
- *   - Export is read-only from dataset perspective
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { listDatasetRecords, readDatasetArtifact, } from './nocturnal-dataset.js';
-import { NocturnalPathResolver } from './nocturnal-paths.js';
-// ---------------------------------------------------------------------------
-// Dataset Fingerprint (for reproducibility)
-// ---------------------------------------------------------------------------
-/**
- * Compute a deterministic dataset fingerprint from a sorted list of sample fingerprints.
- * This allows reproducible exports — same dataset always produces same fingerprint.
- */
-function computeDatasetFingerprint(sampleFingerprints) {
-    const sorted = [...sampleFingerprints].sort();
-    const combined = sorted.join('|');
-    return crypto.createHash('sha256').update(combined, 'utf8').digest('hex');
-}
-// ---------------------------------------------------------------------------
-// Individual Sample Serialization
-// ---------------------------------------------------------------------------
-/**
- * Serialize a single dataset record + artifact to ORPO JSONL line.
- * Caller guarantees record.targetModelFamily is non-null.
- */
-function serializeORPOSample(record, artifact, exportId, datasetFingerprint) {
-    const now = new Date().toISOString();
-    return {
-        sampleFingerprint: record.sampleFingerprint,
-        artifactId: record.artifactId,
-        sessionId: record.sessionId,
-        principleId: record.principleId,
-        targetModelFamily: record.targetModelFamily, // validated non-null by caller
-        // For ORPO: prompt = badDecision, chosen = betterDecision, rejected = badDecision
-        // This teaches the model to prefer betterDecision over badDecision
-        prompt: artifact.badDecision,
-        chosen: artifact.betterDecision,
-        rejected: artifact.badDecision,
-        rationale: artifact.rationale,
-        datasetMetadata: {
-            sampleFingerprint: record.sampleFingerprint,
-            artifactPath: record.artifactPath,
-            createdAt: record.createdAt,
-            exportedAt: now,
-            exportId,
-            datasetFingerprint,
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Core Export Function
-// ---------------------------------------------------------------------------
-/**
- * Export approved nocturnal samples as ORPO decision-point JSONL.
- *
- * @param workspaceDir - Workspace directory
- * @param targetModelFamily - Specific model family to export, or undefined for all
- * @param options - Additional export options
- * @returns ExportResult
- */
-export function exportORPOSamples(workspaceDir, targetModelFamily, _options = {}) {
-    const exportId = crypto.randomUUID();
-    const now = new Date().toISOString();
-    // Step 1: Collect eligible records
-    // Use listDatasetRecords directly to have full control over the family filter
-    // (listExportReadyRecords uses ?? which maps null→undefined, losing the null distinction)
-    const allApprovedRecords = listDatasetRecords(workspaceDir, {
-        reviewStatus: 'approved_for_training',
-    });
-    let eligibleRecords;
-    if (targetModelFamily !== undefined && targetModelFamily !== null) {
-        // Specific family: check if ANY records (regardless of status) have this family
-        const allRecords = listDatasetRecords(workspaceDir);
-        const hasAnyWithFamily = allRecords.some((r) => r.targetModelFamily === targetModelFamily);
-        if (!hasAnyWithFamily) {
-            // Family doesn't exist in any record
-            return {
-                success: false,
-                error: 'No samples found for the requested target model family',
-                emptyReason: 'family_mismatch',
-            };
-        }
-        // Family exists but none are approved
-        eligibleRecords = allApprovedRecords.filter((r) => r.targetModelFamily === targetModelFamily);
-    }
-    else {
-        // All families
-        eligibleRecords = allApprovedRecords;
-    }
-    // Step 2: Validate we have records
-    if (eligibleRecords.length === 0) {
-        return {
-            success: false,
-            error: 'No approved samples found for export',
-            emptyReason: 'no_approved_samples',
-        };
-    }
-    // Step 3: Verify lineage completeness and read artifacts
-    const orpoSamples = [];
-    const failedFingerprints = [];
-    for (const record of eligibleRecords) {
-        // Enforce targetModelFamily binding — samples without a family cannot enter training
-        if (record.targetModelFamily === null) {
-            failedFingerprints.push(record.sampleFingerprint);
-            continue;
-        }
-        // Verify lineage completeness
-        if (!record.sampleFingerprint || !record.artifactId || !record.sessionId || !record.principleId) {
-            failedFingerprints.push(record.sampleFingerprint);
-            continue;
-        }
-        // Read artifact (throws on error — distinguishes read failure from missing artifact)
-        let artifact;
-        try {
-            artifact = readDatasetArtifact(workspaceDir, record.sampleFingerprint);
-        }
-        catch {
-            failedFingerprints.push(record.sampleFingerprint);
-            continue;
-        }
-        // Serialize
-        orpoSamples.push(serializeORPOSample(record, artifact, exportId, ''));
-    }
-    // Step 4: Fail if all samples failed validation
-    if (orpoSamples.length === 0) {
-        return {
-            success: false,
-            error: `All ${eligibleRecords.length} eligible samples failed validation (missing artifacts or lineage)`,
-            emptyReason: 'all_samples_missing_artifacts',
-        };
-    }
-    // Step 5: Compute dataset fingerprint for manifest
-    const datasetFingerprint = computeDatasetFingerprint(orpoSamples.map((s) => s.sampleFingerprint));
-    // Step 6: Fill in dataset fingerprint in all samples
-    for (const sample of orpoSamples) {
-        sample.datasetMetadata.datasetFingerprint = datasetFingerprint;
-    }
-    // Step 7: Write JSONL file
-    const exportsDir = NocturnalPathResolver.exportsDir(workspaceDir);
-    const jsonlPath = path.join(exportsDir, `${exportId}.jsonl`);
-    const lines = orpoSamples.map((s) => JSON.stringify(s)).join('\n') + '\n';
-    fs.writeFileSync(jsonlPath, lines, 'utf-8');
-    // Step 8: Write manifest
-    const manifest = {
-        exportId,
-        createdAt: now,
-        sampleCount: orpoSamples.length,
-        targetModelFamily: targetModelFamily ?? 'all',
-        datasetFingerprint,
-        exportPath: jsonlPath,
-        manifestPath: path.join(exportsDir, `${exportId}-manifest.json`),
-        samples: orpoSamples.map((s) => ({
-            sampleFingerprint: s.sampleFingerprint,
-            artifactId: s.artifactId,
-            sessionId: s.sessionId,
-            principleId: s.principleId,
-        })),
-    };
-    fs.writeFileSync(manifest.manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
-    return {
-        success: true,
-        manifest,
-    };
-}
-/**
- * Verify an existing export by re-computing its dataset fingerprint.
- * Returns true if the export is intact and reproducible.
- */
-export function verifyExportIntegrity(workspaceDir, exportId) {
-    const exportsDir = NocturnalPathResolver.exportsDir(workspaceDir);
-    const manifestPath = path.join(exportsDir, `${exportId}-manifest.json`);
-    if (!fs.existsSync(manifestPath)) {
-        return null;
-    }
-    try {
-        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-        const computedFingerprint = computeDatasetFingerprint(manifest.samples.map((s) => s.sampleFingerprint));
-        return {
-            valid: computedFingerprint === manifest.datasetFingerprint,
-            computedFingerprint,
-            manifestFingerprint: manifest.datasetFingerprint,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * List all exports in the exports directory.
- */
-export function listExports(workspaceDir) {
-    const exportsDir = NocturnalPathResolver.exportsDir(workspaceDir);
-    if (!fs.existsSync(exportsDir)) {
-        return [];
-    }
-    try {
-        const files = fs.readdirSync(exportsDir);
-        const manifests = [];
-        for (const file of files) {
-            if (!file.endsWith('-manifest.json'))
-                continue;
-            try {
-                const manifest = JSON.parse(fs.readFileSync(path.join(exportsDir, file), 'utf-8'));
-                manifests.push(manifest);
-            }
-            catch {
-                // Skip malformed manifest
-            }
-        }
-        return manifests.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Read an export manifest by ID.
- */
-export function getExportManifest(workspaceDir, exportId) {
-    const exportsDir = NocturnalPathResolver.exportsDir(workspaceDir);
-    const manifestPath = path.join(exportsDir, `${exportId}-manifest.json`);
-    if (!fs.existsSync(manifestPath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}

package/dist/core/nocturnal-paths.d.ts

@@ -1,124 +0,0 @@
-/**
- * Nocturnal Paths — Canonical Path Registry for Sleep-Mode Reflection Artifacts
- * =============================================================================
- *
- * PURPOSE: Establishes a single source of truth for all nocturnal artifact paths.
- * Prevents path fragmentation and ensures consistent resolution across modules.
- *
- * ARCHITECTURE:
- *   Operator-facing  (read by agent, injected into prompts):
- *     memory/reflection-log.md       ← human-readable lessons, NOT training data
- *
- *   Nocturnal artifacts (structured, NOT injected into prompts):
- *     .state/nocturnal/samples/     ← decision-point JSON artifacts (Phase 2+)
- *     .state/nocturnal/memory/      ← short-term reflection memory (Phase 2+)
- *     .state/exports/orpo/          ← approved training pairs, immutable (Phase 3+)
- *
- * DESIGN CONSTRAINTS:
- * - Nocturnal samples are NEVER written to memory/reflection-log.md
- * - Prompt injection reads ONLY from memory/reflection-log.md
- * - Each nocturnal artifact category has its own subdirectory
- * - All paths go through this registry — no ad-hoc path construction
- *
- * USAGE:
- *   import { NocturnalPathResolver, NOCTURNAL_DIRS, NOCTURNAL_FILES } from './nocturnal-paths.js';
- *   const sampleDir = NocturnalPathResolver.samplesDir(workspaceDir);
- */
-export declare const NOCTURNAL_DIRS: {
-    /** Root directory for all nocturnal reflection artifacts */
-    readonly ROOT: ".state/nocturnal";
-    /**
-     * Structured decision-point samples from nocturnal reflection.
-     * Each file is a JSON artifact containing:
-     *   - session snapshot reference
-     *   - target principle
-     *   - decision-point contrastive pair
-     *   - arbiter approval status
-     */
-    readonly SAMPLES: ".state/nocturnal/samples";
-    /**
-     * Short-term operator-facing reflection memory.
-     * Written by nocturnal service, NOT injected into prompts directly.
-     * Consumed by operator on next session start.
-     */
-    readonly MEMORY: ".state/nocturnal/memory";
-    /**
-     * Nocturnal runtime bookkeeping (cooldowns, quotas).
-     * NOTE: nocturnal-runtime.json is written to stateDir directly
-     * (not under NOCTURNAL_DIRS.ROOT) for simpler migration.
-     */
-    /**
-     * Approved training pairs ready for export.
-     * Immutable once written — never modified in place.
-     * Consumed by external trainer (not the plugin).
-     */
-    readonly EXPORTS: ".state/exports/orpo";
-};
-export declare const NOCTURNAL_FILES: {
-    /**
-     * Arbiter review queue for pending samples.
-     * Not written by nocturnal service directly — created during arbiter review.
-     * Format: JSON array of sample refs pending approval.
-     */
-    readonly REVIEW_QUEUE: ".state/nocturnal/review-queue.json";
-    /**
-     * Lineage metadata for all samples.
-     * Written alongside each sample file for traceability.
-     */
-    readonly LINEAGE_INDEX: ".state/nocturnal/samples/lineage-index.json";
-};
-/**
- * Resolves a nocturnal directory path within a workspace.
- */
-export declare function resolveNocturnalDir(workspaceDir: string, dirKey: keyof typeof NOCTURNAL_DIRS): string;
-/**
- * Resolves a nocturnal file path within a workspace.
- */
-export declare function resolveNocturnalFile(workspaceDir: string, fileKey: keyof typeof NOCTURNAL_FILES): string;
-export declare const NocturnalPathResolver: {
-    /**
-     * Returns the samples directory path.
-     * Creates the directory if it does not exist.
-     */
-    readonly samplesDir: (workspaceDir: string) => string;
-    /**
-     * Returns the memory directory path.
-     * Creates the directory if it does not exist.
-     */
-    readonly memoryDir: (workspaceDir: string) => string;
-    /**
-     * Returns the exports directory path.
-     * Creates the directory if it does not exist.
-     */
-    readonly exportsDir: (workspaceDir: string) => string;
-    /**
-     * Returns the path for a named sample file.
-     * File is NOT created — caller decides when to write.
-     */
-    readonly samplePath: (workspaceDir: string, sampleId: string) => string;
-    /**
-     * Returns the path for nocturnal reflection memory.
-     * This is the operator-facing summary written after each nocturnal run.
-     */
-    readonly reflectionMemoryPath: (workspaceDir: string) => string;
-    /**
-     * Lists all sample files in the samples directory.
-     * Returns absolute paths sorted by modification time (newest first).
-     */
-    readonly listSamples: (workspaceDir: string) => string[];
-    /**
-     * Lists all approved sample files ready for export.
-     * Filters to samples with status === 'approved'.
-     */
-    readonly listApprovedSamples: (workspaceDir: string) => string[];
-};
-/**
- * Complete path map for reference.
- * These mirror the keys in NOCTURNAL_DIRS and NOCTURNAL_FILES.
- */
-export declare const NOCTURNAL_PATH_DESCRIPTIONS: Record<string, string>;
-/**
- * IMPORTANT: memory/reflection-log.md is NOT a nocturnal artifact.
- * It is the pre-existing operator-facing reflection log, defined in paths.ts.
- * It is kept separate from nocturnal outputs by design.
- */

package/dist/core/nocturnal-trajectory-extractor.d.ts

@@ -1,242 +0,0 @@
-/**
- * Nocturnal Trajectory Extractor — Structured Session Snapshot API
- * ==============================================================
- *
- * PURPOSE: Provide minimal necessary structured trajectory extraction
- * for the nocturnal reflection pipeline. NOT a general-purpose data mirror.
- *
- * DESIGN PRINCIPLES:
- * - Uses sanitized text ONLY — never raw_text or blob payloads
- * - Two distinct query paths:
- *     1. Analytics query (listRecentNocturnalCandidateSessions) — for target selection
- *     2. Runtime query (getNocturnalSessionSnapshot) — for sample generation
- * - All snapshots are self-contained and principle-relevant metadata-rich
- *
- * WHAT THIS MODULE DOES:
- * - List recent sessions with metadata relevant to nocturnal target selection
- * - Extract structured session snapshots for a selected violating session
- *
- * WHAT THIS MODULE DOES NOT DO:
- * - NO snapshot database cloning
- * - NO full trajectory export
- * - NO raw text exposure
- * - NO target selection logic
- * - NO sample generation
- *
- * ARTIFACT OUTPUTS go to:
- *   .state/nocturnal/samples/    ← structured JSON artifacts
- *
- * FILE: {stateDir}/nocturnal/snapshots/  (cached snapshots if needed, optional)
- */
-import { TrajectoryDatabase } from './trajectory.js';
-/**
- * Minimal sanitized assistant turn for nocturnal snapshot.
- * Contains ONLY sanitizedText — raw_text is never exposed.
- */
-export interface NocturnalAssistantTurn {
-    turnIndex: number;
-    sanitizedText: string;
-    model: string;
-    createdAt: string;
-}
-/**
- * Minimal sanitized user turn for nocturnal snapshot.
- * Contains only derived cues — NO raw user text.
- */
-export interface NocturnalUserTurn {
-    turnIndex: number;
-    correctionDetected: boolean;
-    correctionCue: string | null;
-    createdAt: string;
-}
-/**
- * Tool call event for nocturnal snapshot.
- */
-export interface NocturnalToolCall {
-    toolName: string;
-    outcome: 'success' | 'failure' | 'blocked';
-    filePath: string | null;
-    durationMs: number | null;
-    exitCode: number | null;
-    errorType: string | null;
-    errorMessage: string | null;
-    createdAt: string;
-}
-/**
- * Pain signal for nocturnal snapshot.
- */
-export interface NocturnalPainEvent {
-    source: string;
-    score: number;
-    severity: string | null;
-    reason: string | null;
-    createdAt: string;
-}
-/**
- * Gate block event for nocturnal snapshot.
- */
-export interface NocturnalGateBlock {
-    toolName: string;
-    filePath: string | null;
-    reason: string;
-    planStatus: string | null;
-    createdAt: string;
-}
-/**
- * A structured nocturnal session snapshot.
- * Contains all information needed for a reflector to generate decision-point samples.
- *
- * GUARANTEES:
- * - NO raw_text exposed
- * - NO blob references resolved
- * - All text is sanitized or derived-cue only
- * - Self-contained (principle-relevant metadata included)
- */
-export interface NocturnalSessionSnapshot {
-    sessionId: string;
-    startedAt: string;
-    updatedAt: string;
-    assistantTurns: NocturnalAssistantTurn[];
-    userTurns: NocturnalUserTurn[];
-    toolCalls: NocturnalToolCall[];
-    painEvents: NocturnalPainEvent[];
-    gateBlocks: NocturnalGateBlock[];
-    /**
-     * Summary statistics for quick triage.
-     */
-    stats: {
-        totalAssistantTurns: number;
-        totalToolCalls: number;
-        totalPainEvents: number;
-        totalGateBlocks: number;
-        failureCount: number;
-    };
-}
-/**
- * Summary entry for session listing (used by nocturnal target selector).
- * Lightweight — only identification and basic metadata, no turns.
- */
-export interface NocturnalSessionSummary {
-    sessionId: string;
-    startedAt: string;
-    updatedAt: string;
-    /** Number of assistant turns (for relevance scoring) */
-    assistantTurnCount: number;
-    /** Number of tool calls (for violation signal density) */
-    toolCallCount: number;
-    /** Number of pain events (for pain signal density) */
-    painEventCount: number;
-    /** Number of gate blocks (for constraint violation evidence) */
-    gateBlockCount: number;
-    /** Number of failed tool calls (for violation signal) */
-    failureCount: number;
-}
-/**
- * Options for listing recent nocturnal candidate sessions.
- */
-export interface ListNocturnalSessionsOptions {
-    /** Maximum number of sessions to return (default: 20) */
-    limit?: number;
-    /** Only return sessions updated after this date */
-    dateFrom?: string;
-    /** Only return sessions updated before this date */
-    dateTo?: string;
-    /** Minimum tool call count threshold (default: 1) */
-    minToolCalls?: number;
-}
-/**
- * Nocturnal Trajectory Extractor.
- *
- * Provides sanitized, structured access to session data for the nocturnal
- * reflection pipeline. All queries return sanitized text only.
- *
- * This class is a thin, focused wrapper around TrajectoryDatabase.
- * It does NOT cache snapshots or maintain its own state.
- */
-export declare class NocturnalTrajectoryExtractor {
-    private readonly trajectory;
-    constructor(trajectory: TrajectoryDatabase);
-    /**
-     * List recent sessions suitable for nocturnal target selection.
-     *
-     * ANALYTICS QUERY — used by nocturnal target selector to find candidate sessions.
-     *
-     * @param options - Query options
-     * @returns Lightweight session summaries ordered by most recently updated
-     */
-    listRecentNocturnalCandidateSessions(options?: ListNocturnalSessionsOptions): NocturnalSessionSummary[];
-    /**
-     * Get a full structured snapshot for a specific session.
-     *
-     * RUNTIME QUERY — used by nocturnal service after target selection.
-     *
-     * SECURITY GUARANTEES:
-     * - Only sanitizedText from assistant turns (never raw_text)
-     * - Only correction cues from user turns (never raw user text)
-     * - Tool calls with outcome and error info (no raw parameters)
-     * - Pain events with score and reason (no raw event data)
-     * - Gate blocks with tool/reason info (no file content)
-     *
-     * @param sessionId - Session ID to snapshot
-     * @returns Full structured snapshot, or null if session not found
-     */
-    getNocturnalSessionSnapshot(sessionId: string): NocturnalSessionSnapshot | null;
-}
-/**
- * Creates a NocturnalTrajectoryExtractor from a workspace directory.
- *
- * USAGE:
- *   const extractor = createNocturnalTrajectoryExtractor(workspaceDir);
- *   const sessions = extractor.listRecentNocturnalCandidateSessions({ limit: 10 });
- *   const snapshot = extractor.getNocturnalSessionSnapshot(sessionId);
- */
-export declare function createNocturnalTrajectoryExtractor(workspaceDir: string, _stateDir?: string): NocturnalTrajectoryExtractor;
-/**
- * List recent sessions for nocturnal target selection.
- * Convenience wrapper around NocturnalTrajectoryExtractor.
- */
-export declare function listNocturnalCandidateSessions(trajectory: TrajectoryDatabase, options?: ListNocturnalSessionsOptions): NocturnalSessionSummary[];
-/**
- * Get a session snapshot for nocturnal reflection.
- * Convenience wrapper around NocturnalTrajectoryExtractor.
- */
-export declare function getNocturnalSessionSnapshot(trajectory: TrajectoryDatabase, sessionId: string): NocturnalSessionSnapshot | null;
-/**
- * Compute thinking model activation for a text.
- * Returns 0-1 ratio of matched thinking models to total available models.
- *
- * @param text - Text to analyze
- * @returns Activation ratio (0-1)
- */
-export declare function computeThinkingModelActivation(text: string): number;
-/**
- * Compute planning ratio from a session snapshot.
- * Planning ratio = write operations preceded immediately by a read tool / total write operations.
- * A higher ratio indicates more careful planning behavior (reading before writing).
- *
- * Only the immediately preceding tool is checked — each write needs its own
- * preceding read to count as planned. This prevents a single read from satisfying
- * multiple writes in sequence.
- *
- * @param snapshot - Session snapshot to analyze
- * @returns Planning ratio (0-1), or 0 if no write operations
- */
-export declare function computePlanningRatio(snapshot: NocturnalSessionSnapshot): number;
-/**
- * Compute thinking model delta between original and improved decisions.
- * Positive delta means the improved decision uses more thinking models.
- *
- * @param originalText - Original (bad) decision text
- * @param improvedText - Improved (better) decision text
- * @returns Delta in thinking model activation (-1 to 1)
- */
-export declare function computeThinkingModelDelta(originalText: string, improvedText: string): number;
-/**
- * Compute planning ratio gain between original and improved snapshots.
- * Positive gain means the improved behavior has better planning (more reads before writes).
- *
- * @param originalSnapshot - Original session snapshot
- * @param improvedSnapshot - Improved session snapshot
- * @returns Planning ratio gain (-1 to 1)
- */
-export declare function computePlanningRatioGain(originalSnapshot: NocturnalSessionSnapshot, improvedSnapshot: NocturnalSessionSnapshot): number;