@auxiora/autonomy 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+/** Trust level from 0 (no autonomy) to 4 (full autonomy). */
+export type TrustLevel = 0 | 1 | 2 | 3 | 4;
+/** Named trust domains that can have independent trust levels. */
+export type TrustDomain = 'messaging' | 'files' | 'web' | 'shell' | 'finance' | 'calendar' | 'email' | 'integrations' | 'system';
+export interface TrustConfig {
+    /** Default trust level for new domains. */
+    defaultLevel: TrustLevel;
+    /** Whether automatic promotion is enabled. */
+    autoPromote: boolean;
+    /** Minimum successful actions before promotion is considered. */
+    promotionThreshold: number;
+    /** Number of failures before automatic demotion. */
+    demotionThreshold: number;
+    /** Maximum trust level that auto-promotion can reach. */
+    autoPromoteCeiling: TrustLevel;
+}
+export interface TrustEvidence {
+    /** Number of successful actions in this domain. */
+    successes: number;
+    /** Number of failed actions in this domain. */
+    failures: number;
+    /** Timestamp of last action. */
+    lastActionAt: number;
+    /** Timestamp of last promotion. */
+    lastPromotedAt?: number;
+    /** Timestamp of last demotion. */
+    lastDemotedAt?: number;
+}
+export interface TrustPromotion {
+    domain: TrustDomain;
+    fromLevel: TrustLevel;
+    toLevel: TrustLevel;
+    reason: string;
+    timestamp: number;
+    automatic: boolean;
+}
+export interface TrustDemotion {
+    domain: TrustDomain;
+    fromLevel: TrustLevel;
+    toLevel: TrustLevel;
+    reason: string;
+    timestamp: number;
+}
+export interface ActionAudit {
+    id: string;
+    timestamp: number;
+    trustLevel: TrustLevel;
+    domain: TrustDomain;
+    intent: string;
+    plan: string;
+    executed: boolean;
+    outcome: 'success' | 'failure' | 'pending' | 'rolled_back';
+    reasoning: string;
+    rollbackAvailable: boolean;
+}
+export interface TrustState {
+    levels: Record<TrustDomain, TrustLevel>;
+    evidence: Record<TrustDomain, TrustEvidence>;
+    promotions: TrustPromotion[];
+    demotions: TrustDemotion[];
+}
+export declare const DEFAULT_TRUST_CONFIG: TrustConfig;
+export declare const TRUST_LEVEL_NAMES: Record<TrustLevel, string>;
+export declare const ALL_TRUST_DOMAINS: TrustDomain[];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3C,kEAAkE;AAClE,MAAM,MAAM,WAAW,GACnB,WAAW,GACX,OAAO,GACP,KAAK,GACL,OAAO,GACP,SAAS,GACT,UAAU,GACV,OAAO,GACP,cAAc,GACd,QAAQ,CAAC;AAEb,MAAM,WAAW,WAAW;IAC1B,2CAA2C;IAC3C,YAAY,EAAE,UAAU,CAAC;IACzB,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IACrB,iEAAiE;IACjE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,kBAAkB,EAAE,UAAU,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IAC7C,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,SAAS,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,eAAO,MAAM,oBAAoB,EAAE,WAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMxD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,WAAW,EAU1C,CAAC"}

package/dist/types.js

@@ -0,0 +1,26 @@
+export const DEFAULT_TRUST_CONFIG = {
+    defaultLevel: 0,
+    autoPromote: true,
+    promotionThreshold: 10,
+    demotionThreshold: 3,
+    autoPromoteCeiling: 3,
+};
+export const TRUST_LEVEL_NAMES = {
+    0: 'None',
+    1: 'Inform',
+    2: 'Suggest',
+    3: 'Act & Report',
+    4: 'Full Autonomy',
+};
+export const ALL_TRUST_DOMAINS = [
+    'messaging',
+    'files',
+    'web',
+    'shell',
+    'finance',
+    'calendar',
+    'email',
+    'integrations',
+    'system',
+];
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA8EA,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,YAAY,EAAE,CAAC;IACf,WAAW,EAAE,IAAI;IACjB,kBAAkB,EAAE,EAAE;IACtB,iBAAiB,EAAE,CAAC;IACpB,kBAAkB,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAA+B;IAC3D,CAAC,EAAE,MAAM;IACT,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,SAAS;IACZ,CAAC,EAAE,cAAc;IACjB,CAAC,EAAE,eAAe;CACnB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAkB;IAC9C,WAAW;IACX,OAAO;IACP,KAAK;IACL,OAAO;IACP,SAAS;IACT,UAAU;IACV,OAAO;IACP,cAAc;IACd,QAAQ;CACT,CAAC"}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@auxiora/autonomy",
+  "version": "1.0.0",
+  "description": "Trust engine with 5-level autonomy, escalation, demotion, and audit trail",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@auxiora/core": "1.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/audit-trail.ts

@@ -0,0 +1,93 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { paths } from '@auxiora/core';
+import type { ActionAudit, TrustDomain, TrustLevel } from './types.js';
+
+export interface AuditQueryFilters {
+  domain?: TrustDomain;
+  outcome?: ActionAudit['outcome'];
+  fromTimestamp?: number;
+  toTimestamp?: number;
+  limit?: number;
+}
+
+export class ActionAuditTrail {
+  private entries: ActionAudit[] = [];
+  private filePath: string;
+
+  constructor(filePath?: string) {
+    this.filePath = filePath ?? path.join(paths.data(), 'trust-audit.json');
+  }
+
+  async load(): Promise<void> {
+    try {
+      const raw = await fs.readFile(this.filePath, 'utf-8');
+      this.entries = JSON.parse(raw) as ActionAudit[];
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  async save(): Promise<void> {
+    const dir = path.dirname(this.filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(this.entries, null, 2), 'utf-8');
+  }
+
+  async record(entry: Omit<ActionAudit, 'id' | 'timestamp'>): Promise<ActionAudit> {
+    const audit: ActionAudit = {
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+      ...entry,
+    };
+    this.entries.push(audit);
+    await this.save();
+    return audit;
+  }
+
+  query(filters: AuditQueryFilters = {}): ActionAudit[] {
+    let result = [...this.entries];
+
+    if (filters.domain) {
+      result = result.filter((e) => e.domain === filters.domain);
+    }
+    if (filters.outcome) {
+      result = result.filter((e) => e.outcome === filters.outcome);
+    }
+    if (filters.fromTimestamp !== undefined) {
+      result = result.filter((e) => e.timestamp >= filters.fromTimestamp!);
+    }
+    if (filters.toTimestamp !== undefined) {
+      result = result.filter((e) => e.timestamp <= filters.toTimestamp!);
+    }
+
+    // Sort newest first
+    result.sort((a, b) => b.timestamp - a.timestamp);
+
+    if (filters.limit !== undefined && filters.limit > 0) {
+      result = result.slice(0, filters.limit);
+    }
+
+    return result;
+  }
+
+  getById(id: string): ActionAudit | undefined {
+    return this.entries.find((e) => e.id === id);
+  }
+
+  async markRolledBack(id: string): Promise<boolean> {
+    const entry = this.entries.find((e) => e.id === id);
+    if (!entry) return false;
+    entry.outcome = 'rolled_back';
+    entry.rollbackAvailable = false;
+    await this.save();
+    return true;
+  }
+
+  getAll(): ActionAudit[] {
+    return [...this.entries];
+  }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export type {
+  TrustLevel,
+  TrustDomain,
+  TrustConfig,
+  TrustEvidence,
+  TrustPromotion,
+  TrustDemotion,
+  ActionAudit,
+  TrustState,
+} from './types.js';
+export {
+  DEFAULT_TRUST_CONFIG,
+  TRUST_LEVEL_NAMES,
+  ALL_TRUST_DOMAINS,
+} from './types.js';
+export { TrustEngine } from './trust-engine.js';
+export { ActionAuditTrail, type AuditQueryFilters } from './audit-trail.js';
+export { RollbackManager, type RollbackResult } from './rollback.js';
+export { TrustGate, type GateResult } from './trust-gate.js';

package/src/rollback.ts

@@ -0,0 +1,44 @@
+import type { ActionAuditTrail } from './audit-trail.js';
+import type { ActionAudit } from './types.js';
+
+export interface RollbackResult {
+  success: boolean;
+  auditId: string;
+  error?: string;
+}
+
+export class RollbackManager {
+  private auditTrail: ActionAuditTrail;
+
+  constructor(auditTrail: ActionAuditTrail) {
+    this.auditTrail = auditTrail;
+  }
+
+  canRollback(auditId: string): boolean {
+    const entry = this.auditTrail.getById(auditId);
+    if (!entry) return false;
+    return entry.rollbackAvailable && entry.outcome !== 'rolled_back';
+  }
+
+  async rollback(auditId: string): Promise<RollbackResult> {
+    const entry = this.auditTrail.getById(auditId);
+    if (!entry) {
+      return { success: false, auditId, error: 'Audit entry not found' };
+    }
+
+    if (entry.outcome === 'rolled_back') {
+      return { success: false, auditId, error: 'Action already rolled back' };
+    }
+
+    if (!entry.rollbackAvailable) {
+      return { success: false, auditId, error: 'Rollback not available for this action' };
+    }
+
+    await this.auditTrail.markRolledBack(auditId);
+    return { success: true, auditId };
+  }
+
+  getHistory(): ActionAudit[] {
+    return this.auditTrail.query({ outcome: 'rolled_back' });
+  }
+}

package/src/trust-engine.ts

@@ -0,0 +1,218 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { paths } from '@auxiora/core';
+import type {
+  TrustLevel,
+  TrustDomain,
+  TrustConfig,
+  TrustEvidence,
+  TrustPromotion,
+  TrustDemotion,
+  TrustState,
+} from './types.js';
+import {
+  DEFAULT_TRUST_CONFIG,
+  ALL_TRUST_DOMAINS,
+} from './types.js';
+
+function makeFreshEvidence(): TrustEvidence {
+  return { successes: 0, failures: 0, lastActionAt: 0 };
+}
+
+function makeFreshState(defaultLevel: TrustLevel): TrustState {
+  const levels = {} as Record<TrustDomain, TrustLevel>;
+  const evidence = {} as Record<TrustDomain, TrustEvidence>;
+  for (const domain of ALL_TRUST_DOMAINS) {
+    levels[domain] = defaultLevel;
+    evidence[domain] = makeFreshEvidence();
+  }
+  return { levels, evidence, promotions: [], demotions: [] };
+}
+
+export class TrustEngine {
+  private state: TrustState;
+  private config: TrustConfig;
+  private statePath: string;
+
+  constructor(config?: Partial<TrustConfig>, statePath?: string) {
+    this.config = { ...DEFAULT_TRUST_CONFIG, ...config };
+    this.statePath = statePath ?? path.join(paths.data(), 'trust-state.json');
+    this.state = makeFreshState(this.config.defaultLevel);
+  }
+
+  async load(): Promise<void> {
+    try {
+      const raw = await fs.readFile(this.statePath, 'utf-8');
+      const parsed = JSON.parse(raw) as TrustState;
+      this.state = parsed;
+
+      // Ensure all domains exist (in case new ones were added)
+      for (const domain of ALL_TRUST_DOMAINS) {
+        if (this.state.levels[domain] === undefined) {
+          this.state.levels[domain] = this.config.defaultLevel;
+        }
+        if (!this.state.evidence[domain]) {
+          this.state.evidence[domain] = makeFreshEvidence();
+        }
+      }
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+      // File doesn't exist, use fresh state
+    }
+  }
+
+  async save(): Promise<void> {
+    const dir = path.dirname(this.statePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.statePath, JSON.stringify(this.state, null, 2), 'utf-8');
+  }
+
+  getTrustLevel(domain: TrustDomain): TrustLevel {
+    return this.state.levels[domain] ?? this.config.defaultLevel;
+  }
+
+  getAllLevels(): Record<TrustDomain, TrustLevel> {
+    return { ...this.state.levels };
+  }
+
+  getEvidence(domain: TrustDomain): TrustEvidence {
+    return { ...(this.state.evidence[domain] ?? makeFreshEvidence()) };
+  }
+
+  async setTrustLevel(domain: TrustDomain, level: TrustLevel, reason: string): Promise<void> {
+    const current = this.getTrustLevel(domain);
+    if (level === current) return;
+
+    if (level > current) {
+      this.state.promotions.push({
+        domain,
+        fromLevel: current,
+        toLevel: level,
+        reason,
+        timestamp: Date.now(),
+        automatic: false,
+      });
+      this.state.evidence[domain].lastPromotedAt = Date.now();
+    } else {
+      this.state.demotions.push({
+        domain,
+        fromLevel: current,
+        toLevel: level,
+        reason,
+        timestamp: Date.now(),
+      });
+      this.state.evidence[domain].lastDemotedAt = Date.now();
+    }
+
+    this.state.levels[domain] = level;
+    await this.save();
+  }
+
+  checkPermission(domain: TrustDomain, requiredLevel: TrustLevel): boolean {
+    return this.getTrustLevel(domain) >= requiredLevel;
+  }
+
+  async recordOutcome(domain: TrustDomain, success: boolean): Promise<TrustPromotion | TrustDemotion | null> {
+    const ev = this.state.evidence[domain] ?? makeFreshEvidence();
+    ev.lastActionAt = Date.now();
+
+    if (success) {
+      ev.successes++;
+      ev.failures = 0; // Reset consecutive failure count on success
+    } else {
+      ev.failures++;
+    }
+
+    this.state.evidence[domain] = ev;
+
+    // Check for auto-demotion
+    if (ev.failures >= this.config.demotionThreshold) {
+      const current = this.getTrustLevel(domain);
+      if (current > 0) {
+        const newLevel = (current - 1) as TrustLevel;
+        const demotion: TrustDemotion = {
+          domain,
+          fromLevel: current,
+          toLevel: newLevel,
+          reason: `Automatic demotion after ${ev.failures} consecutive failures`,
+          timestamp: Date.now(),
+        };
+        this.state.levels[domain] = newLevel;
+        this.state.demotions.push(demotion);
+        ev.failures = 0;
+        ev.lastDemotedAt = Date.now();
+        await this.save();
+        return demotion;
+      }
+    }
+
+    // Check for auto-promotion
+    const promotion = this.evaluatePromotion(domain);
+    if (promotion) {
+      this.state.levels[domain] = promotion.toLevel;
+      this.state.promotions.push(promotion);
+      ev.successes = 0; // Reset counter after promotion
+      ev.lastPromotedAt = Date.now();
+      await this.save();
+      return promotion;
+    }
+
+    await this.save();
+    return null;
+  }
+
+  evaluatePromotion(domain: TrustDomain): TrustPromotion | null {
+    if (!this.config.autoPromote) return null;
+
+    const current = this.getTrustLevel(domain);
+    if (current >= this.config.autoPromoteCeiling) return null;
+    if (current >= 4) return null;
+
+    const ev = this.state.evidence[domain];
+    if (!ev || ev.successes < this.config.promotionThreshold) return null;
+
+    const newLevel = (current + 1) as TrustLevel;
+    return {
+      domain,
+      fromLevel: current,
+      toLevel: newLevel,
+      reason: `Automatic promotion after ${ev.successes} successful actions`,
+      timestamp: Date.now(),
+      automatic: true,
+    };
+  }
+
+  async demote(domain: TrustDomain, reason: string): Promise<TrustDemotion | null> {
+    const current = this.getTrustLevel(domain);
+    if (current <= 0) return null;
+
+    const newLevel = (current - 1) as TrustLevel;
+    const demotion: TrustDemotion = {
+      domain,
+      fromLevel: current,
+      toLevel: newLevel,
+      reason,
+      timestamp: Date.now(),
+    };
+
+    this.state.levels[domain] = newLevel;
+    this.state.demotions.push(demotion);
+    this.state.evidence[domain].lastDemotedAt = Date.now();
+    await this.save();
+    return demotion;
+  }
+
+  getPromotions(): TrustPromotion[] {
+    return [...this.state.promotions];
+  }
+
+  getDemotions(): TrustDemotion[] {
+    return [...this.state.demotions];
+  }
+
+  getState(): TrustState {
+    return JSON.parse(JSON.stringify(this.state)) as TrustState;
+  }
+}

package/src/trust-gate.ts

@@ -0,0 +1,36 @@
+import type { TrustEngine } from './trust-engine.js';
+import type { TrustDomain, TrustLevel } from './types.js';
+import { TRUST_LEVEL_NAMES } from './types.js';
+
+export interface GateResult {
+  allowed: boolean;
+  currentLevel: TrustLevel;
+  requiredLevel: TrustLevel;
+  domain: TrustDomain;
+  message: string;
+}
+
+export class TrustGate {
+  private engine: TrustEngine;
+
+  constructor(engine: TrustEngine) {
+    this.engine = engine;
+  }
+
+  gate(domain: TrustDomain, action: string, requiredLevel: TrustLevel): GateResult {
+    const currentLevel = this.engine.getTrustLevel(domain);
+    const allowed = currentLevel >= requiredLevel;
+
+    const message = allowed
+      ? `Action "${action}" allowed at trust level ${TRUST_LEVEL_NAMES[currentLevel]}`
+      : `Action "${action}" denied: requires ${TRUST_LEVEL_NAMES[requiredLevel]} (current: ${TRUST_LEVEL_NAMES[currentLevel]})`;
+
+    return {
+      allowed,
+      currentLevel,
+      requiredLevel,
+      domain,
+      message,
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,105 @@
+/** Trust level from 0 (no autonomy) to 4 (full autonomy). */
+export type TrustLevel = 0 | 1 | 2 | 3 | 4;
+
+/** Named trust domains that can have independent trust levels. */
+export type TrustDomain =
+  | 'messaging'
+  | 'files'
+  | 'web'
+  | 'shell'
+  | 'finance'
+  | 'calendar'
+  | 'email'
+  | 'integrations'
+  | 'system';
+
+export interface TrustConfig {
+  /** Default trust level for new domains. */
+  defaultLevel: TrustLevel;
+  /** Whether automatic promotion is enabled. */
+  autoPromote: boolean;
+  /** Minimum successful actions before promotion is considered. */
+  promotionThreshold: number;
+  /** Number of failures before automatic demotion. */
+  demotionThreshold: number;
+  /** Maximum trust level that auto-promotion can reach. */
+  autoPromoteCeiling: TrustLevel;
+}
+
+export interface TrustEvidence {
+  /** Number of successful actions in this domain. */
+  successes: number;
+  /** Number of failed actions in this domain. */
+  failures: number;
+  /** Timestamp of last action. */
+  lastActionAt: number;
+  /** Timestamp of last promotion. */
+  lastPromotedAt?: number;
+  /** Timestamp of last demotion. */
+  lastDemotedAt?: number;
+}
+
+export interface TrustPromotion {
+  domain: TrustDomain;
+  fromLevel: TrustLevel;
+  toLevel: TrustLevel;
+  reason: string;
+  timestamp: number;
+  automatic: boolean;
+}
+
+export interface TrustDemotion {
+  domain: TrustDomain;
+  fromLevel: TrustLevel;
+  toLevel: TrustLevel;
+  reason: string;
+  timestamp: number;
+}
+
+export interface ActionAudit {
+  id: string;
+  timestamp: number;
+  trustLevel: TrustLevel;
+  domain: TrustDomain;
+  intent: string;
+  plan: string;
+  executed: boolean;
+  outcome: 'success' | 'failure' | 'pending' | 'rolled_back';
+  reasoning: string;
+  rollbackAvailable: boolean;
+}
+
+export interface TrustState {
+  levels: Record<TrustDomain, TrustLevel>;
+  evidence: Record<TrustDomain, TrustEvidence>;
+  promotions: TrustPromotion[];
+  demotions: TrustDemotion[];
+}
+
+export const DEFAULT_TRUST_CONFIG: TrustConfig = {
+  defaultLevel: 0,
+  autoPromote: true,
+  promotionThreshold: 10,
+  demotionThreshold: 3,
+  autoPromoteCeiling: 3,
+};
+
+export const TRUST_LEVEL_NAMES: Record<TrustLevel, string> = {
+  0: 'None',
+  1: 'Inform',
+  2: 'Suggest',
+  3: 'Act & Report',
+  4: 'Full Autonomy',
+};
+
+export const ALL_TRUST_DOMAINS: TrustDomain[] = [
+  'messaging',
+  'files',
+  'web',
+  'shell',
+  'finance',
+  'calendar',
+  'email',
+  'integrations',
+  'system',
+];