Examples

Practical examples demonstrating how to use R-Think in real-world engineering scenarios. Each example is copy-pasteable and includes error handling and expected output.

Minimal Mission

The smallest valid cognitive mission: a single observation with a required rule.

minimal.ts typescript

import { Runtime, Protocol, Rule } from '@r-think/core';

const mission = Runtime.create({
  id: 'minimal',
  protocol: Protocol.sequential,
  rules: [Rule.required('observation')]
});

const result = await mission.execute({
  observation: 'System uptime reported as 99.98%'
});

console.log(result.validated); // true

L0 Mission

A minimal-depth mission with artifact capture. L0 requires basic trace only.

l0-mission.ts typescript

import { Runtime, Protocol, Rule, Artifact } from '@r-think/core';

const mission = Runtime.create({
  id: 'alert-check',
  protocol: Protocol.sequential,
  rules: [Rule.required('observation')],
  adaptiveDepth: 'L0',
  artifacts: [Artifact.trace()]
});

const result = await mission.execute({
  observation: 'CPU alert triggered on node-01'
});

console.log(result.trace.steps[0].name); // observe

L1 Mission

A low-risk mission that validates each claim and preserves evidence.

l1-mission.ts typescript

import { Runtime, Protocol, Rule, Artifact } from '@r-think/core';

const mission = Runtime.create({
  id: 'log-analysis',
  protocol: Protocol.define({
    steps: [
      { name: 'observe', action: (ctx) => ingestLogs(ctx.input) },
      { name: 'validate', action: (ctx) => validatePatterns(ctx.matches) },
      { name: 'decide', action: (ctx) => classifyAnomaly(ctx.validated) }
    ]
  }),
  rules: [Rule.required('observation')],
  adaptiveDepth: 'L1',
  artifacts: [Artifact.trace(), Artifact.evidence()]
});

const result = await mission.execute({
  observation: '500 errors exceed 5% on /api/checkout'
});

console.log(result.output.classification); // anomaly / normal

L2 Mission

A medium-risk mission that requires authority gates and full evidence graph validation before acceptance.

l2-mission.ts typescript

import { Runtime, Protocol, Rule, Artifact, EvidenceGraph } from '@r-think/core';

const evidence = new EvidenceGraph();
evidence.addSource({ id: 's1', type: 'metric', reference: 'gateway-latency' });
evidence.addObservation({ id: 'o1', sourceId: 's1', claim: 'Latency above threshold' });
evidence.addEvidence({ id: 'e1', observationId: 'o1', artifact: 'trace-l1', confidence: 'high' });

const mission = Runtime.create({
  id: 'incident-response',
  protocol: Protocol.define({
    steps: [
      { name: 'observe', action: (ctx) => captureMetrics(ctx.input) },
      { name: 'understand', action: (ctx) => buildIncidentContext(ctx.metrics) },
      { name: 'validate', action: (ctx) => validateEvidence(evidence) },
      { name: 'decide', action: (ctx) => proposeRemediation(ctx.context) },
      { name: 'accept', action: (ctx) => authorityGate(ctx.decision, 'domain-owner') }
    ]
  }),
  rules: [Rule.required('observation')],
  adaptiveDepth: 'L2',
  artifacts: [Artifact.trace(), Artifact.evidence(), Artifact.metrics()]
});

const result = await mission.execute({
  observation: 'Checkout latency p99 = 4.2s'
});

console.log(result.output.authorityAccepted); // true

L3 Mission

A high-risk mission that exposes the Inspector for independent review and replay.

l3-mission.ts typescript

import { Runtime, Protocol, Rule, Artifact, EvidenceGraph } from '@r-think/core';
import { Inspector } from '@r-think/inspector';

const mission = Runtime.create({
  id: 'safety-critical',
  protocol: Protocol.define({
    steps: [
      { name: 'observe', action: (ctx) => sensorIngest(ctx.input) },
      { name: 'validate', action: (ctx) => multiSourceCorroboration(ctx.readings) },
      { name: 'decide', action: (ctx) => safetyDecision(ctx.corroborated) },
      { name: 'accept', action: (ctx) => independentReview(ctx.decision) }
    ]
  }),
  rules: [Rule.required('observation'), Rule.type('observation', 'string')],
  adaptiveDepth: 'L3',
  artifacts: [Artifact.trace(), Artifact.evidence(), Artifact.metrics()]
});

const result = await mission.execute({
  observation: 'Brake temperature sensor reports 820 C'
});

const inspector = new Inspector({ source: 'local' });
const view = await inspector.inspect(result.trace.id);
await inspector.replay(result.trace.id);

Artifact Registration

Control which artifacts the runtime captures by attaching Artifact configurations to the mission.

artifact-registration.ts typescript

import { Runtime, Artifact } from '@r-think/core';

const mission = Runtime.create({
  id: 'artifact-registration',
  protocol: Protocol.sequential,
  rules: [Rule.required('observation')],
  artifacts: [
    Artifact.trace({ includeInput: true, includeOutput: true }),
    Artifact.evidence({ store: 'local' }),
    Artifact.metrics({ includeTiming: true })
  ]
});

const result = await mission.execute({
  observation: 'Deployment completed'
});

console.log(result.trace.steps);      // Execution record
console.log(result.evidence);         // Evidence records
console.log(result.metrics);          // Timing and quality metrics

Tip

Use Artifact.prune() to remove old artifacts and control storage growth.

Evidence Graph

Build an evidence graph to connect source, observation, claim, evidence, decision, and acceptance nodes.

evidence-graph.ts typescript

import { EvidenceGraph } from '@r-think/core';

const graph = new EvidenceGraph();

graph.addSource({ id: 'src-1', type: 'sensor', reference: 'temp-sensor-01' });
graph.addObservation({ id: 'obs-1', sourceId: 'src-1', claim: 'Temperature exceeds operating range' });
graph.addEvidence({ id: 'ev-1', observationId: 'obs-1', artifact: 'trace-001', confidence: 'high' });
graph.addDecision({ id: 'dec-1', evidenceIds: ['ev-1'], authority: 'operator', result: 'maintenance-required' });

const view = graph.toGraph();
console.log(view.nodes.length); // 4

Router Decision

The router selects a capablity or provider based on mission requirement, provider status, and rejection reason.

router-decision.ts typescript

import { Router, ProviderRegistry } from '@r-think/core';

const registry = new ProviderRegistry();
registry.register('summarizer', { provider: 'core', status: 'active' });
registry.register('translator', { provider: 'external', status: 'active' });

const router = new Router({ registry });

const route = await router.resolve({
  requiredCapability: 'summarizer',
  acceptableStatus: ['active']
});

console.log(route.provider); // core

Persistence and Replay

Persist mission events and replay the full execution history for debugging and audit.

persistence-replay.ts typescript

import { Runtime, Protocol, Rule, Persistence, ReplayEngine } from '@r-think/core';

const mission = Runtime.create({
  id: 'persisted-mission',
  protocol: Protocol.sequential,
  rules: [Rule.required('observation')],
  persistence: { driver: 'local' }
});

const result = await mission.execute({ observation: 'First run' });

await Persistence.persist(result.events);

const replay = new ReplayEngine({ source: 'local' });
const replayResult = await replay.run(result.missionId);
console.log(replayResult.completed); // true

Inspector Integration

Connect the Inspector to a mission endpoint to view timeline, evidence graph, and replay controls.

inspector.ts typescript

import { Inspector } from '@r-think/inspector';

const inspector = new Inspector({
  source: 'local',
  endpoint: 'http://localhost:4001'
});

const view = await inspector.inspect('mission-001');
console.log(view.timeline.length); // number of steps
console.log(view.evidenceGraph.nodes); // evidence nodes

await inspector.replay('mission-001');
// Replay proceeds step-by-step from persisted history