@nauticana/sail 1.1.34 → 1.1.36

package/src/agent/component/studio_page.html

@@ -10,7 +10,7 @@
               <button type="button" class="studio__agent" [class.selected]="agent.agent_name === selectedName()"
                 [attr.aria-current]="agent.agent_name === selectedName()" (click)="select(agent.agent_name)">
                 <span class="studio__agent-name">{{ agent.display_name }}</span>
-                <span [class]="'studio__readiness studio__readiness--' + agent.readiness">{{ agent.readiness }}</span>
+                <span [class]="'studio__readiness studio__readiness--' + agent.readiness">{{ readinessCaption(agent.readiness) }}</span>
                 <span class="studio__agent-meta">
                   @if (agent.is_default) { <span>Default</span> }
                   @if (agent.archived) { <span>Archived</span> }
@@ -232,6 +232,40 @@
               </ul>
             }
           }
+          @case ('guardrails') {
+            @if (guardrails(); as g) {
+              @if (g.problem) { <p class="studio__error" role="alert">{{ g.problem }}</p> }
+              @for (layer of g.inherited; track layer.layer) {
+                <h3>Inherited · layer {{ layer.layer }}@if (layer.digest) { · {{ layer.digest.slice(0, 12) }} }</h3>
+                <pre class="studio__rules">{{ layer.rules | json }}</pre>
+              }
+              <h3>This agent's rules</h3>
+              <p>Rules only add to the inherited ones or tighten a rule of the same id.</p>
+              <mat-form-field class="studio__rules-editor">
+                <mat-label>Rules (JSON array)</mat-label>
+                <textarea matInput rows="10" #rules [value]="g.rules | json" [disabled]="!can('EDIT', undefined, 'guardrails')"></textarea>
+              </mat-form-field>
+              @if (can('EDIT', undefined, 'guardrails')) {
+                <button matButton="elevated" type="button" [disabled]="busy()" (click)="saveGuardrails(rules.value)">Save rules</button>
+              }
+              <h3>Safety events</h3>
+              <ul class="studio__safety-events">
+                @for (event of safetyEvents(); track event.id) {
+                  <li>
+                    {{ event.occurred_at | date: 'medium' }} · {{ event.stage }} · layer {{ event.layer }} · {{ event.action }} ({{ event.severity }})
+                    · rules {{ event.rule_ids.join(', ') }}
+                    @if (event.version) { · v{{ event.version }} }
+                    @if (event.actor_kind) { · {{ event.actor_kind }} {{ event.actor_id }} }
+                  </li>
+                } @empty {
+                  <li>No safety event recorded.</li>
+                }
+              </ul>
+              @if (!safetyExhausted()) {
+                <button matButton type="button" [disabled]="busy()" (click)="loadSafetyEvents()">Load more</button>
+              }
+            }
+          }
           @default {
             @if (productTab(); as t) {
               @if (selected(); as agent) {

package/src/agent/component/studio_page.ts

@@ -13,8 +13,9 @@ import { BaseAuthService } from '../../service/auth.service';
 import { CaptionPipe } from '../../service/caption_pipe';
 import { LabelOption, LabelService } from '../../service/label.service';
 import {
-  AgentAuditEvent, AgentDraft, AgentLanguageDraft, AgentMergeMode, AgentModelSelection, AgentRelease, AgentSetting,
-  AgentSettings, AgentSummary, AgentTestResult, StudioFeature, StudioModel,
+  AGENT_READINESS_CAPTIONS, AgentAuditEvent, AgentReadiness, AgentDraft, AgentGuardrails, AgentLanguageDraft, AgentMergeMode,
+  AgentModelSelection, AgentRelease, AgentSetting, AgentSettings, AgentSummary, AgentTestResult, GuardrailRule,
+  SafetyEvent, StudioFeature, StudioModel,
 } from '../model/agent_studio';
 import { AgentStudioService } from '../service/agent_studio.service';
 import { ReleaseSectionDiff, diffReleaseSections } from '../util/release_diff';
@@ -29,11 +30,12 @@ const CORE_TABS = [
   { id: 'test', label: 'Test' },
   { id: 'history', label: 'History' },
 ];
+const GUARDRAILS_TAB = { id: 'guardrails', label: 'Guardrails' };
 
 /**
  * Embeddable Agent Studio over Scout's core `agents` feature: a grouped agent rail and tabs
- * for the draft, prompts, scoped settings, tests, and release history, plus product tabs
- * declared with `sailStudioTab`. A control shows only when the feature manifest lists its
+ * for the draft, prompts, scoped settings, tests, and release history, a Guardrails tab when the
+ * manifest lists that feature, plus product tabs declared with `sailStudioTab`. A control shows only when the feature manifest lists its
  * action and the caller holds the grant; hiding is never the authorization, Scout decides.
  * Selector: <sail-studio-page>.
  */
@@ -66,6 +68,9 @@ export class StudioPageComponent implements OnInit {
   readonly settings = signal<AgentSettings | null>(null);
   readonly releases = signal<AgentRelease[]>([]);
   readonly audit = signal<AgentAuditEvent[]>([]);
+  readonly guardrails = signal<AgentGuardrails | null>(null);
+  readonly safetyEvents = signal<SafetyEvent[]>([]);
+  readonly safetyExhausted = signal(true);
   readonly diff = signal<{ version: number; previous: number; rows: ReleaseSectionDiff[] } | null>(null);
   readonly testResult = signal<AgentTestResult | null>(null);
   readonly tab = signal('overview');
@@ -79,7 +84,10 @@ export class StudioPageComponent implements OnInit {
   private readonly pending = signal(0);
   readonly busy = computed(() => this.pending() > 0);
 
-  readonly tabs = computed(() => [...CORE_TABS, ...this.productTabs().map((t) => ({ id: t.id(), label: t.label() }))]);
+  readonly tabs = computed(() => [
+    ...CORE_TABS, ...(this.feature('guardrails') ? [GUARDRAILS_TAB] : []),
+    ...this.productTabs().map((t) => ({ id: t.id(), label: t.label() })),
+  ]);
   readonly productTab = computed(() => this.productTabs().find((t) => t.id() === this.tab()));
   readonly selected = computed(() => this.summaries().find((a) => a.agent_name === this.selectedName()));
   readonly dirty = computed(() => this.draft() !== null && JSON.stringify(this.draft()) !== this.baseline());
@@ -97,7 +105,6 @@ export class StudioPageComponent implements OnInit {
     }
     return [...groups].map(([name, agents]) => ({ name, agents }));
   });
-  private readonly core = computed(() => this.features().find((f) => f.id === 'agents'));
 
   ngOnInit(): void {
     this.call(this.studio.features(), (features) => this.features.set(features));
@@ -110,10 +117,18 @@ export class StudioPageComponent implements OnInit {
     return this.dirty();
   }
 
-  /** Whether the manifest serves `action` and the caller holds it at `value` (the selected agent by default). */
-  can(action: string, value = `agent:${this.selectedName()}`): boolean {
-    const core = this.core();
-    return !!core?.actions.includes(action) && this.auth.hasPermission(core.object || 'AGENT_STUDIO', action, value);
+  /** Whether `feature` serves `action` and the caller holds it at `value` (the selected agent by default). */
+  can(action: string, value = `agent:${this.selectedName()}`, feature = 'agents'): boolean {
+    const f = this.feature(feature);
+    return !!f?.actions.includes(action) && this.auth.hasPermission(f.object || 'AGENT_STUDIO', action, value);
+  }
+
+  private feature(id: string): StudioFeature | undefined {
+    return this.features().find((f) => f.id === id);
+  }
+
+  readinessCaption(code: AgentReadiness): string {
+    return AGENT_READINESS_CAPTIONS[code] ?? code;
   }
 
   modelsOf(type: string): StudioModel[] {
@@ -136,6 +151,8 @@ export class StudioPageComponent implements OnInit {
     this.settings.set(null);
     this.releases.set([]);
     this.audit.set([]);
+    this.guardrails.set(null);
+    this.safetyEvents.set([]);
     this.diff.set(null);
     this.testResult.set(null);
     this.errorMessage.set('');
@@ -146,6 +163,7 @@ export class StudioPageComponent implements OnInit {
   openTab(id: string): void {
     this.tab.set(id);
     if (id === 'history') this.loadHistory();
+    if (id === 'guardrails') this.loadGuardrails();
   }
 
   private loadAgent(): void {
@@ -153,6 +171,7 @@ export class StudioPageComponent implements OnInit {
     this.call(this.studio.getDraft(name), (draft) => this.applyDraft(draft), name);
     this.call(this.studio.settings(name), (settings) => this.settings.set(settings), name);
     if (this.tab() === 'history') this.loadHistory();
+    if (this.tab() === 'guardrails') this.loadGuardrails();
   }
 
   private applyDraft(draft: AgentDraft): void {
@@ -312,6 +331,44 @@ export class StudioPageComponent implements OnInit {
     }, name);
   }
 
+  loadGuardrails(): void {
+    const name = this.selectedName();
+    this.safetyEvents.set([]);
+    this.call(this.studio.guardrails(name), (g) => this.guardrails.set(g), name);
+    this.loadSafetyEvents();
+  }
+
+  loadSafetyEvents(): void {
+    const name = this.selectedName();
+    const before = this.safetyEvents().at(-1)?.id ?? 0;
+    this.call(this.studio.safetyEvents(name, before), (events) => {
+      this.safetyEvents.update((rows) => [...rows, ...events]);
+      this.safetyExhausted.set(events.length < 50);
+    }, name);
+  }
+
+  /** Replaces the agent's own rules with the JSON array typed in. */
+  saveGuardrails(rulesText: string): void {
+    const g = this.guardrails();
+    if (!g) return;
+    let rules: GuardrailRule[];
+    try {
+      rules = JSON.parse(rulesText.trim() || '[]') as GuardrailRule[];
+    } catch {
+      this.errorMessage.set('The rules must be a JSON array.');
+      return;
+    }
+    if (!Array.isArray(rules)) {
+      this.errorMessage.set('The rules must be a JSON array.');
+      return;
+    }
+    this.act(this.studio.saveGuardrails({ agent_name: g.agent_name, rules, expected_agent_revision: g.expected_agent_revision }), (saved) => {
+      this.guardrails.set(saved);
+      this.applyRevisions(saved.expected_agent_revision);
+      this.successMessage.set('Guardrails saved.');
+    }, g.agent_name);
+  }
+
   previousVersion(version: number): number {
     return this.releases().reduce((best, r) => r.version < version && r.version > best ? r.version : best, 0);
   }

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') {
+        <p class="turn-thread__error" role="alert">{{ turn.error_text || failedText() }}</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,94 @@
+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';
+
+export interface TurnResultContext {
+  $implicit: ConversationTurn;
+}
+
+/**
+ * The result card of one task kind, or of every other kind with `"*"`:
+ * `<ng-template sailTurnResult="kind" let-turn>…</ng-template>`.
+ */
+@Directive({ selector: 'ng-template[sailTurnResult]' })
+export class TurnResultDirective {
+  readonly kind = input.required<string>({ alias: 'sailTurnResult' });
+  readonly template = inject<TemplateRef<TurnResultContext>>(TemplateRef);
+
+  static ngTemplateContextGuard(_dir: TurnResultDirective, ctx: unknown): ctx is TurnResultContext {
+    return true;
+  }
+}
+
+/**
+ * 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.');
+  /** Shown for a failed turn that carries no error text. */
+  readonly failedText = input('The turn failed.');
+
+  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<TurnResultContext> | undefined {
+    const results = this.results();
+    return (results.find((r) => r.kind() === kind) ?? results.find((r) => r.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

@@ -12,7 +12,7 @@ export interface AgentSummary {
   enabled: boolean;
   is_default: boolean;
   archived: boolean;
-  readiness: string;
+  readiness: AgentReadiness;
   readiness_reason: string;
   type_defaults_revision: number;
   agent_revision: number;
@@ -309,3 +309,69 @@ export interface AgentSettingChange {
   expected_agent_revision: number;
   expected_type_defaults_revision: number;
 }
+
+/** Scout's fixed `AgentReadiness` values, which no constant domain carries. */
+export type AgentReadiness =
+  'ready' | 'disabled' | 'missing_model' | 'unpublished' | 'error' | 'not_entitled' | 'needs_integration' | 'forbidden';
+
+export const AGENT_READINESS_CAPTIONS: Record<AgentReadiness, 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.14). 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,45 @@ 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';
+
+/** A verified reconciliation outcome. */
+export type ReconcileOutcome = Extract<ConfirmationStatus, 'D' | 'F'>;
+
+/** Scout's bound on decision and reconciliation notes, in characters. */
+export const CONFIRMATION_NOTE_MAX = 500;
+
+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 {
+  tenant_label?: string;
+  maker: PrincipalRef;
+  client_ref?: string;
+  client_label?: 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,7 +36,41 @@ export class ConversationStreamFailure extends Error {
   }
 }
 
-/** Where the app mounts Scout's ConversationHandler, e.g. '/api/wingmate/'. */
+/** 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/'. `ConversationService` is a
+ * root singleton: provide this at bootstrap, or provide both together on a component.
+ */
 export const CONVERSATION_BASE_PATH = new InjectionToken<string>('SailConversationBasePath', {
   providedIn: 'root',
   factory: () => '/api/conversation/',

package/src/agent/model/decision.ts

@@ -1,11 +1,11 @@
-import { ObjectRef } from './turn_event';
-
 /** A allowed, D denied, P pending (`audit_decision_outcome`). */
 export type DecisionOutcome = 'A' | 'D' | 'P';
 
 export interface PrincipalRef {
   kind: string;
   id: string;
+  /** The product's caption for the principal (Scout `contract.Labeler`). */
+  label?: string;
 }
 
 export interface AuthorityRef {
@@ -14,12 +14,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,18 +24,33 @@ export interface DecisionRecord {
   reason: string;
   principal: PrincipalRef;
   authority?: AuthorityRef;
+  /** The client application the principal acted through. */
+  client_ref?: string;
+  client_label?: 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[];
 }
+
+/** A principal's label, or its kind and id. */
+export function principalName(ref: PrincipalRef): string {
+  return ref.label || `${ref.kind} ${ref.id}`;
+}

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, ReconcileOutcome } 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; the note is required. */
+  reconcileConfirmation(key: ConfirmationKey, outcome: ReconcileOutcome, note: string): Observable<Confirmation> {
+    return this.http.post<Confirmation>(this.url(base + 'confirmation/reconcile'), { ...key, outcome, note });
   }
 }