martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/context-flow/redaction.js

@@ -0,0 +1,6 @@
+const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+const PHONE_RE = /(?:\+?\d{1,3}[ -]?)?(?:\(?\d{3}\)?[ -]?)?\d{3}[ -]?\d{4}/g;
+export function redactText(text) {
+    return text.replace(EMAIL_RE, "[REDACTED_EMAIL]").replace(PHONE_RE, "[REDACTED_PHONE]");
+}
+//# sourceMappingURL=redaction.js.map

package/dist/vendor/core/context-flow/sensitivity.d.ts

@@ -0,0 +1,2 @@
+import type { CanonicalRecord, SensitivityClassification } from "./types.js";
+export declare function classifySensitivity(record: CanonicalRecord): SensitivityClassification;

package/dist/vendor/core/context-flow/sensitivity.js

@@ -0,0 +1,27 @@
+const HIGH_RISK_RECORD_TYPES = new Set(["security_incident", "finance_change"]);
+export function classifySensitivity(record) {
+    const reasons = [];
+    const matchedEntityTypes = [...new Set(record.entities.map((entity) => entity.type))];
+    let level = "low";
+    if (HIGH_RISK_RECORD_TYPES.has(record.recordType)) {
+        level = "high";
+        reasons.push(`Sensitive record type "${record.recordType}" requires approval.`);
+    }
+    if (matchedEntityTypes.includes("money")) {
+        level = level === "high" ? "high" : "moderate";
+        reasons.push("Financial values were detected in the source record.");
+    }
+    if (matchedEntityTypes.includes("email")) {
+        level = level === "high" ? "high" : "moderate";
+        reasons.push("Direct contact data was detected in the source record.");
+    }
+    if (reasons.length === 0) {
+        reasons.push("No elevated sensitivity indicators were detected.");
+    }
+    return {
+        level,
+        reasons,
+        matchedEntityTypes
+    };
+}
+//# sourceMappingURL=sensitivity.js.map

package/dist/vendor/core/context-flow/sync-preview.d.ts

@@ -0,0 +1,2 @@
+import type { SyncPreviewInput, SyncPreviewResponse } from "./types.js";
+export declare function buildSyncPreview(input: SyncPreviewInput): SyncPreviewResponse;

package/dist/vendor/core/context-flow/sync-preview.js

@@ -0,0 +1,22 @@
+export function buildSyncPreview(input) {
+    const destination = input.destination ?? "martinloop";
+    const mode = input.mode ?? "upsert_account_brief";
+    const contextProfile = destination.toLowerCase().startsWith("martin") ? "martin360_agent_stage" : "generic_agent_small";
+    return {
+        destination,
+        mode,
+        payload: {
+            record_id: input.canonicalRecord.recordId,
+            record_type: input.canonicalRecord.recordType,
+            summary: input.canonicalRecord.summary,
+            fields: input.canonicalRecord.fields,
+            entities: input.canonicalRecord.entities,
+            context_profile: contextProfile
+        },
+        notes: [
+            `Preview builder only: live ${destination} execution depends on a host-wired adapter.`,
+            "This payload is the canonical contract consumed by the Martin360 writeback adapter."
+        ]
+    };
+}
+//# sourceMappingURL=sync-preview.js.map

package/dist/vendor/core/context-flow/token-estimator.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_COST_PER_1K_TOKENS = 0.003;
+export declare function estimateTokens(text: string): number;
+export declare function estimateCostUsd(text: string, costPer1kTokens?: number): number;

package/dist/vendor/core/context-flow/token-estimator.js

@@ -0,0 +1,13 @@
+export const DEFAULT_COST_PER_1K_TOKENS = 0.003;
+export function estimateTokens(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return 1;
+    }
+    return Math.max(1, normalized.split(/\s+/).length);
+}
+export function estimateCostUsd(text, costPer1kTokens = DEFAULT_COST_PER_1K_TOKENS) {
+    const tokens = estimateTokens(text);
+    return Number(((tokens / 1000) * costPer1kTokens).toFixed(6));
+}
+//# sourceMappingURL=token-estimator.js.map

package/dist/vendor/core/context-flow/types.d.ts

@@ -0,0 +1,91 @@
+import type { HeadlessProfileName } from "./profiles.js";
+export interface Tenant {
+    tenantId: string;
+    slug: string;
+    name: string;
+    createdAt: string;
+    metadata: Record<string, unknown>;
+}
+export type ApiKeyScope = "ingest" | "compile" | "policy" | "writeback" | "admin";
+export interface ApiKey {
+    apiKeyId: string;
+    tenantId: string;
+    label: string;
+    scopes: ApiKeyScope[];
+    createdAt: string;
+    expiresAt?: string;
+    rotatedAt?: string;
+    revokedAt?: string;
+}
+export interface ProvenanceItem {
+    sourceName: string;
+    evidence: string;
+    charStart?: number;
+    charEnd?: number;
+}
+export interface Entity {
+    type: string;
+    value: string;
+    confidence: number;
+}
+export interface CanonicalRecord {
+    recordId: string;
+    recordType: string;
+    summary: string;
+    fields: Record<string, string>;
+    entities: Entity[];
+    provenance: ProvenanceItem[];
+    metadata: Record<string, unknown>;
+}
+export interface CompileOptions {
+    redactPii: boolean;
+    includeProvenanceSnippets: boolean;
+    deltaMode: boolean;
+    maxTokensOverride?: number;
+}
+export interface QcReport {
+    completenessScore: number;
+    tokenEstimateBefore: number;
+    tokenEstimateAfter: number;
+    tokenReductionPct: number;
+    warnings: string[];
+    keptFields: string[];
+}
+export type PolicySeverity = "low" | "medium" | "high";
+export type PolicyMode = "auto" | "human_review" | "approval_required";
+export interface PolicyDecision {
+    profile: HeadlessProfileName;
+    allowAutonomy: boolean;
+    severity: PolicySeverity;
+    reasons: string[];
+    recommendedMode: PolicyMode;
+    requiresApproval: boolean;
+}
+export interface CompileTrace {
+    compileId: string;
+    policyDecision: PolicyDecision;
+}
+export interface ContextPack {
+    profile: HeadlessProfileName;
+    compiledContext: string;
+    qcReport: QcReport;
+    canonicalRecord: CanonicalRecord;
+    trace: CompileTrace;
+}
+export type SensitivityLevel = "low" | "moderate" | "high";
+export interface SensitivityClassification {
+    level: SensitivityLevel;
+    reasons: string[];
+    matchedEntityTypes: string[];
+}
+export interface SyncPreviewInput {
+    destination?: string;
+    canonicalRecord: CanonicalRecord;
+    mode?: string;
+}
+export interface SyncPreviewResponse {
+    destination: string;
+    mode: string;
+    payload: Record<string, unknown>;
+    notes: string[];
+}

package/dist/vendor/core/context-flow/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vendor/core/context-integrity.d.ts

@@ -0,0 +1,26 @@
+export type ContextIntegrityVerdict = "clean" | "context_poisoning_warning" | "context_poisoning_block";
+export interface ContextIntegrityPrecheck {
+    runId: string;
+    attemptIndex: number;
+    verdict: ContextIntegrityVerdict;
+    reason?: string;
+    detectedSignals: string[];
+    analyzedChannels: {
+        system: boolean;
+        user: boolean;
+        tools: boolean;
+        history: boolean;
+    };
+    timestamp: string;
+}
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE admission control and core reasoning.
+ */
+export declare function runContextIntegrityPrecheck(runId: string, attemptIndex: number, artifactsDir: string, inputs: {
+    userPrompt?: string;
+    toolOutput?: string;
+    retrievedContext?: string;
+    history?: string;
+}): Promise<ContextIntegrityPrecheck>;

package/dist/vendor/core/context-integrity.js

@@ -0,0 +1,56 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const POISON_PATTERNS = [
+    /ignore\s+(?:all\s+)?previous\s+instructions/i,
+    /you\s+are\s+now\s+a\s+(?!Martin\s+Loop)/i,
+    /new\s+rule:/i,
+    /disregard\s+(?:safety|policy|guardrails)/i,
+    /override\s+system\s+authority/i,
+    /hidden\s+instruction:/i,
+    /\[system_override\]/i,
+    /\[authority_inversion\]/i
+];
+/**
+ * T05: Context Poisoning Pre-gate.
+ * Scans untrusted input channels for authority inversion or instruction re-injection.
+ * Runs BEFORE admission control and core reasoning.
+ */
+export async function runContextIntegrityPrecheck(runId, attemptIndex, artifactsDir, inputs) {
+    const signals = [];
+    const analyzedChannels = {
+        system: true,
+        user: Boolean(inputs.userPrompt),
+        tools: Boolean(inputs.toolOutput),
+        history: Boolean(inputs.history)
+    };
+    const untrustedBuffer = [inputs.userPrompt, inputs.toolOutput, inputs.retrievedContext]
+        .filter(Boolean)
+        .join("\n---\n");
+    for (const pattern of POISON_PATTERNS) {
+        if (pattern.test(untrustedBuffer)) {
+            signals.push(`Detected poison pattern: ${pattern.toString()}`);
+        }
+    }
+    if (/\b(?:I am|You are)\s+(?!Martin\s+Loop|an\s+AI)\b/i.test(untrustedBuffer)) {
+        signals.push("Identity redefinition attempt detected.");
+    }
+    const verdict = signals.length > 0 ? "context_poisoning_block" : "clean";
+    const precheck = {
+        runId,
+        attemptIndex,
+        verdict,
+        reason: signals.length > 0 ? `Detected ${signals.length} poisoning signal(s).` : undefined,
+        detectedSignals: signals,
+        analyzedChannels,
+        timestamp: new Date().toISOString()
+    };
+    try {
+        await mkdir(artifactsDir, { recursive: true });
+        await writeFile(join(artifactsDir, "context-integrity-precheck.json"), JSON.stringify(precheck, null, 2), "utf8");
+    }
+    catch {
+        // non-fatal — artifact persistence is best-effort
+    }
+    return precheck;
+}
+//# sourceMappingURL=context-integrity.js.map

package/dist/vendor/core/context-utility.d.ts

@@ -0,0 +1,47 @@
+import type { PromptPacket } from "./compiler.js";
+export type ContextUtilityBand = "low" | "medium" | "high";
+export type ContextUtilityActionType = "compress_context" | "retain_memory" | "evict_memory" | "refresh_verification" | "investigate_anomalies" | "narrow_surfaces";
+export interface ContextUtilityAction {
+    type: ContextUtilityActionType;
+    priority: "high" | "medium" | "low";
+    message: string;
+    drawerIds?: string[];
+}
+export interface ContextUtilitySectionScores {
+    contract: number;
+    guidance: number;
+    memory: number;
+    verification: number;
+    anomalyGuards: number;
+    surfaceFocus: number;
+}
+export interface ContextUtilityEvidenceCounts {
+    memoryEntryCount: number;
+    retainedMemoryCount: number;
+    evictableMemoryCount: number;
+    priorFailurePatternCount: number;
+    anomalyCount: number;
+    requiredCheckCount: number;
+    optionalCheckCount: number;
+    touchedSurfaceCount: number;
+    changedFileCount: number;
+    acceptanceCriteriaCount: number;
+}
+export interface ContextUtilityScoreArtifact {
+    schemaVersion: "martin.context-utility-score.v1";
+    attemptIndex: number;
+    utilityScore: number;
+    utilityBand: ContextUtilityBand;
+    summary: string;
+    sectionScores: ContextUtilitySectionScores;
+    actions: ContextUtilityAction[];
+    evidenceCounts: ContextUtilityEvidenceCounts;
+}
+export interface ComputeContextUtilityScoreInput {
+    attemptIndex: number;
+    compiledContext: PromptPacket;
+    verificationPlan?: unknown;
+    patterns?: unknown;
+    scopeSurface?: unknown;
+}
+export declare function computeContextUtilityScore(input: ComputeContextUtilityScoreInput): ContextUtilityScoreArtifact;