@nauticana/sail 1.1.33 → 1.1.35

package/src/agent/model/agent_studio.ts

@@ -1,6 +1,7 @@
-/** Agent Studio `studio-v2` wire types. Field names are the backend's JSON names. */
+/** Agent Studio wire types (Scout v1.2.7). Field names are the backend's JSON names. */
 
-export type AgentMergeMode = 'append' | 'replace';
+/** R replace, A append, I intersect (non-prompt settings only). */
+export type AgentMergeMode = 'R' | 'A' | 'I';
 export type AgentResetScope = 'agent_override' | 'type_default' | 'platform_baseline';
 
 export interface AgentSummary {
@@ -10,6 +11,7 @@ export interface AgentSummary {
   purpose: string;
   enabled: boolean;
   is_default: boolean;
+  archived: boolean;
   readiness: string;
   readiness_reason: string;
   type_defaults_revision: number;
@@ -35,10 +37,6 @@ export interface AgentModelSelection {
   video_model: string;
 }
 
-export interface AgentApprovalPolicy {
-  require_approval: boolean;
-}
-
 /** One contribution to a prompt section. `editable` is response-only. */
 export interface AgentPromptLayer {
   scope_id: string;
@@ -48,6 +46,8 @@ export interface AgentPromptLayer {
   editable: boolean;
   instruction: string;
   output: string;
+  /** Who last edited the layer; absent on the baseline. */
+  bound_by?: number;
 }
 
 export interface AgentPromptSection {
@@ -77,7 +77,6 @@ export interface AgentDraft {
   display_name: string;
   enabled: boolean;
   is_default: boolean;
-  approval_policy: AgentApprovalPolicy;
   models: AgentModelSelection;
   languages: AgentLanguageDraft[];
   agent_scope_id?: string;
@@ -103,6 +102,7 @@ export interface AgentTestResult {
   latency_ms: number;
   input_tokens: number;
   output_tokens: number;
+  /** Cost in minor units. */
   credits: number;
   sections: string[];
 }
@@ -110,6 +110,10 @@ export interface AgentTestResult {
 export interface AgentPublishRequest {
   agent_name: string;
   change_summary: string;
+  /** 1–99 deploys the release as a canary. */
+  canary_percentage?: number;
+  /** RFC 3339; a future time schedules the release. */
+  effective_at?: string;
   expected_agent_revision: number;
   expected_type_defaults_revision: number;
 }
@@ -137,6 +141,7 @@ export interface AgentSetDefaultRequest {
 export interface AgentSetEnabledRequest {
   agent_name: string;
   enabled: boolean;
+  reason?: string;
   expected_agent_revision: number;
 }
 
@@ -151,19 +156,41 @@ export interface AgentRelease {
   version: number;
   enabled: boolean;
   models: AgentModelSelection;
-  require_approval: boolean;
   definition_digest: string;
   change_summary: string;
   published_by: number;
   published_at: string;
   active: boolean;
   languages: string[];
+  activation?: ReleaseActivation;
+}
+
+/** A scheduled publish; state P pending, A activated, R refused, X cancelled. */
+export interface ReleaseActivation {
+  id: number;
+  agent_name: string;
+  version: number;
+  definition_digest: string;
+  canary_percentage?: number;
+  effective_at: string;
+  state: 'P' | 'A' | 'R' | 'X';
+  scheduled_by: string;
+  scheduled_at: string;
+  attempts: number;
+  next_attempt_at?: string;
+  reason?: string;
+  detail?: string;
+  decided_by?: string;
+  decided_at?: string;
 }
 
 export interface AgentAuditEvent {
   event: string;
   detail: string;
-  user_id: number;
+  actor_kind?: string;
+  actor_id?: string;
+  /** Set only when a person acted. */
+  user_id?: number;
   event_time: string;
 }
 
@@ -196,3 +223,152 @@ export interface StudioModel {
   image_credits: number;
   video_credits_per_sec: number;
 }
+
+/** One optional Studio API the backend mounted. Unknown ids are ignored; grants still decide. */
+export interface StudioFeature {
+  id: string;
+  version: number;
+  actions: string[];
+  /** Authorization object of the actions; empty is AGENT_STUDIO. */
+  object?: string;
+}
+
+/** `copy_from` and `template_id` are exclusive. */
+export interface AgentCreateRequest {
+  agent_type: string;
+  display_name: string;
+  copy_from?: string;
+  template_id?: string;
+  template_version?: number;
+  references?: Record<string, Record<string, string>>;
+  idempotency_key: string;
+}
+
+export interface AgentRenameRequest {
+  agent_name: string;
+  display_name: string;
+  expected_agent_revision: number;
+}
+
+export interface AgentArchiveRequest {
+  agent_name: string;
+  expected_agent_revision: number;
+}
+
+export interface AgentSettingSource {
+  scope_id: string;
+  scope_kind: string;
+  resource_version: string;
+  merge_mode: AgentMergeMode;
+  sealed: boolean;
+}
+
+/** One binding on the agent's scope chain; `editable` marks the agent's and its type's scopes. */
+export interface AgentSetting {
+  scope_id: string;
+  scope_kind: string;
+  editable: boolean;
+  resource_kind: string;
+  resource_id: string;
+  resource_version: string;
+  merge_mode: AgentMergeMode;
+  sealed: boolean;
+  value: unknown;
+}
+
+export interface AgentEffectiveSetting {
+  resource_kind: string;
+  resource_id: string;
+  value: unknown;
+  source: AgentSettingSource;
+  superseded?: AgentSettingSource[];
+}
+
+/** Bindings other than prompt sections; `problem` says why they do not compile. */
+export interface AgentSettings {
+  agent_name: string;
+  agent_scope_id: string;
+  type_scope_id: string;
+  bindings: AgentSetting[];
+  effective: AgentEffectiveSetting[];
+  problem?: string;
+  expected_agent_revision: number;
+  expected_type_defaults_revision: number;
+}
+
+/** Binds, or with `remove` ends, one resource at the agent or type scope. */
+export interface AgentSettingChange {
+  agent_name: string;
+  scope_id: string;
+  resource_kind: string;
+  resource_id: string;
+  merge_mode?: AgentMergeMode;
+  sealed: boolean;
+  value?: unknown;
+  remove: boolean;
+  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

@@ -0,0 +1,78 @@
+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';
+
+export interface ApproverReference {
+  kind: string;
+  ref: string;
+}
+
+/** One decision a reviewer owes; evidence stays behind its own authorization. */
+export interface ApprovalRequest {
+  request_id: string;
+  execution_step_id: number;
+  conversation_id: string;
+  scope_id?: string;
+  rule_id: string;
+  action: string;
+  resource: string;
+  output_class: string;
+  risk_tier: string;
+  summary: string;
+  proposed_digest: string;
+  status: string;
+  deadline_at?: string;
+  created_at: string;
+  revises_step_id?: number;
+  rule_source: string;
+  route_id?: string;
+  route_step: number;
+  approver_reference?: ApproverReference;
+}
+
+export interface ApprovalResolveRequest {
+  request_id: string;
+  execution_step_id: number;
+  verdict: ApprovalVerdict;
+  proposed_digest: string;
+  reason?: string;
+  /** 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

@@ -4,7 +4,15 @@ import { InjectionToken } from '@angular/core';
 export interface ConversationTurnRequest {
   request_id: string;
   conversation_id: string;
-  agent_id: string;
+  /** The agent type alias; its default agent serves a new conversation. */
+  agent_type: string;
+  /** One agent of that type instead of its default. */
+  agent_name?: string;
+  /** Pins a new conversation to one release; needs `release_reason`. */
+  release?: string;
+  release_reason?: string;
+  /** The product's opaque reference to the work the turn serves. */
+  work_ref?: string;
   /** Opaque product payload; the backend forwards it to the agent unread. */
   input: unknown;
 }
@@ -28,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,6 +1,5 @@
-import { ObjectRef } from './turn_event';
-
-export type DecisionOutcome = 'allow' | 'deny' | 'pending';
+/** A allowed, D denied, P pending (`audit_decision_outcome`). */
+export type DecisionOutcome = 'A' | 'D' | 'P';
 
 export interface PrincipalRef {
   kind: string;
@@ -13,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;
@@ -26,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/model/turn_event.ts

@@ -10,6 +10,7 @@ export const TURN_EVENT_KINDS = [
   'effect',
   'progress',
   'result',
+  'citations',
   'extension',
 ] as const;
 
@@ -73,6 +74,14 @@ export interface TurnExtensionEvent {
   payload?: unknown;
 }
 
+export interface Citation {
+  url: string;
+  domain?: string;
+  title?: string;
+  snippet?: string;
+  position: number;
+}
+
 export interface TurnEvent {
   v: number;
   kind: TurnEventKind;
@@ -83,6 +92,7 @@ export interface TurnEvent {
   effect?: TurnEffectEvent;
   progress?: TurnProgressEvent;
   extension?: TurnExtensionEvent;
+  citations?: Citation[];
 }
 
 const knownKinds: ReadonlySet<string> = new Set(TURN_EVENT_KINDS);

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

@@ -2,27 +2,42 @@ import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { BaseRestService } from '../../service/base_rest.service';
 import {
+  AgentArchiveRequest,
+  AgentGuardrailChange,
+  AgentGuardrails,
   AgentAuditEvent,
+  AgentCreateRequest,
   AgentDraft,
   AgentEnabledState,
   AgentPublishRequest,
   AgentRelease,
   AgentReleaseSection,
+  AgentRenameRequest,
   AgentResetRequest,
   AgentRestoreRequest,
   AgentSetDefaultRequest,
   AgentSetEnabledRequest,
+  AgentSettingChange,
+  AgentSettings,
   AgentSummary,
   AgentTestRequest,
   AgentTestResult,
+  SafetyEvent,
+  StudioFeature,
   StudioModel,
 } from '../model/agent_studio';
+import { DecisionOutcome, DecisionPage } from '../model/decision';
 
 const studioBasePath = '/api/agent-studio/';
 
-/** Client for the `studio-v2` Agent Studio routes, which are fixed and unversioned. */
+/** Client for Scout's core Agent Studio routes, which are fixed and unversioned. */
 @Injectable({ providedIn: 'root' })
 export class AgentStudioService extends BaseRestService {
+  /** The optional Studio APIs the backend mounted; `agents` is the core set. */
+  features(): Observable<StudioFeature[]> {
+    return this.http.get<StudioFeature[]>(this.studioUrl('features'));
+  }
+
   listAgents(): Observable<AgentSummary[]> {
     return this.http.get<AgentSummary[]>(this.studioUrl('agents'));
   }
@@ -36,6 +51,30 @@ export class AgentStudioService extends BaseRestService {
     return this.http.post<AgentDraft>(this.studioUrl('draft'), draft);
   }
 
+  create(request: AgentCreateRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('create'), request);
+  }
+
+  rename(request: AgentRenameRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('rename'), request);
+  }
+
+  archive(request: AgentArchiveRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('archive'), request);
+  }
+
+  unarchive(request: AgentArchiveRequest): Observable<AgentSummary> {
+    return this.http.post<AgentSummary>(this.studioUrl('unarchive'), request);
+  }
+
+  settings(agentName: string): Observable<AgentSettings> {
+    return this.http.get<AgentSettings>(this.studioUrl('settings'), { params: { agent_name: agentName } });
+  }
+
+  saveSetting(change: AgentSettingChange): Observable<AgentSettings> {
+    return this.http.post<AgentSettings>(this.studioUrl('setting'), change);
+  }
+
   setEnabled(request: AgentSetEnabledRequest): Observable<AgentEnabledState> {
     return this.http.post<AgentEnabledState>(this.studioUrl('enabled'), request);
   }
@@ -79,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

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BaseRestService } from '../../service/base_rest.service';
+import { ApprovalRequest, ApprovalResolveRequest, Confirmation, ConfirmationKey } from '../model/approval';
+
+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(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(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/agent/util/release_diff.ts

@@ -0,0 +1,33 @@
+import { AgentReleaseSection } from '../model/agent_studio';
+
+export interface ReleaseSectionDiff {
+  language_code: string;
+  prompt_header_id: number;
+  caption: string;
+  status: 'added' | 'changed' | 'removed';
+  old_text: string;
+  new_text: string;
+}
+
+/**
+ * Section changes from `prior` to `current`, keyed by language and prompt header. Caption and
+ * description are part of the compiled prompt, so they count; so does a pure reordering.
+ */
+export function diffReleaseSections(prior: AgentReleaseSection[], current: AgentReleaseSection[]): ReleaseSectionDiff[] {
+  const key = (s: AgentReleaseSection) => `${s.language_code}#${s.prompt_header_id}`;
+  const text = (s: AgentReleaseSection) =>
+    `${s.description ? `${s.caption} — ${s.description}` : s.caption}\n${s.output ? `${s.instruction}\n\nOutput: ${s.output}` : s.instruction}`;
+  const row = (s: AgentReleaseSection, status: ReleaseSectionDiff['status'], old_text: string, new_text: string): ReleaseSectionDiff =>
+    ({ language_code: s.language_code, prompt_header_id: s.prompt_header_id, caption: s.caption, status, old_text, new_text });
+  const remaining = new Map(prior.map((s) => [key(s), s]));
+  const rows: ReleaseSectionDiff[] = [];
+  for (const section of current) {
+    const old = remaining.get(key(section));
+    remaining.delete(key(section));
+    if (!old) rows.push(row(section, 'added', '', text(section)));
+    else if (text(old) !== text(section)) rows.push(row(section, 'changed', text(old), text(section)));
+    else if (old.sequence !== section.sequence) rows.push(row(section, 'changed', `position ${old.sequence}`, `position ${section.sequence}`));
+  }
+  for (const old of remaining.values()) rows.push(row(old, 'removed', text(old), ''));
+  return rows;
+}