cir.query(options?: CIRQueryOptions): CIRSignal[]

interface CIRSignal {
  id: string;
  type: string;
  body: string;
  domain?: string;
  confidence?: number;
  source?: string;
  created_at?: string;
  tags?: string[];
}

// Get the 10 most recent observation signals
const signals = mentu.cir.query({ type: 'observation', limit: 10 });
for (const s of signals) {
  console.log(`[${s.type}] ${s.body} (confidence: ${s.confidence})`);
}

cir.capture(body: string, options?: CIRCaptureOptions): { id: string }

const result = mentu.cir.capture('API latency exceeded 500ms threshold', {
  type: 'observation',
  domain: 'infrastructure',
  confidence: 0.95,
  source: 'health-script',
  tags: ['latency', 'alert'],
});
console.log(`Captured signal: ${result.id}`);

cir.search(text: string, options?: CIRQueryOptions): CIRSignal[]

const matches = mentu.cir.search('authentication failure', { limit: 5 });
console.log(`Found ${matches.length} matching signals`);

cir.contradictions(): CIRSignal[]

const contradictions = mentu.cir.contradictions();
if (contradictions.length > 0) {
  console.log(`${contradictions.length} contradictions detected:`);
  for (const c of contradictions) {
    console.log(`  - ${c.body}`);
  }
}

cir.stats(): CIRStats

interface CIRStats {
  signals: number;
  relations: number;
  embeddings: number;
  patterns: number;
  contradictions: number;
  database_size_bytes: number;
}

const stats = mentu.cir.stats();
console.log(`CIR: ${stats.signals} signals, ${stats.contradictions} contradictions`);
console.log(`Database: ${(stats.database_size_bytes / 1024 / 1024).toFixed(1)} MB`);

vault.get(key: string, options?: { scope?: string }): string | null

const apiKey = mentu.vault.get('OPENAI_KEY');
if (apiKey) {
  console.log(`Key found: ${apiKey.slice(0, 8)}...`);
} else {
  console.log('No API key stored');
}

vault.set(key: string, value: string, options?: { scope?: string }): void

mentu.vault.set('DEPLOY_TOKEN', 'ghp_abc123', { scope: 'ci' });

vault.delete(key: string, options?: { scope?: string }): void

mentu.vault.delete('OLD_TOKEN');

vault.list(options?: { scope?: string }): string[]

const keys = mentu.vault.list();
console.log(`Vault contains ${keys.length} keys: ${keys.join(', ')}`);
 
// List keys in a specific scope
const ciKeys = mentu.vault.list({ scope: 'ci' });

sequence.run(name: string, options?: SequenceRunOptions): string

const output = mentu.sequence.run('cir-audit', {
  vars: { THRESHOLD: '3', DOMAIN: 'infrastructure' },
});
console.log('Sequence output:', output);

sequence.list(): Array<{ name: string; type: string }>

const recipes = mentu.sequence.list();
for (const r of recipes) {
  console.log(`${r.name} (${r.type})`);
}

temporal.list(): TemporalEntry[]

interface TemporalEntry {
  name: string;
  schedule: string;        // cron expression
  target: string;          // sequence or script target
  enabled: boolean;
  last_run?: string;       // ISO 8601 timestamp
  next_run?: string;       // ISO 8601 timestamp
  consecutive_failures: number;
  circuit_broken: boolean; // true if circuit breaker has tripped
}

const temporals = mentu.temporal.list();
for (const t of temporals) {
  const status = t.circuit_broken ? 'BROKEN' : t.enabled ? 'active' : 'disabled';
  console.log(`${t.name}: ${t.schedule} [${status}]`);
}

temporal.enable(name: string): void

mentu.temporal.enable('daily-health');

temporal.disable(name: string): void

mentu.temporal.disable('daily-health');

temporal.status(name: string): Record<string, unknown>

const status = mentu.temporal.status('daily-health');
console.log(JSON.stringify(status, null, 2));

temporal.fire(name: string): string

const output = mentu.temporal.fire('daily-health');
console.log('Fired temporal:', output);

ledger.verify(): { valid: boolean; entries: number }

const result = mentu.ledger.verify();
if (result.valid) {
  console.log(`Ledger valid: ${result.entries} entries`);
} else {
  console.log('Ledger integrity check FAILED');
  mentu.notify.send('Ledger Alert', 'Integrity check failed');
}

notify.send(title: string, message: string): void

mentu.notify.send('Build Complete', 'All 42 tests passed');

health.check(): Record<string, unknown>

const health = mentu.health.check();
console.log(JSON.stringify(health, null, 2));

vars: Readonly<Record<string, string>>

mentu script run my-script --var ENV=production --var THRESHOLD=5

const env = mentu.vars.ENV ?? 'development';
const threshold = parseInt(mentu.vars.THRESHOLD ?? '10', 10);
 
console.log(`Running in ${env} with threshold ${threshold}`);

workspace: { path: string }

console.log(`Workspace: ${mentu.workspace.path}`);

await servers.<server-id>.call(tool: string, args?: Record<string, unknown>): Promise<unknown>

// Call a tool on the 'crawlio' MCP server
const result = await servers.crawlio.call('search_api', {
  query: 'authentication',
  limit: 10,
});
console.log(JSON.stringify(result, null, 2));

sleep(ms: number): Promise<void>

console.log('Waiting 5 seconds...');
await sleep(5000);
console.log('Done');