Moves: SDK

1const moves = await beliefs.moves.list({ topN: 3 })
2for (const m of moves) {
3  console.log(m.action, m.rationale, m.expectedDeltaH)
4}

1const result = await beliefs.moves.generate({
2  beliefId: 'belief-abc123',
3  includeJustification: true,
4})
5
6if (result.move) {
7  showRecommendation(result.move, result.move.justification)
8} else if (result.reason === 'belief_complete') {
9  showDoneState()
10}

1{
2  success: true
3  move: ThinkingMoveWithJustification | null
4  target: ResolvedCanonicalTarget
5  reason?: 'belief_complete'    // present when no move was generated
6  durationMs: number
7}

1await beliefs.moves.act(move.id, 'accept')
2await beliefs.moves.act(move.id, 'snooze')
3await beliefs.moves.act(move.id, 'dismiss')

1{
2  success: true
3  move: ThinkingMove   // updated with new status / resolvedAt
4  durationMs: number
5}

1const ranked = await beliefs.moves.rank({ topN: 3, budget: 0.05 })
2for (const m of ranked) {
3  console.log(`${m.action}/${m.subType} → q=${m.qValue} cost=${m.cost} voi=${m.valueOfInformation}`)
4}

1{
2  id, summary, targetId
3  targetKind: 'claim' | 'goal' | 'gap'
4  action: string                            // 'gather_evidence', 'clarify', ...
5  subType: string                           // 'design_test', 'tradeoff_mapping', ...
6  qValue: number                            // composite ranking score (higher = better)
7  expectedInfoGain: number                  // expected info-gain from executing this move
8  cost: number                              // USD / tokens / effort units
9  valueOfInformation: number                // info-gain / max(cost, 0.01)
10  executor: 'agent' | 'user' | 'both'
11  confidence: 'low' | 'medium' | 'high'
12}

1const summary = await beliefs.moves.forecast('gather_evidence', { depth: 3, rollouts: 50 })
2console.log(`score=${summary.score} confidence=${summary.confidence}`)
3console.log(`will sharpen: ${summary.willAnswer.join(', ')}`)

1const cascade = await beliefs.moves.cascade('gather_evidence', {
2  targetBeliefId: 'b-market-size',
3  magnitude: 0.3,
4})
5for (const shift of cascade.willShift) {
6  if (shift.severity !== 'none') {
7    console.warn(`Agent ${shift.agent}: ${shift.summary}`)
8  }
9}

1{
2  id, summary
3  /** Aggregate cascade risk: 0 = isolated, 1 = every known agent feels it. */
4  score: number
5  willShift: Array<{
6    agent: string
7    summary: string
8    severity: 'none' | 'low' | 'medium' | 'high'
9    affectedBeliefs?: string[]
10  }>
11  confidence: 'low' | 'medium' | 'high'
12  why: string
13}

1const forecasts = await beliefs.forecast.predict(
2  ['gather_evidence_apac', 'design_test_market_size', 'reframe_question'],
3  { horizon: 3, rollouts: 50 },
4)
5
6const ranked = [...forecasts].sort((a, b) => b.score - a.score)
7console.log(`Best action: ${ranked[0].summary} (score=${ranked[0].score})`)

1{
2  id: string
3  summary: string
4  /** 0–1 expected value. Higher = more useful. */
5  score: number
6  /** Plain-English belief topics most likely to sharpen under this action. */
7  willAnswer: string[]
8  /** Confidence in the forecast itself, not the action. */
9  confidence: 'low' | 'medium' | 'high'
10  /** Short human explanation. */
11  why: string
12  suggestion?: string
13  relatedBeliefs?: string[]
14}

1{
2  id: string
3  targetId: string
4  targetEntityType?: 'claim' | 'goal' | 'gap' | 'risk' | string
5  targetEntityId?: string
6  action: 'clarify' | 'gather_evidence' | 'resolve_uncertainty' | 'compare_paths' | string
7  rationale: string
8  expectedDeltaH: number       // expected uncertainty reduction from acting on this move
9  status: 'suggested' | 'accepted' | 'snoozed' | 'dismissed' | string
10  suggestedModality?: string   // hint about how to surface (e.g., 'inline', 'banner')
11  qValue?: number              // recommender's internal score, when available
12  executor?: 'agent' | 'user' | 'both'
13  createdAt: string
14  updatedAt?: string
15  resolvedAt?: string
16}