martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/circuit/circuit-breaker.js

@@ -0,0 +1,143 @@
+// SLICE-24 — Model circuit breaker
+// State machine: CLOSED → OPEN → HALF_OPEN → CLOSED
+// Tracks consecutive failures per adapter and opens the circuit when the
+// threshold is reached, allowing recovery via a half-open probe.
+const DEFAULT_CONFIG = {
+    failureThreshold: 3,
+    cooldownMs: 60_000,
+    windowMs: 300_000
+};
+export class CircuitBreaker {
+    config;
+    adapterId;
+    state = "CLOSED";
+    failureCount = 0;
+    lastFailureTime;
+    openedAt;
+    constructor(adapterId, config) {
+        this.adapterId = adapterId;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Returns the current circuit breaker state snapshot.
+     */
+    getState() {
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            lastFailureTime: this.lastFailureTime?.toISOString(),
+            openedAt: this.openedAt?.toISOString(),
+            adapterId: this.adapterId
+        };
+    }
+    /**
+     * Returns true if a call should be allowed through.
+     * - CLOSED: always allowed
+     * - HALF_OPEN: one probe call allowed
+     * - OPEN: blocked unless cooldown has elapsed (transitions to HALF_OPEN)
+     */
+    canCall(now = new Date()) {
+        if (this.state === "CLOSED") {
+            return true;
+        }
+        if (this.state === "HALF_OPEN") {
+            return true;
+        }
+        // OPEN: check if cooldown has elapsed
+        if (this.state === "OPEN" && this.openedAt) {
+            const elapsed = now.getTime() - this.openedAt.getTime();
+            if (elapsed >= this.config.cooldownMs) {
+                this.state = "HALF_OPEN";
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Record a successful adapter call.
+     * HALF_OPEN → CLOSED on success.
+     */
+    recordSuccess() {
+        if (this.state === "HALF_OPEN") {
+            this.state = "CLOSED";
+            this.failureCount = 0;
+            this.lastFailureTime = undefined;
+            this.openedAt = undefined;
+        }
+        else if (this.state === "CLOSED") {
+            // Reset failure count on success in closed state
+            this.failureCount = 0;
+        }
+        // In OPEN state, success shouldn't happen (canCall returns false)
+        // but we handle it gracefully
+    }
+    /**
+     * Record a failed adapter call.
+     * CLOSED: increments failure count; if threshold reached, opens circuit.
+     * HALF_OPEN: re-opens circuit (probe failed).
+     */
+    recordFailure(now = new Date()) {
+        this.lastFailureTime = now;
+        if (this.state === "HALF_OPEN") {
+            // Probe failed — re-open
+            this.state = "OPEN";
+            this.openedAt = now;
+            return;
+        }
+        if (this.state === "CLOSED") {
+            this.failureCount++;
+            if (this.failureCount >= this.config.failureThreshold) {
+                this.state = "OPEN";
+                this.openedAt = now;
+            }
+        }
+        // In OPEN state, failures are noted but don't change state
+    }
+    /**
+     * Manually reset the circuit breaker to CLOSED state.
+     */
+    reset() {
+        this.state = "CLOSED";
+        this.failureCount = 0;
+        this.lastFailureTime = undefined;
+        this.openedAt = undefined;
+    }
+}
+/**
+ * Serializes a CircuitBreaker instance to a JSON string.
+ */
+export function serializeState(breaker) {
+    const snapshot = breaker.getState();
+    const serialized = {
+        adapterId: snapshot.adapterId,
+        config: breaker.config,
+        internalState: {
+            state: snapshot.state,
+            failureCount: snapshot.failureCount,
+            lastFailureTime: snapshot.lastFailureTime,
+            openedAt: snapshot.openedAt
+        }
+    };
+    return JSON.stringify(serialized);
+}
+/**
+ * Deserializes a JSON string back into a CircuitBreaker instance.
+ * Restores internal state including failure count, timestamps, and state.
+ */
+export function deserializeState(json, configOverride) {
+    const parsed = JSON.parse(json);
+    const mergedConfig = { ...parsed.config, ...configOverride };
+    const breaker = new CircuitBreaker(parsed.adapterId, mergedConfig);
+    // Restore internal state by directly setting private fields via index access
+    const internal = parsed.internalState;
+    breaker["state"] = internal.state;
+    breaker["failureCount"] = internal.failureCount;
+    breaker["lastFailureTime"] = internal.lastFailureTime
+        ? new Date(internal.lastFailureTime)
+        : undefined;
+    breaker["openedAt"] = internal.openedAt
+        ? new Date(internal.openedAt)
+        : undefined;
+    return breaker;
+}
+//# sourceMappingURL=circuit-breaker.js.map

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

@@ -0,0 +1,3 @@
+import type { LoopRecord } from "../contracts/index.js";
+import type { DistillContextOptions, DistilledContext } from "./types.js";
+export declare function distillContext(loop: LoopRecord, options?: DistillContextOptions): DistilledContext;

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

@@ -0,0 +1,44 @@
+export function distillContext(loop, options = {}) {
+    const maxRecentAttempts = Math.max(1, options.maxRecentAttempts ?? 3);
+    const recentAttempts = loop.attempts.slice(-maxRecentAttempts).map((attempt) => {
+        const distilled = {
+            attemptId: attempt.attemptId,
+            index: attempt.index,
+            summary: attempt.summary ?? "No attempt summary recorded."
+        };
+        if (attempt.failureClass) {
+            distilled.failureClass = attempt.failureClass;
+        }
+        if (attempt.intervention) {
+            distilled.intervention = attempt.intervention;
+        }
+        return distilled;
+    });
+    const remainingBudgetUsd = clamp(loop.budget.maxUsd - loop.cost.actualUsd);
+    const remainingIterations = clamp(loop.budget.maxIterations - loop.attempts.length);
+    const remainingTokens = clamp(loop.budget.maxTokens - loop.cost.tokensIn - loop.cost.tokensOut);
+    const repeatedClass = recentAttempts.at(-1)?.failureClass;
+    const nextMove = repeatedClass === undefined
+        ? "Focus on the first verified attempt."
+        : `Avoid another ${repeatedClass} outcome.`;
+    const context = {
+        taskTitle: loop.task.title,
+        objective: loop.task.objective,
+        verificationPlan: [...loop.task.verificationPlan],
+        recentAttempts,
+        constraints: {
+            remainingBudgetUsd,
+            remainingIterations,
+            remainingTokens
+        },
+        focus: `${loop.task.objective} ${nextMove}`.trim()
+    };
+    if (loop.task.repoRoot) {
+        context.repoRoot = loop.task.repoRoot;
+    }
+    return context;
+}
+function clamp(value) {
+    return value < 0 ? 0 : Number(value.toFixed(4));
+}
+//# sourceMappingURL=context-distillation.js.map

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

@@ -0,0 +1,8 @@
+import type { CanonicalRecord, CompileOptions, ContextPack, PolicyDecision, QcReport } from "./types.js";
+export declare function defaultCompileOptions(): CompileOptions;
+export declare function compileRecordContext(record: CanonicalRecord, profileName: string | undefined, options?: Partial<CompileOptions>): {
+    profile: ContextPack["profile"];
+    compiledContext: string;
+    qcReport: QcReport;
+};
+export declare function createCompileTraceId(record: CanonicalRecord, compiledContext: string, policyDecision: PolicyDecision): string;

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

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { resolveHeadlessProfile } from "./profiles.js";
+import { redactText } from "./redaction.js";
+import { estimateTokens } from "./token-estimator.js";
+export function defaultCompileOptions() {
+    return {
+        redactPii: true,
+        includeProvenanceSnippets: false,
+        deltaMode: false
+    };
+}
+export function compileRecordContext(record, profileName, options) {
+    const { name, config } = resolveHeadlessProfile(profileName);
+    const resolvedOptions = {
+        ...defaultCompileOptions(),
+        ...(options ?? {})
+    };
+    const sections = [];
+    const keptFields = [];
+    if (config.keepSections.includes("summary") && record.summary) {
+        sections.push(`SUMMARY\n${record.summary}`);
+        keptFields.push("summary");
+    }
+    const fieldMap = {
+        customer: record.fields.account,
+        issue: record.fields.issue,
+        product: record.fields.product,
+        next_steps: record.fields.requested_outcome,
+        account: record.fields.account,
+        stakeholders: record.fields.primary_contact,
+        open_risks: record.fields.priority,
+        opportunities: record.fields.arr,
+        recent_activity: typeof record.metadata.recent_activity === "string"
+            ? record.metadata.recent_activity
+            : undefined
+    };
+    for (const section of config.keepSections) {
+        const value = fieldMap[section];
+        if (value) {
+            sections.push(`${section.toUpperCase()}\n${value}`);
+            keptFields.push(section);
+        }
+    }
+    if (config.keepSections.includes("key_entities") && record.entities.length > 0) {
+        const values = [...new Set(record.entities.slice(0, 8).map((entity) => entity.value))];
+        sections.push(`KEY_ENTITIES\n${values.join(", ")}`);
+        keptFields.push("key_entities");
+    }
+    if (config.keepSections.includes("action_items")) {
+        const action = record.fields.requested_outcome ?? "Review canonical record and proceed cautiously.";
+        sections.push(`ACTION_ITEMS\n- ${action}`);
+        keptFields.push("action_items");
+    }
+    if (resolvedOptions.includeProvenanceSnippets && record.provenance.length > 0) {
+        const snippets = record.provenance
+            .slice(0, 3)
+            .map((item) => `- ${item.evidence}`)
+            .join("\n");
+        sections.push(`PROVENANCE_SNIPPETS\n${snippets}`);
+        keptFields.push("provenance_snippets");
+    }
+    let compiledContext = sections.join("\n\n").trim();
+    if (resolvedOptions.redactPii) {
+        compiledContext = redactText(compiledContext);
+    }
+    const budget = resolvedOptions.maxTokensOverride ?? config.maxTokens;
+    compiledContext = truncateToBudget(compiledContext, budget);
+    const tokenEstimateAfter = estimateTokens(compiledContext);
+    const beforeText = `${record.summary} ${record.provenance.map((item) => item.evidence).join(" ")}`;
+    const tokenEstimateBefore = estimateTokens(beforeText);
+    const tokenReductionPct = tokenEstimateBefore === 0
+        ? 0
+        : Number((Math.max(0, (tokenEstimateBefore - tokenEstimateAfter) / tokenEstimateBefore) * 100).toFixed(2));
+    const completenessScore = Number(Math.min(1, (Object.keys(record.fields).length + record.entities.length * 0.15) / 8).toFixed(2));
+    const warnings = [];
+    if (!record.fields.issue) {
+        warnings.push("Issue field missing or not inferred.");
+    }
+    if (!record.fields.account) {
+        warnings.push("Account field missing or not inferred.");
+    }
+    if (resolvedOptions.deltaMode) {
+        warnings.push("Delta mode enabled: only compact context should be sent downstream.");
+    }
+    return {
+        profile: name,
+        compiledContext,
+        qcReport: {
+            completenessScore,
+            tokenEstimateBefore,
+            tokenEstimateAfter,
+            tokenReductionPct,
+            warnings,
+            keptFields
+        }
+    };
+}
+export function createCompileTraceId(record, compiledContext, policyDecision) {
+    return createHash("sha1")
+        .update(`${record.recordId}:${compiledContext}:${policyDecision.recommendedMode}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+function truncateToBudget(text, budget) {
+    const words = text.split(/\s+/).filter(Boolean);
+    if (words.length <= budget) {
+        return text;
+    }
+    return words.slice(0, budget).join(" ");
+}
+//# sourceMappingURL=compile-context.js.map

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

@@ -0,0 +1,2 @@
+import type { Entity } from "./types.js";
+export declare function extractEntities(text: string): Entity[];

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

@@ -0,0 +1,44 @@
+import { CANONICAL_FIELD_LABELS, toFieldKey } from "./labels.js";
+const EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+const MONEY_RE = /\$\s?([0-9][0-9,]*)/g;
+const DATE_RE = /\b20\d{2}-\d{2}-\d{2}\b/g;
+export function extractEntities(text) {
+    const entities = [];
+    for (const match of text.matchAll(EMAIL_RE)) {
+        entities.push({
+            type: "email",
+            value: match[0],
+            confidence: 0.95
+        });
+    }
+    for (const match of text.matchAll(MONEY_RE)) {
+        entities.push({
+            type: "money",
+            value: match[0],
+            confidence: 0.8
+        });
+    }
+    for (const match of text.matchAll(DATE_RE)) {
+        entities.push({
+            type: "date",
+            value: match[0],
+            confidence: 0.9
+        });
+    }
+    for (const label of CANONICAL_FIELD_LABELS) {
+        const pattern = new RegExp(`${escapeForRegex(label)}:\\s*(.+)`, "im");
+        const match = pattern.exec(text);
+        if (match?.[1]) {
+            entities.push({
+                type: toFieldKey(label),
+                value: match[1].trim(),
+                confidence: 0.9
+            });
+        }
+    }
+    return entities;
+}
+function escapeForRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=entities.js.map

package/dist/vendor/core/context-flow/evaluate-policy.d.ts

@@ -0,0 +1,2 @@
+import type { CanonicalRecord, PolicyDecision, QcReport } from "./types.js";
+export declare function evaluatePolicy(record: CanonicalRecord, qcReport: QcReport, profileName: string | undefined): PolicyDecision;

package/dist/vendor/core/context-flow/evaluate-policy.js

@@ -0,0 +1,42 @@
+import { resolveHeadlessProfile } from "./profiles.js";
+import { classifySensitivity } from "./sensitivity.js";
+export function evaluatePolicy(record, qcReport, profileName) {
+    const { name, config } = resolveHeadlessProfile(profileName);
+    const reasons = [];
+    let allowAutonomy = true;
+    let severity = "low";
+    let recommendedMode = "auto";
+    let requiresApproval = false;
+    if (qcReport.completenessScore < config.autonomyThreshold) {
+        allowAutonomy = false;
+        severity = "medium";
+        recommendedMode = "human_review";
+        reasons.push("Completeness below autonomy threshold.");
+    }
+    if (qcReport.warnings.length >= 2) {
+        allowAutonomy = false;
+        severity = "high";
+        recommendedMode = "human_review";
+        reasons.push("Too many unresolved warnings in compiled context.");
+    }
+    const sensitivity = classifySensitivity(record);
+    if (sensitivity.level === "high") {
+        allowAutonomy = false;
+        severity = "high";
+        recommendedMode = "approval_required";
+        requiresApproval = true;
+        reasons.push(...sensitivity.reasons);
+    }
+    if (reasons.length === 0) {
+        reasons.push("Record meets baseline autonomy policy.");
+    }
+    return {
+        profile: name,
+        allowAutonomy,
+        severity,
+        reasons,
+        recommendedMode,
+        requiresApproval
+    };
+}
+//# sourceMappingURL=evaluate-policy.js.map

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

@@ -0,0 +1,11 @@
+export type { ApiKey, ApiKeyScope, CanonicalRecord, CompileOptions, CompileTrace, ContextPack, Entity, PolicyDecision, PolicyMode, PolicySeverity, ProvenanceItem, QcReport, SensitivityClassification, SensitivityLevel, SyncPreviewInput, SyncPreviewResponse, Tenant } from "./types.js";
+export { HEADLESSOS_PROFILES, resolveHeadlessProfile, type HeadlessCompileProfile, type HeadlessProfileName, type HeadlessProfileSection } from "./profiles.js";
+export { CANONICAL_FIELD_LABELS, toFieldKey, type CanonicalFieldLabel } from "./labels.js";
+export { normalizeTextRecord, extractLabeledFields, type NormalizeTextInput } from "./normalizer.js";
+export { extractEntities } from "./entities.js";
+export { redactText } from "./redaction.js";
+export { compileRecordContext, createCompileTraceId, defaultCompileOptions } from "./compile-context.js";
+export { DEFAULT_COST_PER_1K_TOKENS, estimateCostUsd, estimateTokens } from "./token-estimator.js";
+export { classifySensitivity } from "./sensitivity.js";
+export { evaluatePolicy } from "./evaluate-policy.js";
+export { buildSyncPreview } from "./sync-preview.js";

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

@@ -0,0 +1,24 @@
+// ─── Context Flow: OSS data pipeline for AI agents ──────────────────────────
+// Transforms raw unstructured records into clean, PII-safe, token-budgeted
+// context packs ready for any LLM agent. No infrastructure required.
+// Profiles
+export { HEADLESSOS_PROFILES, resolveHeadlessProfile } from "./profiles.js";
+// Labels
+export { CANONICAL_FIELD_LABELS, toFieldKey } from "./labels.js";
+// Normalizer (raw text → canonical record)
+export { normalizeTextRecord, extractLabeledFields } from "./normalizer.js";
+// Entity extraction
+export { extractEntities } from "./entities.js";
+// PII redaction
+export { redactText } from "./redaction.js";
+// Context compilation (canonical record → context pack)
+export { compileRecordContext, createCompileTraceId, defaultCompileOptions } from "./compile-context.js";
+// Token estimation
+export { DEFAULT_COST_PER_1K_TOKENS, estimateCostUsd, estimateTokens } from "./token-estimator.js";
+// Sensitivity classification
+export { classifySensitivity } from "./sensitivity.js";
+// Policy evaluation
+export { evaluatePolicy } from "./evaluate-policy.js";
+// Sync preview
+export { buildSyncPreview } from "./sync-preview.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+export declare const CANONICAL_FIELD_LABELS: readonly ["Account", "Primary Contact", "Product", "Issue", "Priority", "ARR", "Renewal Date", "Requested Outcome", "Recent Activity", "Owner", "Status"];
+export type CanonicalFieldLabel = (typeof CANONICAL_FIELD_LABELS)[number];
+export declare function toFieldKey(label: CanonicalFieldLabel | string): string;

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

@@ -0,0 +1,17 @@
+export const CANONICAL_FIELD_LABELS = [
+    "Account",
+    "Primary Contact",
+    "Product",
+    "Issue",
+    "Priority",
+    "ARR",
+    "Renewal Date",
+    "Requested Outcome",
+    "Recent Activity",
+    "Owner",
+    "Status"
+];
+export function toFieldKey(label) {
+    return label.toLowerCase().replace(/\s+/g, "_");
+}
+//# sourceMappingURL=labels.js.map

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

@@ -0,0 +1,9 @@
+import type { CanonicalRecord } from "./types.js";
+export interface NormalizeTextInput {
+    text: string;
+    sourceName?: string;
+    recordType?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function extractLabeledFields(text: string): Record<string, string>;
+export declare function normalizeTextRecord(input: NormalizeTextInput): CanonicalRecord;

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

@@ -0,0 +1,69 @@
+import { createHash } from "node:crypto";
+import { extractEntities } from "./entities.js";
+import { CANONICAL_FIELD_LABELS, toFieldKey } from "./labels.js";
+export function extractLabeledFields(text) {
+    const fields = {};
+    for (const label of CANONICAL_FIELD_LABELS) {
+        const match = new RegExp(`${escapeForRegex(label)}:\\s*(.+)`, "im").exec(text);
+        if (match?.[1]) {
+            fields[toFieldKey(label)] = match[1].trim();
+        }
+    }
+    return fields;
+}
+export function normalizeTextRecord(input) {
+    const sourceName = input.sourceName ?? "inline";
+    const recordType = input.recordType ?? "note";
+    const metadata = {
+        ...(input.metadata ?? {})
+    };
+    const lines = input.text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const fields = extractLabeledFields(input.text);
+    const summary = buildSummary(fields, lines);
+    const recordId = createHash("sha1")
+        .update(`${sourceName}:${recordType}:${input.text}`)
+        .digest("hex")
+        .slice(0, 12);
+    const provenance = lines.slice(0, 10).map((line) => ({
+        sourceName,
+        evidence: line
+    }));
+    const entities = extractEntities(input.text);
+    if (fields.recent_activity) {
+        metadata.recent_activity = fields.recent_activity;
+    }
+    return {
+        recordId,
+        recordType,
+        summary,
+        fields,
+        entities,
+        provenance,
+        metadata
+    };
+}
+function buildSummary(fields, lines) {
+    const summaryParts = [];
+    for (const key of ["account", "product", "issue", "requested_outcome"]) {
+        if (fields[key]) {
+            summaryParts.push(`${toTitleCase(key)}: ${fields[key]}`);
+        }
+    }
+    if (summaryParts.length > 0) {
+        return summaryParts.join(" | ");
+    }
+    return lines.slice(0, 3).join(" ").slice(0, 400);
+}
+function toTitleCase(value) {
+    return value
+        .split("_")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function escapeForRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=normalizer.js.map

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

@@ -0,0 +1,33 @@
+export type HeadlessProfileSection = "summary" | "customer" | "issue" | "product" | "next_steps" | "account" | "stakeholders" | "open_risks" | "opportunities" | "recent_activity" | "key_entities" | "action_items" | "provenance_snippets";
+export interface HeadlessCompileProfile {
+    maxTokens: number;
+    keepSections: readonly HeadlessProfileSection[];
+    autonomyThreshold: number;
+}
+export declare const HEADLESSOS_PROFILES: {
+    support_triage: {
+        maxTokens: number;
+        keepSections: ("summary" | "customer" | "issue" | "product" | "next_steps")[];
+        autonomyThreshold: number;
+    };
+    revops_account_brief: {
+        maxTokens: number;
+        keepSections: ("account" | "stakeholders" | "open_risks" | "opportunities" | "recent_activity")[];
+        autonomyThreshold: number;
+    };
+    generic_agent_small: {
+        maxTokens: number;
+        keepSections: ("summary" | "key_entities" | "action_items")[];
+        autonomyThreshold: number;
+    };
+    martin360_agent_stage: {
+        maxTokens: number;
+        keepSections: ("summary" | "issue" | "next_steps" | "account" | "stakeholders" | "key_entities")[];
+        autonomyThreshold: number;
+    };
+};
+export type HeadlessProfileName = keyof typeof HEADLESSOS_PROFILES;
+export declare function resolveHeadlessProfile(profile: HeadlessProfileName | string | undefined): {
+    name: HeadlessProfileName;
+    config: HeadlessCompileProfile;
+};

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

@@ -0,0 +1,36 @@
+export const HEADLESSOS_PROFILES = {
+    support_triage: {
+        maxTokens: 800,
+        keepSections: ["summary", "customer", "issue", "product", "next_steps"],
+        autonomyThreshold: 0.8
+    },
+    revops_account_brief: {
+        maxTokens: 1200,
+        keepSections: ["account", "stakeholders", "open_risks", "opportunities", "recent_activity"],
+        autonomyThreshold: 0.85
+    },
+    generic_agent_small: {
+        maxTokens: 600,
+        keepSections: ["summary", "key_entities", "action_items"],
+        autonomyThreshold: 0.9
+    },
+    martin360_agent_stage: {
+        maxTokens: 900,
+        keepSections: ["summary", "account", "issue", "stakeholders", "next_steps", "key_entities"],
+        autonomyThreshold: 0.82
+    }
+};
+export function resolveHeadlessProfile(profile) {
+    if (profile && profile in HEADLESSOS_PROFILES) {
+        const name = profile;
+        return {
+            name,
+            config: HEADLESSOS_PROFILES[name]
+        };
+    }
+    return {
+        name: "generic_agent_small",
+        config: HEADLESSOS_PROFILES.generic_agent_small
+    };
+}
+//# sourceMappingURL=profiles.js.map

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

@@ -0,0 +1 @@
+export declare function redactText(text: string): string;

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;