@mcoda/codali 0.1.66

package/dist/cognitive/LearningGovernance.d.ts

@@ -0,0 +1,100 @@
+export type LearningRuleLifecycleState = "candidate" | "enforced";
+export type LearningRuleConfidenceBand = "low" | "medium" | "high";
+export type LearningRuleScope = "repo_memory" | "profile_memory";
+export type LearningGovernanceStatus = "accepted" | "deferred" | "rejected";
+export interface LearningEvidenceReference {
+    kind: "run" | "artifact" | "file" | "request" | "post_mortem" | "other";
+    ref: string;
+    note?: string;
+}
+export interface LearningRuleProposal {
+    category: string;
+    content: string;
+    source?: string;
+    scope?: LearningRuleScope;
+    agent_id?: string;
+    lifecycle_state?: LearningRuleLifecycleState;
+    confidence_score?: number;
+    confidence_band?: LearningRuleConfidenceBand;
+    confidence_reasons?: string[];
+    evidence?: LearningEvidenceReference[];
+    explicit_confirmation?: boolean;
+}
+export interface LearningGovernancePolicy {
+    persistence_min_confidence: number;
+    enforcement_min_confidence: number;
+    require_confirmation_for_low_confidence: boolean;
+    auto_enforce_high_confidence: boolean;
+}
+export declare const DEFAULT_LEARNING_GOVERNANCE_POLICY: LearningGovernancePolicy;
+export interface LearningConfidenceInput {
+    source: string;
+    content: string;
+    explicit: boolean;
+    evidence_count: number;
+    has_revert_signal: boolean;
+}
+export interface LearningConfidenceScore {
+    score: number;
+    band: LearningRuleConfidenceBand;
+    reasons: string[];
+}
+export interface GovernedLearningRule {
+    schema_version: 1;
+    id: string;
+    dedupe_key: string;
+    category: string;
+    content: string;
+    normalized_content: string;
+    source: string;
+    scope: LearningRuleScope;
+    lifecycle_state: LearningRuleLifecycleState;
+    confidence_score: number;
+    confidence_band: LearningRuleConfidenceBand;
+    confidence_reasons: string[];
+    evidence: LearningEvidenceReference[];
+    explicit_confirmation: boolean;
+    created_at: string;
+    updated_at: string;
+    agent_id?: string;
+    supersedes?: string[];
+}
+export interface LearningRuleDecision {
+    status: LearningGovernanceStatus;
+    code: string;
+    message: string;
+    rule: GovernedLearningRule;
+}
+export interface LearningRuleLedgerRecord extends GovernedLearningRule {
+    superseded_by?: string;
+    superseded_at?: string;
+}
+export interface LearningRuleLedger {
+    schema_version: 1;
+    rules: LearningRuleLedgerRecord[];
+}
+export interface LedgerMergeResult {
+    action: "inserted" | "suppressed" | "superseded";
+    rule: LearningRuleLedgerRecord;
+    superseded?: LearningRuleLedgerRecord;
+}
+export interface LedgerPromotionResult {
+    action: "promoted" | "not_found" | "already_enforced";
+    promoted?: LearningRuleLedgerRecord;
+    previous?: LearningRuleLedgerRecord;
+}
+export declare class LearningGovernanceError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare const normalizeLearningCategory: (value: string) => string;
+export declare const normalizeLearningText: (value: string) => string;
+export declare const scoreLearningConfidence: (input: LearningConfidenceInput) => LearningConfidenceScore;
+export declare const buildLearningDedupeKey: (scope: LearningRuleScope, category: string, content: string) => string;
+export declare const governLearningRule: (proposal: LearningRuleProposal, policy?: LearningGovernancePolicy, now?: string) => LearningRuleDecision;
+export declare const createEmptyLearningRuleLedger: () => LearningRuleLedger;
+export declare const mergeLearningRuleIntoLedger: (ledger: LearningRuleLedger, rule: GovernedLearningRule) => LedgerMergeResult;
+export declare const promoteLearningRuleCandidate: (ledger: LearningRuleLedger, dedupeKey: string, policy?: LearningGovernancePolicy, now?: string) => LedgerPromotionResult;
+export declare const readLearningRuleLedger: (filePath: string) => Promise<LearningRuleLedger>;
+export declare const writeLearningRuleLedger: (filePath: string, ledger: LearningRuleLedger) => Promise<void>;
+//# sourceMappingURL=LearningGovernance.d.ts.map

package/dist/cognitive/LearningGovernance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LearningGovernance.d.ts","sourceRoot":"","sources":["../../src/cognitive/LearningGovernance.ts"],"names":[],"mappings":"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"}

package/dist/cognitive/LearningGovernance.js

@@ -0,0 +1,276 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const DEFAULT_LEARNING_GOVERNANCE_POLICY = {
+    persistence_min_confidence: 0.45,
+    enforcement_min_confidence: 0.85,
+    require_confirmation_for_low_confidence: true,
+    auto_enforce_high_confidence: true,
+};
+export class LearningGovernanceError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = "LearningGovernanceError";
+        this.code = code;
+    }
+}
+const clamp01 = (value) => Math.min(1, Math.max(0, value));
+const normalizeWhitespace = (value) => value
+    .trim()
+    .replace(/\s+/g, " ");
+export const normalizeLearningCategory = (value) => {
+    const normalized = normalizeWhitespace(value).toLowerCase();
+    if (!normalized) {
+        throw new LearningGovernanceError("invalid_category", "Learning rule category is required.");
+    }
+    if (normalized === "prefer" || normalized === "preference")
+        return "preference";
+    if (normalized === "constraint" || normalized === "rule" || normalized === "avoid") {
+        return "constraint";
+    }
+    if (normalized === "lesson" || normalized === "failure_lesson")
+        return "lesson";
+    return normalized;
+};
+export const normalizeLearningText = (value) => {
+    const normalized = normalizeWhitespace(value);
+    if (!normalized) {
+        throw new LearningGovernanceError("invalid_content", "Learning rule content is required.");
+    }
+    return normalized;
+};
+const canonicalizeLearningText = (value) => normalizeLearningText(value)
+    .toLowerCase()
+    .replace(/[“”]/g, "\"")
+    .replace(/[‘’]/g, "'")
+    .replace(/[.,;:!?]+$/g, "");
+const normalizeLearningEvidence = (evidence) => {
+    if (!Array.isArray(evidence) || evidence.length === 0)
+        return [];
+    const map = new Map();
+    for (const entry of evidence) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const kind = normalizeWhitespace(String(entry.kind ?? "")).toLowerCase();
+        const ref = normalizeWhitespace(String(entry.ref ?? ""));
+        const note = entry.note ? normalizeWhitespace(String(entry.note)) : undefined;
+        if (!kind || !ref)
+            continue;
+        const safeKind = (["run", "artifact", "file", "request", "post_mortem"].includes(kind) ? kind : "other");
+        const key = `${safeKind}::${ref}::${note ?? ""}`.toLowerCase();
+        if (!map.has(key)) {
+            map.set(key, { kind: safeKind, ref, note });
+        }
+    }
+    return Array.from(map.values()).sort((left, right) => {
+        const leftKey = `${left.kind}:${left.ref}:${left.note ?? ""}`;
+        const rightKey = `${right.kind}:${right.ref}:${right.note ?? ""}`;
+        return leftKey.localeCompare(rightKey);
+    });
+};
+const resolveScope = (category, scope) => {
+    if (scope === "repo_memory" || scope === "profile_memory")
+        return scope;
+    if (category === "preference" || category === "constraint")
+        return "profile_memory";
+    return "repo_memory";
+};
+const resolveBand = (score) => {
+    if (score >= 0.8)
+        return "high";
+    if (score >= 0.5)
+        return "medium";
+    return "low";
+};
+export const scoreLearningConfidence = (input) => {
+    let score = 0.2;
+    const reasons = [];
+    if (input.explicit) {
+        score += 0.4;
+        reasons.push("explicit_directive");
+    }
+    else {
+        reasons.push("inferred_directive");
+    }
+    if (input.source.includes("post_mortem")) {
+        score += 0.2;
+        reasons.push("post_mortem_source");
+    }
+    else if (input.source.includes("request")) {
+        score += 0.15;
+        reasons.push("request_source");
+    }
+    if (input.has_revert_signal) {
+        score += 0.15;
+        reasons.push("revert_signal");
+    }
+    if (input.evidence_count > 0) {
+        const evidenceBoost = Math.min(0.2, input.evidence_count * 0.05);
+        score += evidenceBoost;
+        reasons.push(`evidence_count:${input.evidence_count}`);
+    }
+    else {
+        reasons.push("no_evidence");
+    }
+    if (/(?:maybe|might|perhaps|probably|could)\b/i.test(input.content)) {
+        score -= 0.2;
+        reasons.push("ambiguous_language");
+    }
+    if (input.content.trim().length < 10) {
+        score -= 0.1;
+        reasons.push("short_rule_text");
+    }
+    const normalizedScore = clamp01(score);
+    return {
+        score: normalizedScore,
+        band: resolveBand(normalizedScore),
+        reasons,
+    };
+};
+const createRuleId = (dedupeKey, now, lifecycle) => `${dedupeKey}::${lifecycle}::${new Date(now).getTime()}`;
+export const buildLearningDedupeKey = (scope, category, content) => `${scope}::${category}::${canonicalizeLearningText(content)}`;
+export const governLearningRule = (proposal, policy = DEFAULT_LEARNING_GOVERNANCE_POLICY, now = new Date().toISOString()) => {
+    const category = normalizeLearningCategory(proposal.category);
+    const content = normalizeLearningText(proposal.content);
+    const source = normalizeWhitespace(proposal.source ?? "unknown_source").toLowerCase();
+    const scope = resolveScope(category, proposal.scope);
+    const evidence = normalizeLearningEvidence(proposal.evidence);
+    const dedupeKey = buildLearningDedupeKey(scope, category, content);
+    const confidence = Number.isFinite(proposal.confidence_score)
+        ? clamp01(Number(proposal.confidence_score))
+        : scoreLearningConfidence({
+            source,
+            content,
+            explicit: source.includes("explicit"),
+            evidence_count: evidence.length,
+            has_revert_signal: source.includes("post_mortem"),
+        }).score;
+    const confidenceBand = proposal.confidence_band ?? resolveBand(confidence);
+    const confidenceReasons = proposal.confidence_reasons?.length
+        ? proposal.confidence_reasons.map((entry) => normalizeWhitespace(entry)).filter(Boolean)
+        : scoreLearningConfidence({
+            source,
+            content,
+            explicit: source.includes("explicit"),
+            evidence_count: evidence.length,
+            has_revert_signal: source.includes("post_mortem"),
+        }).reasons;
+    let lifecycleState = "candidate";
+    const explicitConfirmation = Boolean(proposal.explicit_confirmation);
+    if (explicitConfirmation) {
+        lifecycleState = "enforced";
+    }
+    else if (policy.auto_enforce_high_confidence &&
+        confidence >= policy.enforcement_min_confidence &&
+        (!policy.require_confirmation_for_low_confidence || confidenceBand !== "low")) {
+        lifecycleState = "enforced";
+    }
+    const rule = {
+        schema_version: 1,
+        id: createRuleId(dedupeKey, now, lifecycleState),
+        dedupe_key: dedupeKey,
+        category,
+        content,
+        normalized_content: canonicalizeLearningText(content),
+        source,
+        scope,
+        lifecycle_state: lifecycleState,
+        confidence_score: confidence,
+        confidence_band: confidenceBand,
+        confidence_reasons: confidenceReasons,
+        evidence,
+        explicit_confirmation: explicitConfirmation,
+        created_at: now,
+        updated_at: now,
+        agent_id: proposal.agent_id,
+    };
+    if (confidence < policy.persistence_min_confidence) {
+        return {
+            status: "deferred",
+            code: "confidence_below_persistence_threshold",
+            message: "Rule confidence is below persistence threshold.",
+            rule,
+        };
+    }
+    return {
+        status: "accepted",
+        code: lifecycleState === "enforced" ? "accepted_enforced" : "accepted_candidate",
+        message: lifecycleState === "enforced"
+            ? "Rule accepted as enforced."
+            : "Rule accepted as candidate.",
+        rule,
+    };
+};
+export const createEmptyLearningRuleLedger = () => ({
+    schema_version: 1,
+    rules: [],
+});
+const toLedgerRecord = (rule) => ({ ...rule });
+const isActive = (entry) => !entry.superseded_by;
+export const mergeLearningRuleIntoLedger = (ledger, rule) => {
+    const existing = ledger.rules.find((entry) => isActive(entry) && entry.dedupe_key === rule.dedupe_key);
+    if (!existing) {
+        const inserted = toLedgerRecord(rule);
+        ledger.rules.push(inserted);
+        return { action: "inserted", rule: inserted };
+    }
+    const shouldPromote = existing.lifecycle_state !== "enforced" && rule.lifecycle_state === "enforced";
+    const confidenceDelta = rule.confidence_score - existing.confidence_score;
+    const shouldReplaceByConfidence = existing.lifecycle_state === rule.lifecycle_state &&
+        (confidenceDelta > 0.05 || rule.normalized_content !== existing.normalized_content);
+    if (!shouldPromote && !shouldReplaceByConfidence) {
+        return { action: "suppressed", rule: existing };
+    }
+    const supersededAt = rule.updated_at;
+    existing.superseded_by = rule.id;
+    existing.superseded_at = supersededAt;
+    const inserted = toLedgerRecord({
+        ...rule,
+        supersedes: [...(rule.supersedes ?? []), existing.id],
+    });
+    ledger.rules.push(inserted);
+    return { action: "superseded", rule: inserted, superseded: existing };
+};
+export const promoteLearningRuleCandidate = (ledger, dedupeKey, policy = DEFAULT_LEARNING_GOVERNANCE_POLICY, now = new Date().toISOString()) => {
+    const active = ledger.rules.find((entry) => isActive(entry) && entry.dedupe_key === dedupeKey);
+    if (!active)
+        return { action: "not_found" };
+    if (active.lifecycle_state === "enforced") {
+        return { action: "already_enforced", previous: active };
+    }
+    const promoted = {
+        ...active,
+        id: createRuleId(active.dedupe_key, now, "enforced"),
+        lifecycle_state: "enforced",
+        confidence_score: Math.max(active.confidence_score, policy.enforcement_min_confidence),
+        confidence_band: resolveBand(Math.max(active.confidence_score, policy.enforcement_min_confidence)),
+        explicit_confirmation: true,
+        updated_at: now,
+        supersedes: [...(active.supersedes ?? []), active.id],
+    };
+    active.superseded_by = promoted.id;
+    active.superseded_at = now;
+    ledger.rules.push(promoted);
+    return { action: "promoted", promoted, previous: active };
+};
+export const readLearningRuleLedger = async (filePath) => {
+    try {
+        const content = await readFile(filePath, "utf8");
+        if (!content.trim())
+            return createEmptyLearningRuleLedger();
+        const parsed = JSON.parse(content);
+        if (parsed.schema_version !== 1 || !Array.isArray(parsed.rules)) {
+            return createEmptyLearningRuleLedger();
+        }
+        return {
+            schema_version: 1,
+            rules: parsed.rules.filter((entry) => Boolean(entry && typeof entry === "object" && typeof entry.id === "string")),
+        };
+    }
+    catch {
+        return createEmptyLearningRuleLedger();
+    }
+};
+export const writeLearningRuleLedger = async (filePath, ledger) => {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(ledger, null, 2)}\n`, "utf8");
+};

package/dist/cognitive/MemoryWriteback.d.ts

@@ -0,0 +1,64 @@
+import type { LearningConfig } from "../config/Config.js";
+import type { DocdexClient } from "../docdex/DocdexClient.js";
+import type { RunLogger } from "../runtime/RunLogger.js";
+import { type LearningEvidenceReference, type LearningRuleProposal, type LearningRuleScope } from "./LearningGovernance.js";
+export interface PreferenceWriteback {
+    category: string;
+    content: string;
+    agentId?: string;
+    source?: string;
+    scope?: LearningRuleScope;
+    confidence_score?: number;
+    confidence_band?: "low" | "medium" | "high";
+    confidence_reasons?: string[];
+    evidence?: LearningEvidenceReference[];
+    explicit_confirmation?: boolean;
+}
+export interface RulePromotionRequest {
+    dedupe_key: string;
+    agentId?: string;
+}
+export interface MemoryWritebackInput {
+    failures: number;
+    maxRetries: number;
+    lesson: string;
+    preferences?: PreferenceWriteback[];
+    rules?: LearningRuleProposal[];
+    promotions?: RulePromotionRequest[];
+}
+export interface MemoryWritebackOptions {
+    agentId?: string;
+    workspaceRoot?: string;
+    learning?: Partial<LearningConfig>;
+    logger?: RunLogger;
+}
+export interface LearningWriteOutcome {
+    status: "accepted" | "deferred" | "suppressed" | "rejected" | "promoted";
+    code: string;
+    message: string;
+    rule_id?: string;
+    dedupe_key?: string;
+    scope?: LearningRuleScope;
+    lifecycle_state?: "candidate" | "enforced";
+    confidence_score?: number;
+    confidence_band?: "low" | "medium" | "high";
+    target?: "repo_memory" | "profile_memory";
+}
+export interface MemoryWritebackResult {
+    outcomes: LearningWriteOutcome[];
+    ledgerPath: string;
+}
+export declare class MemoryWriteback {
+    private client;
+    private agentId;
+    private workspaceRoot;
+    private ledgerPath;
+    private logger?;
+    private policy;
+    constructor(client: DocdexClient, options?: MemoryWritebackOptions);
+    private logOutcome;
+    private toLegacyProposals;
+    private persistRuleToDocdex;
+    persist(input: MemoryWritebackInput): Promise<MemoryWritebackResult>;
+}
+//# sourceMappingURL=MemoryWriteback.d.ts.map

package/dist/cognitive/MemoryWriteback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryWriteback.d.ts","sourceRoot":"","sources":["../../src/cognitive/MemoryWriteback.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAOL,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC5C,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,yBAAyB,EAAE,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACpC,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,eAAe,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC5C,MAAM,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC;CAC3C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,oBAAoB,EAAE,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB;AA6BD,qBAAa,eAAe;IAWd,OAAO,CAAC,MAAM;IAV1B,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,MAAM,CAAC,CAAY;IAE3B,OAAO,CAAC,MAAM,CAAuC;gBAEjC,MAAM,EAAE,YAAY,EAAE,OAAO,GAAE,sBAA2B;YAShE,UAAU;IAKxB,OAAO,CAAC,iBAAiB;YA+BX,mBAAmB;IAmD3B,OAAO,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAqL3E"}