@nauticana/sail 1.1.34 → 1.1.35

package/src/agent/component/turn_thread.html

@@ -0,0 +1,27 @@
+<div class="turn-thread">
+  @for (turn of turns(); track turn.request_id) {
+    <article [class]="'turn-thread__turn turn-thread__turn--' + turn.status">
+      <header class="turn-thread__head">
+        <span class="turn-thread__title">{{ label(turn.task_kind) }} · {{ turn.input_summary }}</span>
+        <span class="turn-thread__status">{{ turn.status | sailCaption:'turn_status' }}</span>
+      </header>
+      <p class="turn-thread__meta">
+        {{ turn.created_at | date: 'medium' }}
+        @if (turn.cost_minor !== undefined && turn.currency && turn.exponent !== undefined) { · {{ turn.cost_minor | sailMoney:turn.currency:turn.exponent }} }
+        @if (turn.release_version) { · {{ turn.agent_name }} v{{ turn.release_version }} }
+      </p>
+      @if (turn.status === 'F' && turn.error_text) {
+        <p class="turn-thread__error" role="alert">{{ turn.error_text }}</p>
+      }
+      @if (resultTemplate(turn.task_kind); as template) {
+        <ng-container [ngTemplateOutlet]="template" [ngTemplateOutletContext]="{ $implicit: turn }" />
+      }
+    </article>
+  } @empty {
+    @if (!loading()) { <p class="turn-thread__empty">{{ emptyMessage() }}</p> }
+  }
+  @if (nextBefore()) {
+    <button matButton type="button" [disabled]="loading()" (click)="more()">Load more</button>
+  }
+  @if (errorMessage()) { <p class="turn-thread__error" role="alert">{{ errorMessage() }}</p> }
+</div>

package/src/agent/component/turn_thread.ts

@@ -0,0 +1,83 @@
+import { DatePipe, NgTemplateOutlet } from '@angular/common';
+import {
+  ChangeDetectionStrategy, Component, DestroyRef, Directive, OnInit, TemplateRef, contentChildren, inject, input, signal,
+} from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { BaseAsync } from '../../component/abstract/base_async';
+import { CaptionPipe } from '../../service/caption_pipe';
+import { MoneyPipe } from '../../service/money_pipe';
+import { ConversationTurn, TERMINAL_TURN_STATUSES } from '../model/conversation';
+import { ConversationService } from '../service/conversation.service';
+
+/**
+ * The result card of one task kind: `<ng-template sailTurnResult="kind" let-turn>…</ng-template>`.
+ * The template's context is the turn.
+ */
+@Directive({ selector: 'ng-template[sailTurnResult]' })
+export class TurnResultDirective {
+  readonly kind = input.required<string>({ alias: 'sailTurnResult' });
+  readonly template = inject<TemplateRef<{ $implicit: ConversationTurn }>>(TemplateRef);
+}
+
+/**
+ * The signed-in person's turns from `GET {base}turns`, newest first, with status captions, cost
+ * and release version, paged by `next_before` and reloaded every `pollMs` while a turn is
+ * nonterminal. Selector: <sail-turn-thread>.
+ */
+@Component({
+  selector: 'sail-turn-thread',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  imports: [DatePipe, NgTemplateOutlet, MatButtonModule, CaptionPipe, MoneyPipe],
+  templateUrl: './turn_thread.html',
+})
+export class TurnThreadComponent extends BaseAsync implements OnInit {
+  private readonly conversation = inject(ConversationService);
+
+  /** Only turns that served this work item; all of the person's turns when empty. */
+  readonly workRef = input('');
+  /** `task_kind` → label; the kind itself otherwise. */
+  readonly kindLabels = input<Record<string, string>>({});
+  readonly pollMs = input(10000);
+  readonly emptyMessage = input('Nothing yet.');
+
+  readonly turns = signal<ConversationTurn[]>([]);
+  readonly nextBefore = signal('');
+  private readonly results = contentChildren(TurnResultDirective);
+  private timer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor() {
+    super();
+    inject(DestroyRef).onDestroy(() => clearTimeout(this.timer));
+  }
+
+  ngOnInit(): void {
+    this.load();
+  }
+
+  /** Reloads the first page; the pages below it are dropped. */
+  load(): void {
+    clearTimeout(this.timer);
+    this.run(this.conversation.turns(this.workRef()), (page) => {
+      this.turns.set(page.turns);
+      this.nextBefore.set(page.next_before ?? '');
+      if (page.turns.some((t) => !TERMINAL_TURN_STATUSES.has(t.status))) {
+        this.timer = setTimeout(() => this.load(), Math.max(1000, this.pollMs()));
+      }
+    }, 'Failed to load the turns.');
+  }
+
+  more(): void {
+    this.run(this.conversation.turns(this.workRef(), this.nextBefore()), (page) => {
+      this.turns.update((rows) => [...rows, ...page.turns]);
+      this.nextBefore.set(page.next_before ?? '');
+    }, 'Failed to load more turns.');
+  }
+
+  label(kind: string): string {
+    return this.kindLabels()[kind] ?? kind;
+  }
+
+  resultTemplate(kind: string): TemplateRef<{ $implicit: ConversationTurn }> | undefined {
+    return this.results().find((r) => r.kind() === kind)?.template;
+  }
+}

package/src/agent/index.ts

@@ -21,3 +21,5 @@ export * from './component/decision_timeline';
 export * from './component/studio_tab';
 export * from './component/studio_page';
 export * from './component/approval_inbox';
+export * from './component/assistant_activity';
+export * from './component/turn_thread';

package/src/agent/model/agent_studio.ts

@@ -309,3 +309,66 @@ export interface AgentSettingChange {
   expected_agent_revision: number;
   expected_type_defaults_revision: number;
 }
+
+/** Captions for Scout's fixed `AgentReadiness` values, which no constant domain carries. */
+export const AGENT_READINESS_CAPTIONS: Record<string, string> = {
+  ready: 'Ready',
+  disabled: 'Disabled',
+  missing_model: 'No text model',
+  unpublished: 'Unpublished',
+  error: 'Invalid definition',
+  not_entitled: 'Not entitled',
+  needs_integration: 'Needs integration',
+  forbidden: 'Forbidden',
+};
+
+/** One enforced guardrail rule; `params` is the kind's JSON parameters. */
+export interface GuardrailRule {
+  id: string;
+  kind: string;
+  stages?: string[];
+  action: string;
+  severity: string;
+  params?: unknown;
+}
+
+/** Rules an agent inherits from one layer: B baseline, P platform, T tenant, Y type. */
+export interface InheritedGuardrails {
+  layer: string;
+  digest?: string;
+  rules: GuardrailRule[];
+}
+
+/** The layers an agent inherits, widest first, and its own rules, which only add or tighten. */
+export interface AgentGuardrails {
+  agent_name: string;
+  inherited: InheritedGuardrails[];
+  rules: GuardrailRule[];
+  /** Why the agent's rules no longer fit the inherited ones. */
+  problem?: string;
+  expected_agent_revision: number;
+}
+
+/** Replaces the agent's own rules as a whole; an empty list removes them. */
+export interface AgentGuardrailChange {
+  agent_name: string;
+  rules: GuardrailRule[];
+  expected_agent_revision: number;
+}
+
+/** One stored guardrail hit: rule ids and attribution, never the inspected content. */
+export interface SafetyEvent {
+  id: number;
+  version?: string;
+  policy_version?: string;
+  stage: string;
+  layer: string;
+  action: string;
+  severity: string;
+  rule_ids: string[];
+  actor_kind?: string;
+  actor_id?: string;
+  request_id?: string;
+  duration_ms: number;
+  occurred_at: string;
+}

package/src/agent/model/approval.ts

@@ -1,4 +1,6 @@
-/** Scout approval desk wire types (v1.2.7). Codes render through backend captions. */
+import { PrincipalRef } from './decision';
+
+/** Scout approval desk and MCP confirmation inbox wire types (v1.2.13). Codes render through backend captions. */
 
 /** A approved, X rejected, E edited (tool-call proposals only, with revised arguments). */
 export type ApprovalVerdict = 'A' | 'X' | 'E';
@@ -40,3 +42,37 @@ export interface ApprovalResolveRequest {
   /** The JSON object an `E` verdict runs the tool call with instead. */
   revised_arguments?: Record<string, unknown>;
 }
+
+/** `mcp_confirmation_status`: P pending, A approved, R running, D executed, F failed, U unknown, X declined, W withdrawn, T expired. */
+export type ConfirmationStatus = 'P' | 'A' | 'R' | 'D' | 'F' | 'U' | 'X' | 'W' | 'T';
+
+export interface ConfirmationKey {
+  tenant_id: number;
+  id: number;
+}
+
+/** One MCP tool call awaiting or past a person's confirmation; never its payload. */
+export interface Confirmation extends ConfirmationKey {
+  maker: PrincipalRef;
+  client_ref?: string;
+  tool: string;
+  payload_digest: string;
+  /** The product's preview of the complete action. */
+  preview?: unknown;
+  channel: string;
+  status: ConfirmationStatus;
+  approval_required: boolean;
+  expired: boolean;
+  expires_at: string;
+  created_at: string;
+  decided_at?: string;
+  decider?: PrincipalRef;
+  decision_note?: string;
+  error?: string;
+  completed_at?: string;
+  reconciler?: PrincipalRef;
+  reconcile_note?: string;
+  can_decide: boolean;
+  can_withdraw: boolean;
+  can_reconcile: boolean;
+}

package/src/agent/model/conversation.ts

@@ -36,6 +36,37 @@ export class ConversationStreamFailure extends Error {
   }
 }
 
+/** A `turn_status` code; C, F and X are terminal, as Scout's catalog marks them. */
+export type TurnStatus = 'Q' | 'R' | 'S' | 'U' | 'H' | 'O' | 'C' | 'F' | 'X';
+
+export const TERMINAL_TURN_STATUSES: ReadonlySet<string> = new Set<TurnStatus>(['C', 'F', 'X']);
+
+/** One turn of the signed-in person's history; cost fields are absent while nothing is settled. */
+export interface ConversationTurn {
+  request_id: string;
+  conversation_id: string;
+  agent_name: string;
+  release_version: string;
+  status: TurnStatus;
+  work_ref?: string;
+  task_kind: string;
+  input_summary: string;
+  error_text?: string;
+  /** The product's result card, handed to the kind's `sailTurnResult` template. */
+  result?: unknown;
+  created_at: string;
+  completed_at?: string;
+  cost_minor?: number;
+  currency?: string;
+  exponent?: number;
+}
+
+/** Newest first; `next_before` is absent on the last page. */
+export interface ConversationTurnPage {
+  turns: ConversationTurn[];
+  next_before?: string;
+}
+
 /** Where the app mounts Scout's ConversationHandler, e.g. '/api/wingmate/'. */
 export const CONVERSATION_BASE_PATH = new InjectionToken<string>('SailConversationBasePath', {
   providedIn: 'root',

package/src/agent/model/decision.ts

@@ -1,5 +1,3 @@
-import { ObjectRef } from './turn_event';
-
 /** A allowed, D denied, P pending (`audit_decision_outcome`). */
 export type DecisionOutcome = 'A' | 'D' | 'P';
 
@@ -14,12 +12,9 @@ export interface AuthorityRef {
   grantor?: PrincipalRef;
 }
 
-/**
- * One audit record as sail renders it. The audit endpoint is the app's, so the app maps its
- * response onto this shape; `id` is whatever key the endpoint gives a record.
- */
+/** One governed decision of the tenant (Scout `api.DecisionRecord`); evidence is a digest only. */
 export interface DecisionRecord {
-  id: string | number;
+  id: number;
   category: string;
   action: string;
   resource: string;
@@ -27,17 +22,26 @@ export interface DecisionRecord {
   reason: string;
   principal: PrincipalRef;
   authority?: AuthorityRef;
+  /** The client application the principal acted through. */
+  client_ref?: string;
+  work_ref?: string;
   scope_id?: string;
   release_version?: string;
   policy_id?: string;
   policy_version?: string;
   obligations?: string[];
-  evidence?: ObjectRef;
+  evidence_digest?: string;
   request_id: string;
   conversation_id?: string;
   occurred_at: string;
 }
 
+/** Newest first; `next_before` is absent on the last page. */
+export interface DecisionPage {
+  records: DecisionRecord[];
+  next_before?: number;
+}
+
 export interface DecisionCategoryGroup {
   category: string;
   records: DecisionRecord[];

package/src/agent/service/agent_studio.service.ts

@@ -3,6 +3,8 @@ import { Observable } from 'rxjs';
 import { BaseRestService } from '../../service/base_rest.service';
 import {
   AgentArchiveRequest,
+  AgentGuardrailChange,
+  AgentGuardrails,
   AgentAuditEvent,
   AgentCreateRequest,
   AgentDraft,
@@ -20,9 +22,11 @@ import {
   AgentSummary,
   AgentTestRequest,
   AgentTestResult,
+  SafetyEvent,
   StudioFeature,
   StudioModel,
 } from '../model/agent_studio';
+import { DecisionOutcome, DecisionPage } from '../model/decision';
 
 const studioBasePath = '/api/agent-studio/';
 
@@ -114,6 +118,31 @@ export class AgentStudioService extends BaseRestService {
     return this.http.get<StudioModel[]>(this.studioUrl('models'));
   }
 
+  /** Scout's optional `decisions` feature: the tenant's decision records, newest first. */
+  decisions(before = 0, limit = 0, category = '', outcome?: DecisionOutcome): Observable<DecisionPage> {
+    const params: Record<string, string> = {};
+    if (before) params['before'] = String(before);
+    if (limit) params['limit'] = String(limit);
+    if (category) params['category'] = category;
+    if (outcome) params['outcome'] = outcome;
+    return this.http.get<DecisionPage>(this.studioUrl('decisions'), { params });
+  }
+
+  /** Scout's optional `guardrails` feature. */
+  guardrails(agentName: string): Observable<AgentGuardrails> {
+    return this.http.get<AgentGuardrails>(this.studioUrl('guardrails'), { params: { agent_name: agentName } });
+  }
+
+  saveGuardrails(change: AgentGuardrailChange): Observable<AgentGuardrails> {
+    return this.http.post<AgentGuardrails>(this.studioUrl('guardrails'), change);
+  }
+
+  /** Newest first; pass the last id as `before` for the next page. */
+  safetyEvents(agentName: string, before = 0, limit = 50): Observable<SafetyEvent[]> {
+    return this.http.get<SafetyEvent[]>(this.studioUrl('safety-events'),
+      { params: { agent_name: agentName, before: String(before), limit: String(limit) } });
+  }
+
   private studioUrl(route: string): string {
     return this.url(studioBasePath + route);
   }

package/src/agent/service/approval.service.ts

@@ -1,18 +1,38 @@
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { BaseRestService } from '../../service/base_rest.service';
-import { ApprovalRequest, ApprovalResolveRequest } from '../model/approval';
+import { ApprovalRequest, ApprovalResolveRequest, Confirmation, ConfirmationKey } from '../model/approval';
 
-/** Client for Scout's approval desk under the fixed `/api/approval/` path. */
+const base = '/api/approval/';
+
+/** Client for Scout's approval desk and MCP confirmation inbox under the fixed `/api/approval/` path. */
 @Injectable({ providedIn: 'root' })
 export class ApprovalService extends BaseRestService {
   /** The requests the signed-in person may decide now, soonest deadline first. */
   pending(): Observable<ApprovalRequest[]> {
-    return this.http.get<ApprovalRequest[]>(this.url('/api/approval/pending'));
+    return this.http.get<ApprovalRequest[]>(this.url(base + 'pending'));
   }
 
   /** 409 when the request was reassigned or decided differently since it was read. */
   resolve(request: ApprovalResolveRequest): Observable<ApprovalRequest> {
-    return this.http.post<ApprovalRequest>(this.url('/api/approval/resolve'), request);
+    return this.http.post<ApprovalRequest>(this.url(base + 'resolve'), request);
+  }
+
+  /** Open confirmations and those created since `since` (RFC 3339), across the person's tenants. */
+  confirmations(since = ''): Observable<Confirmation[]> {
+    return this.http.get<Confirmation[]>(this.url(base + 'confirmations'), { params: since ? { since } : {} });
+  }
+
+  decideConfirmation(key: ConfirmationKey, approve: boolean, note = ''): Observable<Confirmation> {
+    return this.http.post<Confirmation>(this.url(base + 'confirmation/decide'), { ...key, approve, note });
+  }
+
+  withdrawConfirmation(key: ConfirmationKey): Observable<ConfirmationKey> {
+    return this.http.post<ConfirmationKey>(this.url(base + 'confirmation/withdraw'), key);
+  }
+
+  /** Records the verified outcome of an unknown confirmation: D executed or F failed. */
+  reconcileConfirmation(key: ConfirmationKey, outcome: 'D' | 'F', note = ''): Observable<Confirmation> {
+    return this.http.post<Confirmation>(this.url(base + 'confirmation/reconcile'), { ...key, outcome, note });
   }
 }

package/src/agent/service/conversation.service.ts

@@ -7,6 +7,7 @@ import {
   ConversationStreamError,
   ConversationStreamFailure,
   ConversationTurnAccepted,
+  ConversationTurnPage,
   ConversationTurnRequest,
 } from '../model/conversation';
 import { TurnReplyFrame } from '../model/reply_frame';
@@ -34,6 +35,15 @@ export class ConversationService extends BaseRestService {
     return this.http.post<ConversationTurnAccepted>(this.conversationUrl('turn'), request);
   }
 
+  /** The person's turns, newest first; `before` continues from a page's `next_before`. */
+  turns(workRef = '', before = '', limit = 0): Observable<ConversationTurnPage> {
+    const params: Record<string, string> = {};
+    if (workRef) params['work_ref'] = workRef;
+    if (before) params['before'] = before;
+    if (limit) params['limit'] = String(limit);
+    return this.http.get<ConversationTurnPage>(this.conversationUrl('turns'), { params });
+  }
+
   /** Cancel is a request: the turn stays open until its final frame arrives. */
   cancel(requestId: string, reason?: string): Observable<ConversationTurnAccepted> {
     return this.http.post<ConversationTurnAccepted>(this.conversationUrl('turn/cancel'), {

package/src/component/agency/agency_earnings_summary.html

@@ -10,15 +10,15 @@
   @for (balance of value.balances; track balance.currency) {
     <div class="agency-earnings-summary__metric" [attr.data-currency]="balance.currency">
       <span class="agency-earnings-summary__label">Held ({{ balance.currency }})</span>
-      <span class="agency-earnings-summary__value">{{ format(balance.heldMinor, balance.currency) }}</span>
+      <span class="agency-earnings-summary__value">{{ balance.heldMinor | sailMoney:balance.currency }}</span>
     </div>
     <div class="agency-earnings-summary__metric" [attr.data-currency]="balance.currency">
       <span class="agency-earnings-summary__label">Due ({{ balance.currency }})</span>
-      <span class="agency-earnings-summary__value">{{ format(balance.dueMinor, balance.currency) }}</span>
+      <span class="agency-earnings-summary__value">{{ balance.dueMinor | sailMoney:balance.currency }}</span>
     </div>
     <div class="agency-earnings-summary__metric" [attr.data-currency]="balance.currency">
       <span class="agency-earnings-summary__label">Paid ({{ balance.currency }})</span>
-      <span class="agency-earnings-summary__value">{{ format(balance.paidMinor, balance.currency) }}</span>
+      <span class="agency-earnings-summary__value">{{ balance.paidMinor | sailMoney:balance.currency }}</span>
     </div>
   }
 }

package/src/component/agency/agency_earnings_summary.ts

@@ -1,15 +1,15 @@
 import { ChangeDetectionStrategy, Component, input } from '@angular/core';
 import { AgencyEarnings } from '../../model/agency';
-import { formatMinorCurrency } from '../../util/money';
+import { MoneyPipe } from '../../service/money_pipe';
 
 @Component({
   selector: 'sail-agency-earnings-summary',
   changeDetection: ChangeDetectionStrategy.OnPush,
+  imports: [MoneyPipe],
   templateUrl: './agency_earnings_summary.html',
   host: { class: 'agency-earnings-summary' },
 })
 export class AgencyEarningsSummaryComponent {
   readonly earnings = input<AgencyEarnings | null>(null);
   readonly activeClients = input(0);
-  readonly format = formatMinorCurrency;
 }

package/src/component/agency/agency_payout_history.html

@@ -6,7 +6,7 @@
         @for (payout of payouts(); track payout.id) {
           <tr>
             <td>{{ payout.cutoffAt | date: 'yyyy-MM':'UTC' }}</td>
-            <td>{{ format(payout.amountMinor, payout.currency) }}</td>
+            <td>{{ payout.amountMinor | sailMoney:payout.currency }}</td>
             <td><sail-status-chip domain="agency_payout_status" [value]="payout.status" /></td>
             <td>{{ payout.paidAt ? (payout.paidAt | date: 'mediumDate':'UTC') : '' }}</td>
           </tr>

package/src/component/agency/agency_payout_history.ts

@@ -1,18 +1,17 @@
 import { DatePipe } from '@angular/common';
 import { ChangeDetectionStrategy, Component, input } from '@angular/core';
 import { AgencyPayout } from '../../model/agency';
-import { formatMinorCurrency } from '../../util/money';
+import { MoneyPipe } from '../../service/money_pipe';
 import { StatusChipComponent } from '../billing/status_chip';
 
 @Component({
   selector: 'sail-agency-payout-history',
   changeDetection: ChangeDetectionStrategy.OnPush,
-  imports: [DatePipe, StatusChipComponent],
+  imports: [DatePipe, StatusChipComponent, MoneyPipe],
   templateUrl: './agency_payout_history.html',
   host: { class: 'agency-payout-history' },
 })
 export class AgencyPayoutHistoryComponent {
   readonly payouts = input<AgencyPayout[]>([]);
   readonly emptyMessage = input('No agency payouts yet.');
-  readonly format = formatMinorCurrency;
 }

package/src/component/agency/commission_ledger.html

@@ -7,7 +7,7 @@
           <tr [class.commission-ledger__reversal]="entry.entryType === 'R'">
             <td>{{ entry.clientName }}</td>
             <td>{{ entry.periodStart | date: 'yyyy-MM-dd':'UTC' }} – {{ entry.periodEnd | date: 'yyyy-MM-dd':'UTC' }}</td>
-            <td>{{ format(entry.amountMinor, entry.currency) }}</td>
+            <td>{{ entry.amountMinor | sailMoney:entry.currency }}</td>
             <td><sail-status-chip domain="agency_commission_status" [value]="entry.status" /></td>
           </tr>
         }

package/src/component/agency/commission_ledger.ts

@@ -1,18 +1,17 @@
 import { DatePipe } from '@angular/common';
 import { ChangeDetectionStrategy, Component, input } from '@angular/core';
 import { AgencyEarningEntry } from '../../model/agency';
-import { formatMinorCurrency } from '../../util/money';
+import { MoneyPipe } from '../../service/money_pipe';
 import { StatusChipComponent } from '../billing/status_chip';
 
 @Component({
   selector: 'sail-commission-ledger',
   changeDetection: ChangeDetectionStrategy.OnPush,
-  imports: [DatePipe, StatusChipComponent],
+  imports: [DatePipe, StatusChipComponent, MoneyPipe],
   templateUrl: './commission_ledger.html',
   host: { class: 'commission-ledger' },
 })
 export class CommissionLedgerComponent {
   readonly entries = input<AgencyEarningEntry[]>([]);
   readonly emptyMessage = input('No commission activity yet.');
-  readonly format = formatMinorCurrency;
 }

package/src/component/billing/plan_selector.ts

@@ -37,7 +37,7 @@ export class PlanSelectorComponent {
     const overrides = this.ctaLabels();
     const out: Record<string, string> = {};
     for (const plan of this.plans()) {
-      const mode = plan.activationMode ?? '';
+      const mode = plan.activationMode;
       out[plan.id] = overrides[mode] ?? PlanSelectorComponent.DEFAULT_CTA[mode] ?? 'Choose';
     }
     return out;

package/src/component/billing/price_selector.ts

@@ -1,12 +1,12 @@
 import { ChangeDetectionStrategy, Component, ViewEncapsulation, computed, input, output } from '@angular/core';
 import { PlanPrice } from '../../model/appdata';
-import { formatCurrency, PERIOD_TYPE_INFO } from '../../util/money';
+import { formatMinor, PERIOD_TYPE_INFO } from '../../util/money';
 
 /** Per-offer view model for accessible, currency-formatted rendering. */
 interface OfferRow {
   key:        string;   // stable id for tracking / selection (priceId or composite)
   price:      PlanPrice;
-  amountText: string;   // currency-formatted major amount
+  amountText: string;   // amount formatted at the offer's exponent
   cycleText:  string;   // "Monthly" / "Annual" / …
   termText:   string;   // commitment note, '' when the term is a single cycle
 }
@@ -16,8 +16,8 @@ interface OfferRow {
  * sells several offers (billing cycle × commitment term); the customer picks one
  * at checkout, then its `priceId` feeds `<sail-checkout-button [priceId]>`.
  *
- * Pure presentational — stateless. Amounts are formatted with `Intl` from each
- * offer's currency, so non-2-decimal currencies (JPY 0, BHD 3) render correctly.
+ * Pure presentational — stateless. Amounts are minor units formatted at the
+ * exponent keel sends with each offer.
  * Period codes map to copy via `[cycleLabels]` (override/extend the defaults).
  */
 @Component({
@@ -45,7 +45,7 @@ export class PriceSelectorComponent {
       return {
         key:        p.priceId || `${p.billingCycle}-${p.termType}-${p.termCount}`,
         price:      p,
-        amountText: formatCurrency(p.amount, p.currency),
+        amountText: formatMinor(p.amountMinor, p.currency, p.exponent),
         cycleText:  cycleLabel(p.billingCycle),
         termText:   singleCycle ? '' : `${p.termCount}-${termNoun(p.termType)} commitment`,
       };

package/src/component/payout/bank_info_form.html

@@ -9,12 +9,12 @@
     <mat-form-field appearance="outline" class="full-width">
       <mat-label>Country</mat-label>
       <mat-select formControlName="countryCode">
-        @for (c of countryProfiles(); track c.code) {
-          <mat-option [value]="c.code">{{ c.label }} ({{ c.currency }})</mat-option>
+        @for (c of options()?.countries ?? []; track c.Id) {
+          <mat-option [value]="c.Id">{{ c.Caption }} ({{ c.Currency }})</mat-option>
         }
       </mat-select>
     </mat-form-field>
-    <p class="hint">Sets your tax ID format + payout currency</p>
+    <p class="hint">Sets your payout currency</p>
 
     <mat-form-field appearance="outline" class="full-width">
       <mat-label>Account holder name</mat-label>
@@ -23,10 +23,19 @@
     <p class="hint">Legal name on the bank account (must match government ID)</p>
 
     <mat-form-field appearance="outline" class="full-width">
-      <mat-label>{{ taxIdLabel() }}</mat-label>
-      <input matInput formControlName="taxId" [placeholder]="taxIdPlaceholder()">
+      <mat-label>Tax ID type</mat-label>
+      <mat-select formControlName="taxIdType">
+        @for (t of options()?.taxIdTypes ?? []; track t.code) {
+          <mat-option [value]="t.code">{{ t.caption }}</mat-option>
+        }
+      </mat-select>
+    </mat-form-field>
+
+    <mat-form-field appearance="outline" class="full-width">
+      <mat-label>Tax ID</mat-label>
+      <input matInput formControlName="taxId">
     </mat-form-field>
-    <p class="hint">{{ taxIdHint() }}</p>
+    <p class="hint">Shared with the tax authority for annual reporting</p>
 
     <mat-form-field appearance="outline" class="full-width">
       <mat-label>Billing address</mat-label>