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));

webhook.register(event: string, url: string, secret: string): { id: string; event: string; url: string }

const hook = mentu.webhook.register(
  'cir.capture',
  'https://myapp.com/hook',
  'my-secret-at-least-16ch'
);
console.log(`Registered: ${hook.id}`);

webhook.list(): WebhookRegistration[]

interface WebhookRegistration {
  id: string;
  event: string;
  url: string;
  active: string;     // "true" or "false"
  created_at: string;  // ISO 8601 timestamp
}

const hooks = mentu.webhook.list();
for (const h of hooks) {
  console.log(`${h.id}: ${h.event} → ${h.url} (active: ${h.active})`);
}

webhook.delete(id: string): { deleted: boolean }

const result = mentu.webhook.delete('wh_abc123');
console.log('Deleted:', result.deleted);

webhook.test(id: string): WebhookTestResult

interface WebhookTestResult {
  delivered: boolean;
  response_code?: number;
  error?: string;
}

const result = mentu.webhook.test('wh_abc123');
if (result.delivered) {
  console.log(`Delivered successfully (HTTP ${result.response_code})`);
} else {
  console.log(`Delivery failed: ${result.error}`);
}

worker.create(name: string, options?: { template?: string }): { name: string; path: string }

const w = mentu.worker.create('ingest-proxy', { template: 'supabase' });
console.log(`Created worker at ${w.path}`);

worker.deploy(name: string, options?: { minify?: boolean }): WorkerDeployResult

interface WorkerDeployResult {
  name: string;
  url: string;
  deployed: boolean;
}

const result = mentu.worker.deploy('ingest-proxy', { minify: true });
console.log(`Deployed to ${result.url}`);

worker.list(): WorkerInfo[]

interface WorkerInfo {
  name: string;
  id: string;
  created_on: string;
  modified_on: string;
}

const workers = mentu.worker.list();
for (const w of workers) {
  console.log(`${w.name} (${w.id})`);
}

worker.status(name: string): WorkerInfo

const info = mentu.worker.status('ingest-proxy');
console.log(`Last modified: ${info.modified_on}`);

worker.delete(name: string): { deleted: boolean }

const result = mentu.worker.delete('old-worker');
console.log('Deleted:', result.deleted);

worker.secret.set(workerName: string, key: string, value: string): void

mentu.worker.secret.set('ingest-proxy', 'SUPABASE_KEY', 'sbp_abc123');

worker.secret.delete(workerName: string, key: string): void

mentu.worker.secret.delete('ingest-proxy', 'OLD_KEY');

worker.secret.list(workerName: string): string[]

const secrets = mentu.worker.secret.list('ingest-proxy');
console.log(`Secrets: ${secrets.join(', ')}`);

ratchet.check(options?: RatchetCheckOptions): RatchetResult

interface RatchetResult {
  passed: boolean;
  violations: RatchetViolation[];
}
 
interface RatchetViolation {
  name: string;    // ratchet rule name
  pattern: string; // regex or glob that was counted
  count: number;   // current count
  limit: number;   // baseline limit
}

const result = mentu.ratchet.check({ source: 'src/' });
if (!result.passed) {
  for (const v of result.violations) {
    console.log(`${v.name}: ${v.count}/${v.limit} (${v.pattern})`);
  }
}

ratchet.baseline(options?: RatchetCheckOptions): void

mentu.ratchet.baseline({ source: 'src/' });
console.log('Baseline updated');

plugin.list(): PluginInfo[]

interface PluginInfo {
  name: string;
  version?: string;
  hooks: string[];  // hook events this plugin listens to
  tools: string[];  // tools this plugin provides
}

const plugins = mentu.plugin.list();
for (const p of plugins) {
  console.log(`${p.name}@${p.version ?? 'unknown'}: ${p.hooks.length} hooks, ${p.tools.length} tools`);
}

dispatch.send(tool: string, params?: Record<string, unknown>): DispatchResult

interface DispatchResult {
  id: string;     // dispatch job ID
  status: string; // initial status (e.g., 'queued')
}

const job = mentu.dispatch.send('crawlio.search_api', { query: 'auth' });
console.log(`Dispatched: ${job.id} (${job.status})`);

dispatch.status(id: string): Record<string, unknown>

const status = mentu.dispatch.status('dsp_abc123');
console.log(JSON.stringify(status, null, 2));

dispatch.list(): DispatchToolInfo[]

interface DispatchToolInfo {
  name: string;   // tool name
  source: string; // provider (e.g., 'mcp:crawlio', 'builtin')
}

const tools = mentu.dispatch.list();
for (const t of tools) {
  console.log(`${t.name} (${t.source})`);
}

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');