@crouton-kit/crouter 0.3.37 → 0.3.39

package/dist/builtin-views/prompt-review/core.mjs

@@ -85,6 +85,8 @@ function execRequest(bin, args, stdin) {
 
 /** @typedef {{kind:string, whenToUse:string}} KindInfo */
 
+/** @typedef {{config:PromptReviewConfig, layers:PromptLayer[], assembled:string, total:{tokens:number, chars:number}, sources:PromptSource[]}} ReviewPayload */
+
 /**
  * @typedef {Object} PromptReviewList
  * @property {KindInfo[]} kinds
@@ -155,19 +157,6 @@ function normalizeConfig(config) {
   };
 }
 
-/** @param {PromptLayer[]} layers @returns {PromptSource[]} */
-function dedupeSources(layers) {
-  /** @type {PromptSource[]} */
-  const out = [];
-  const seen = new Set();
-  for (const layer of layers) {
-    if (!layer.sourcePath || seen.has(layer.sourcePath)) continue;
-    seen.add(layer.sourcePath);
-    out.push({ id: layer.id, label: layer.label, path: layer.sourcePath, scope: layer.scope });
-  }
-  return out;
-}
-
 /** @param {string} s @returns {string} */
 function normalizeText(s) {
   return str(s).replace(/\r\n/g, '\n');
@@ -184,12 +173,6 @@ function chars(text) { return normalizeText(text).length; }
 /** @param {string} text @returns {number} */
 function tokens(text) { return approxTokens(chars(text)); }
 
-/** @param {string} id @param {string} label @param {LayerGroup} group @param {string} source @param {string|null} sourcePath @param {LayerScope} scope @param {boolean} included @param {string|null} condition @param {string} text @returns {PromptLayer} */
-function makeLayer(id, label, group, source, sourcePath, scope, included, condition, text) {
-  const norm = normalizeText(text);
-  return { id, label, group, source, sourcePath, scope, included, condition, text: norm, tokens: tokens(norm), chars: chars(norm) };
-}
-
 /** @param {string} kind @returns {string} */
 function kindLabel(kind) { return kind || DEFAULT_KIND; }
 
@@ -217,112 +200,9 @@ function layerLabel(id) {
   return map[id] || id.replace(/[-_]/g, ' ');
 }
 
-/** @param {PromptReviewConfig} config @returns {PromptLayer[]} */
-function buildReviewLayers(config) {
-  const c = normalizeConfig(config);
-  const base = 'System prompt composition and agent runtime rules.';
-  const spineHas = c.hasManager;
-  const spineNo = !c.hasManager;
-  const lifecycleTerminal = c.lifecycle === 'terminal';
-  const lifecycleResident = !lifecycleTerminal;
-  const baseText = joinPieces([
-    '# Runtime base',
-    base,
-  ]);
-  const spineHasText = joinPieces([
-    '# Spine with manager',
-    'You have a manager. Report upward and keep the spine active.',
-  ]);
-  const spineNoText = joinPieces([
-    '# Spine without manager',
-    'You have no manager. Work independently and do not assume an upstream reviewer.',
-  ]);
-  const lifecycleTerminalText = joinPieces([
-    '# Terminal lifecycle',
-    'This node must finish with a final report when its work is done.',
-  ]);
-  const lifecycleResidentText = joinPieces([
-    '# Resident lifecycle',
-    'This node stays resident and waits for inbound events instead of always owing a final.',
-  ]);
-  const waitingText = joinPieces([
-    '# Waiting',
-    'When you are blocked on a future event, stop and wait instead of busy-looping.',
-  ]);
-  const personaBody = joinPieces([
-    `# ${kindLabel(c.kind)} persona`,
-    `Kind-specific prompt body for ${c.kind}.`,
-  ]);
-  const orchestrationKernel = joinPieces([
-    '# Orchestration kernel',
-    'Kernel guidance for orchestrator mode.',
-  ]);
-
-  /** @type {PromptLayer[]} */
-  const layers = [
-    makeLayer('runtime-base', 'Runtime base', 'protocol', 'personas/runtime-base.md', '/abs/src/builtin-personas/runtime-base.md', 'builtin', true, null, baseText),
-    makeLayer('spine-has-manager', 'Spine (has manager)', 'protocol', 'personas/spine/has-manager.md', '/abs/src/builtin-personas/spine/has-manager.md', 'builtin', spineHas, spineHas ? null : 'hasManager == false', spineHasText),
-    makeLayer('spine-no-manager', 'Spine (no manager)', 'protocol', 'personas/spine/no-manager.md', '/abs/src/builtin-personas/spine/no-manager.md', 'builtin', spineNo, spineNo ? null : 'hasManager == true', spineNoText),
-    makeLayer('lifecycle-terminal', 'Lifecycle (terminal)', 'protocol', 'personas/lifecycle/terminal.md', '/abs/src/builtin-personas/lifecycle/terminal.md', 'builtin', lifecycleTerminal, lifecycleTerminal ? null : 'lifecycle == resident', lifecycleTerminalText),
-    makeLayer('lifecycle-resident', 'Lifecycle (resident)', 'protocol', 'personas/lifecycle/resident.md', '/abs/src/builtin-personas/lifecycle/resident.md', 'builtin', lifecycleResident, lifecycleResident ? null : 'lifecycle == terminal', lifecycleResidentText),
-    makeLayer('waiting', 'Waiting', 'protocol', 'personas/waiting.md', '/abs/src/builtin-personas/waiting.md', 'builtin', true, null, waitingText),
-    makeLayer('persona-body', 'Persona body', 'persona', c.mode === 'base' ? `personas/${c.kind}/PERSONA.md` : `personas/${c.kind}/orchestrator.md`, c.mode === 'base' ? `/abs/src/builtin-personas/${c.kind}/PERSONA.md` : `/abs/src/builtin-personas/${c.kind}/orchestrator.md`, 'builtin', true, null, c.mode === 'base' ? personaBody : joinPieces([personaBody, orchestrationKernel])),
-    makeLayer('subpersona-menu', 'Sub-persona menu', 'generated', `generated:${c.kind}:sub-personas`, null, 'generated', true, null, joinPieces([
-      `Generated sub-persona menu for ${c.kind}.`,
-      'This layer is synthesized from the available sub-personas and their source files.',
-    ])),
-  ];
-
-  if (c.node) {
-    layers.push(
-      makeLayer('substrate-preferences', 'Preferences substrate', 'substrate', 'runtime:preferences', null, 'runtime', true, null, joinPieces([
-        '# Preferences substrate',
-        'Node-scoped preferences are spliced into the system prompt here.',
-      ])),
-      makeLayer('substrate-memory-guidance', 'Memory guidance substrate', 'substrate', 'runtime:memory-guidance', null, 'runtime', true, null, joinPieces([
-        '# Memory guidance',
-        'Runtime-spliced memory guidance shown here because a node was supplied.',
-      ])),
-      makeLayer('substrate-knowledge', 'Context message — not system prompt', 'substrate', 'runtime:knowledge', null, 'runtime', true, null, joinPieces([
-        '# Context message',
-        'This node-specific knowledge block is not part of the system prompt.',
-      ])),
-    );
-  }
-
-  return layers;
-}
-
-/** @param {PromptReviewConfig} config @returns {string} */
-function composeAssembled(config) {
-  const c = normalizeConfig(config);
-  const layers = buildReviewLayers(c);
-  const protocol = layers.filter((layer) => layer.group !== 'substrate');
-  const substrate = layers.filter((layer) => layer.group === 'substrate');
-  const protocolText = joinPieces(protocol.filter((layer) => layer.included).map((layer) => layer.text));
-  if (c.node && substrate.length) {
-    return joinPieces([protocolText, ...substrate.map((layer) => layer.text)]);
-  }
-  return protocolText;
-}
-
-/** @param {PromptReviewConfig} config @param {PromptLayer[]} layers @returns {PromptLayer[]} */
-function maybeAddNodeLayers(config, layers) {
-  if (!config.node) return layers;
-  return layers.concat(buildReviewLayers(config).filter((layer) => layer.group === 'substrate'));
-}
-
 /** @param {PromptLayer} layer @returns {string} */
 function sourceForLayer(layer) { return layer.sourcePath || layer.source; }
 
-/** @param {PromptReviewConfig} config @param {PromptLayer[]} layers @returns {{config:PromptReviewConfig, layers:PromptLayer[], assembled:string, total:{tokens:number, chars:number}, sources:PromptSource[]}} */
-function reviewPayload(config, layers) {
-  const assembled = composeAssembled(config);
-  const totalChars = chars(assembled);
-  const totalTokens = tokens(assembled);
-  return { config: normalizeConfig(config), layers, assembled, total: { tokens: totalTokens, chars: totalChars }, sources: dedupeSources(layers) };
-}
-
 /** @param {unknown} value @returns {value is PromptReviewConfig} */
 function looksLikeConfig(value) {
   return !!value && typeof value === 'object' && 'kind' in /** @type {any} */ (value) && 'mode' in /** @type {any} */ (value) && 'lifecycle' in /** @type {any} */ (value);
@@ -388,11 +268,6 @@ function diffReviews(left, right) {
   return out;
 }
 
-/** @param {PromptReviewConfig} config @param {PromptLayer[]} layers @returns {{config:PromptReviewConfig, layers:PromptLayer[], assembled:string, total:{tokens:number, chars:number}, sources:PromptSource[]}} */
-function makeReview(config, layers) {
-  return reviewPayload(config, layers);
-}
-
 /** @type {import('../../core/view/contract.js').Source<PromptReviewList>} */
 export const listSource = {
   id: 'prompt-review-list',
@@ -414,7 +289,7 @@ export const listSource = {
   },
 };
 
-/** @type {import('../../core/view/contract.js').Source<ReturnType<typeof makeReview>, PromptReviewConfig>} */
+/** @type {import('../../core/view/contract.js').Source<ReviewPayload, PromptReviewConfig>} */
 export const reviewSource = {
   id: 'prompt-review-review',
   request: (config) => {
@@ -464,7 +339,7 @@ export const reviewSource = {
       tokens: typeof data.total.tokens === 'number' ? data.total.tokens : approxTokens(chars(assembled)),
       chars: typeof data.total.chars === 'number' ? data.total.chars : chars(assembled),
     };
-    return ok(/** @type {ReturnType<typeof makeReview>} */ ({ config, layers, assembled, total, sources }));
+    return ok(/** @type {ReviewPayload} */ ({ config, layers, assembled, total, sources }));
   },
 };
 
@@ -507,7 +382,7 @@ export const exportCommand = {
   },
 };
 
-/** @param {PromptReviewConfig} config @param {PromptReviewConfig|null} compareConfig @returns {Promise<{review: ReturnType<typeof makeReview>, compareReview: ReturnType<typeof makeReview> | null, list: PromptReviewList | null, liveNodes: Array<{node_id:string, name:string, kind:string, mode:string, lifecycle:string, status:string, cwd:string, parent:string|null, created:string, enterable:boolean}> | null}>} */
+/** @param {PromptReviewConfig} config @param {PromptReviewConfig|null} compareConfig @returns {Promise<{review: ReviewPayload, compareReview: ReviewPayload | null, list: PromptReviewList | null, liveNodes: Array<{node_id:string, name:string, kind:string, mode:string, lifecycle:string, status:string, cwd:string, parent:string|null, created:string, enterable:boolean}> | null}>} */
 async function loadAll(ctx, config, compareConfig) {
   const tasks = [ctx.resolve(listSource), ctx.resolve(reviewSource, config), ctx.resolve(nodeListSource)];
   if (compareConfig) tasks.push(ctx.resolve(reviewSource, compareConfig));
@@ -546,7 +421,7 @@ function cursorFor(review, id) {
   return idx >= 0 ? idx : Math.max(0, review.findIndex((layer) => layer.included) >= 0 ? review.findIndex((layer) => layer.included) : 0);
 }
 
-/** @param {ReviewState} state @param {PromptReviewConfig} config @param {PromptReviewConfig|null} compareConfig @param {ReturnType<typeof makeReview>|null} reviewPayloadObj @param {ReturnType<typeof makeReview>|null} comparePayloadObj @returns {ReviewState} */
+/** @param {ReviewState} state @param {PromptReviewConfig} config @param {PromptReviewConfig|null} compareConfig @param {ReviewPayload|null} reviewPayloadObj @param {ReviewPayload|null} comparePayloadObj @returns {ReviewState} */
 function materialize(state, config, compareConfig, reviewPayloadObj, comparePayloadObj) {
   const review = reviewPayloadObj ? reviewPayloadObj.layers : null;
   const compareReview = comparePayloadObj ? comparePayloadObj.layers : null;
@@ -852,11 +727,8 @@ export {
   diffReviews,
   layerLabel,
   makeDefaultCompare,
-  reviewPayload,
   selectedLayer,
   compareSelectedLayer,
-  composeAssembled,
-  buildReviewLayers,
   kindLabel,
 };
 

package/dist/builtin-views/settings/core.mjs

@@ -83,21 +83,19 @@ function makeConfigSetCommand(key, value) {
   };
 }
 
-/** @typedef {{ kind:'defaultProvider' } | { kind:'matrix'; strength:ModelStrength } | { kind:'persona'; persona:string } | { kind:'addPersona' }} Row */
+/** @typedef {{ kind:'defaultProvider' } | { kind:'matrix'; strength:ModelStrength }} Row */
 
 /** @typedef {Object} EditState
- * @property {'defaultProvider'|'matrixCell'|'personaStrength'|'personaNew'} kind
+ * @property {'defaultProvider'|'matrixCell'} kind
  * @property {string} draft
  * @property {string} value
  * @property {string} label
  * @property {ModelStrength} [strength]
  * @property {ModelProvider} [provider]
- * @property {string} [persona]
  */
 
 /** @typedef {Object} SettingsState
  * @property {ModelLaddersConfig|null} modelLadders
- * @property {Record<string, ModelStrength>} personaStrengths
  * @property {Record<ModelStrength, ModelProvider>} matrixSelection
  * @property {number} cursor
  * @property {number} scroll
@@ -109,10 +107,8 @@ function makeConfigSetCommand(key, value) {
 /** @param {SettingsState} state @returns {Row[]} */
 export function buildRows(state) {
   if (!state.modelLadders) return [];
-  const rows = [{ kind: 'defaultProvider' }];
-  for (const strength of STRENGTHS) rows.push({ kind: 'matrix', strength });
-  for (const persona of Object.keys(state.personaStrengths).sort((a, b) => a.localeCompare(b))) rows.push({ kind: 'persona', persona });
-  rows.push({ kind: 'addPersona' });
+  const rows = [{ kind: /** @type {'defaultProvider'} */ ('defaultProvider') }];
+  for (const strength of STRENGTHS) rows.push({ kind: /** @type {'matrix'} */ ('matrix'), strength });
   return rows;
 }
 
@@ -131,67 +127,30 @@ function currentRow(state) {
 export function settingsRowLabel(state, row) {
   if (!row) return '';
   if (row.kind === 'defaultProvider') return 'Default provider';
-  if (row.kind === 'matrix') return `${row.strength} strength`;
-  if (row.kind === 'persona') return row.persona;
-  return 'Add persona strength';
+  return `${row.strength} strength`;
 }
 
-/** @param {string} draft @returns {ModelStrength | null} */
-function parseStrength(draft) {
-  const s = draft.trim();
-  return s === 'ultra' || s === 'strong' || s === 'medium' || s === 'light' ? s : null;
-}
-
-/** @param {string} draft @returns {{persona:string, strength:ModelStrength}|null} */
-function parsePersonaPair(draft) {
-  const s = draft.trim();
-  if (!s) return null;
-  const eq = s.indexOf('=');
-  if (eq > 0) {
-    const persona = s.slice(0, eq).trim();
-    const strength = parseStrength(s.slice(eq + 1));
-    return persona && strength ? { persona, strength } : null;
-  }
-  const parts = s.split(/\s+/).filter(Boolean);
-  if (parts.length >= 2) {
-    const strength = parseStrength(parts[parts.length - 1] || '');
-    const persona = parts.slice(0, -1).join(' ').trim();
-    return persona && strength ? { persona, strength } : null;
-  }
-  return null;
-}
-
-/** @param {SettingsState} state @param {Row} row @returns {{ kind:'defaultProvider'|'matrixCell'|'personaStrength'|'personaNew', draft:string, value:string, label:string, strength?:ModelStrength, provider?:ModelProvider, persona?:string }} */
+/** @param {SettingsState} state @param {Row} row @returns {{ kind:'defaultProvider'|'matrixCell', draft:string, value:string, label:string, strength?:ModelStrength, provider?:ModelProvider }} */
 export function settingsTargetForRow(state, row) {
   if (row.kind === 'defaultProvider') {
     return { kind: 'defaultProvider', draft: '', value: state.modelLadders?.defaultProvider ?? 'anthropic', label: 'default provider' };
   }
-  if (row.kind === 'matrix') {
-    const provider = state.matrixSelection[row.strength] ?? DEFAULT_MATRIX_SELECTION[row.strength];
-    return {
-      kind: 'matrixCell',
-      strength: row.strength,
-      provider,
-      draft: '',
-      value: state.modelLadders?.[provider]?.[row.strength] ?? '',
-      label: `${provider} / ${row.strength}`,
-    };
-  }
-  if (row.kind === 'persona') {
-    return { kind: 'personaStrength', persona: row.persona, draft: '', value: state.personaStrengths[row.persona] ?? 'strong', label: row.persona };
-  }
-  return { kind: 'personaNew', draft: '', value: '', label: 'new persona strength' };
+  const provider = state.matrixSelection[row.strength] ?? DEFAULT_MATRIX_SELECTION[row.strength];
+  return {
+    kind: 'matrixCell',
+    strength: row.strength,
+    provider,
+    draft: '',
+    value: state.modelLadders?.[provider]?.[row.strength] ?? '',
+    label: `${provider} / ${row.strength}`,
+  };
 }
 
-/** @param {Ctx} ctx @returns {Promise<{ok:true, data:{ladders: ModelLaddersConfig, personaStrengths: Record<string, ModelStrength>}} | {ok:false, error:SourceError}>} */
+/** @param {Ctx} ctx @returns {Promise<{ok:true, data:{ladders: ModelLaddersConfig}} | {ok:false, error:SourceError}>} */
 async function loadConfig(ctx) {
-  const [ladders, personaStrengths] = await Promise.all([
-    ctx.resolve(makeConfigGetSource('modelLadders')),
-    ctx.resolve(makeConfigGetSource('personaStrengths')),
-  ]);
+  const ladders = await ctx.resolve(makeConfigGetSource('modelLadders'));
   if (!ladders.ok) return ladders;
-  if (!personaStrengths.ok) return personaStrengths;
-  return ok({ ladders: /** @type {ModelLaddersConfig} */ (ladders.data), personaStrengths: /** @type {Record<string, ModelStrength>} */ (personaStrengths.data) });
+  return ok({ ladders: /** @type {ModelLaddersConfig} */ (ladders.data) });
 }
 
 /** @param {Ctx} ctx @param {string} msg @param {SourceError['display']['level']} [level='error'] */
@@ -200,7 +159,7 @@ function setBanner(ctx, msg, level = 'error') {
   else ctx.signal.setBanner(msg, level);
 }
 
-/** @typedef {{ kind:'defaultProvider'|'matrixCell'|'personaStrength'|'personaNew', value:string, strength?:ModelStrength, provider?:ModelProvider, persona?:string }} PersistTarget */
+/** @typedef {{ kind:'defaultProvider'|'matrixCell', value:string, strength?:ModelStrength, provider?:ModelProvider }} PersistTarget */
 
 /** Validate a target, write it via `crtr sys config set`, fold the result into
  *  local state, and re-pull. Shared by submitEdit (text fields) and applyValue
@@ -212,24 +171,13 @@ async function persist(ctx, target) {
     if (value !== 'anthropic' && value !== 'openai') { setBanner(ctx, 'default provider must be anthropic or openai', 'action'); return false; }
   } else if (target.kind === 'matrixCell') {
     if (!value) { setBanner(ctx, 'model id cannot be empty', 'action'); return false; }
-  } else if (target.kind === 'personaStrength') {
-    if (!parseStrength(value)) { setBanner(ctx, 'persona strength must be ultra, strong, medium, or light', 'action'); return false; }
-  } else if (target.kind === 'personaNew') {
-    if (!parsePersonaPair(value)) { setBanner(ctx, 'use "kind strength" or "kind=strength"', 'action'); return false; }
   }
 
   ctx.signal.setStatus('Saving…');
   let key = '';
-  let writeValue = '';
-  if (target.kind === 'defaultProvider') { key = 'modelLadders.defaultProvider'; writeValue = value; }
-  else if (target.kind === 'matrixCell') { key = `modelLadders.${target.provider}.${target.strength}`; writeValue = value; }
-  else if (target.kind === 'personaStrength') { key = `personaStrengths.${target.persona}`; writeValue = value; }
-  else {
-    const pair = parsePersonaPair(value);
-    if (!pair) return false;
-    key = `personaStrengths.${pair.persona}`;
-    writeValue = pair.strength;
-  }
+  const writeValue = value;
+  if (target.kind === 'defaultProvider') { key = 'modelLadders.defaultProvider'; }
+  else { key = `modelLadders.${target.provider}.${target.strength}`; }
 
   const r = await ctx.execute(makeConfigSetCommand(key, writeValue));
   if (!r.ok) {
@@ -241,11 +189,6 @@ async function persist(ctx, target) {
     const next = { ...s, edit: null };
     if (target.kind === 'defaultProvider' && next.modelLadders) next.modelLadders = { ...next.modelLadders, defaultProvider: value };
     if (target.kind === 'matrixCell' && next.modelLadders) next.modelLadders = { ...next.modelLadders, [target.provider]: { ...next.modelLadders[target.provider], [target.strength]: value } };
-    if (target.kind === 'personaStrength') next.personaStrengths = { ...next.personaStrengths, [target.persona]: /** @type {ModelStrength} */ (value) };
-    if (target.kind === 'personaNew') {
-      const pair = parsePersonaPair(value);
-      if (pair) next.personaStrengths = { ...next.personaStrengths, [pair.persona]: pair.strength };
-    }
     return next;
   });
   ctx.signal.setStatus('Saved');
@@ -258,14 +201,13 @@ const core = {
   manifest: {
     id: 'settings',
     title: 'Model Ladders',
-    subtitle: 'provider × strength matrix and persona strengths',
-    description: 'edit model ladders and personaStrengths through crtr commands',
+    subtitle: 'provider × strength matrix',
+    description: 'edit model ladders through crtr commands',
   },
 
   init() {
     return {
       modelLadders: null,
-      personaStrengths: {},
       matrixSelection: { ...DEFAULT_MATRIX_SELECTION },
       cursor: 0,
       scroll: 0,
@@ -277,7 +219,6 @@ const core = {
 
   sources: {
     modelLadders: makeConfigGetSource('modelLadders'),
-    personaStrengths: makeConfigGetSource('personaStrengths'),
   },
 
   intents: {
@@ -297,7 +238,6 @@ const core = {
         const next = {
           ...s,
           modelLadders: r.data.ladders,
-          personaStrengths: r.data.personaStrengths,
           sourceError: null,
           lastFetch: Date.now(),
         };
@@ -343,11 +283,7 @@ const core = {
         const cur = s.modelLadders.defaultProvider ?? 'anthropic';
         return { ...s, edit: { kind: 'defaultProvider', draft: cur, value: cur, label: 'default provider' } };
       }
-      if (p.kind === 'persona' && typeof p.persona === 'string') {
-        const cur = s.personaStrengths[p.persona] ?? 'strong';
-        return { ...s, edit: { kind: 'personaStrength', persona: p.persona, draft: cur, value: cur, label: p.persona } };
-      }
-      return { ...s, edit: { kind: 'personaNew', draft: '', value: '', label: 'new persona strength' } };
+      return s;
     }),
 
     setDraft: (ctx, draft) => ctx.set((s) => (s.edit ? { ...s, edit: { ...s.edit, draft: typeof draft === 'string' ? draft : '' } } : s)),
@@ -357,7 +293,7 @@ const core = {
     async submitEdit(ctx) {
       const edit = ctx.state.edit;
       if (!edit) return;
-      await persist(ctx, { kind: edit.kind, value: edit.draft, strength: edit.strength, provider: edit.provider, persona: edit.persona });
+      await persist(ctx, { kind: edit.kind, value: edit.draft, strength: edit.strength, provider: edit.provider });
     },
 
     // One-click save for enum fields (web chips): no editor round-trip. Payload
@@ -368,16 +304,12 @@ const core = {
       await persist(ctx, p);
     },
 
-    jumpAddPersona: (ctx) => ctx.set((s) => ({ ...s, cursor: Math.max(0, buildRows(s).length - 1) })),
-
     selectRow: (ctx, payload) => ctx.set((s) => {
       const p = payload && typeof payload === 'object' ? /** @type {Record<string, unknown>} */ (payload) : {};
       const rows = buildRows(s);
       const target = rows.findIndex((row) => {
         if (row.kind === 'defaultProvider' && p.kind === 'defaultProvider') return true;
         if (row.kind === 'matrix' && p.kind === 'matrix' && p.strength === row.strength) return true;
-        if (row.kind === 'persona' && p.kind === 'persona' && p.persona === row.persona) return true;
-        if (row.kind === 'addPersona' && p.kind === 'addPersona') return true;
         return false;
       });
       if (target < 0) return s;

package/dist/builtin-views/settings/text.mjs

@@ -30,11 +30,6 @@ export function dump(state, ctx) {
       lines.push(`${row.strength}: anthropic=${state.modelLadders.anthropic?.[row.strength] ?? '—'} | openai=${state.modelLadders.openai?.[row.strength] ?? '—'}${provider ? ` [selected ${provider}]` : ''}`);
       continue;
     }
-    if (row.kind === 'persona') {
-      lines.push(`${row.persona}: ${state.personaStrengths[row.persona] ?? 'strong'}`);
-      continue;
-    }
-    lines.push('+ add persona strength');
   }
   return lines.join('\n');
 }

package/dist/builtin-views/settings/tui.mjs

@@ -37,11 +37,6 @@ function rows(state) {
       });
       continue;
     }
-    if (row.kind === 'persona') {
-      out.push({ spans: [{ text: row.persona, style: { bold: true } }, { text: '  →  ' }, { text: state.personaStrengths[row.persona] ?? 'strong', style: { fg: '33' } }] });
-      continue;
-    }
-    out.push({ spans: [{ text: '+ add persona strength', style: { fg: '32', bold: true } }] });
   }
   return out;
 }
@@ -67,7 +62,7 @@ export function render(state, draw, content) {
 
   const header = state.edit
     ? `Replacing ${state.edit.label} — Enter saves, Esc cancels`
-    : 'j/k move · h/l switch matrix cell · enter edit · n add persona · g refresh';
+    : 'j/k move · h/l switch matrix cell · enter edit · g refresh';
   draw.text(content.row, content.col, 'Model ladders', { bold: true });
   draw.text(content.row + 1, content.col, header, { dim: true });
   if (state.edit) {
@@ -85,7 +80,6 @@ export const keymap = [
   { keys: ['k', 'up'], intent: 'cursorUp', when: (s) => !s.edit },
   { keys: ['h', 'left'], intent: 'matrixLeft', when: (s) => !s.edit, hint: { keys: 'h/l', label: 'switch cell' } },
   { keys: ['l', 'right'], intent: 'matrixRight', when: (s) => !s.edit },
-  { keys: ['n'], intent: 'jumpAddPersona', when: (s) => !s.edit, hint: { keys: 'n', label: 'add persona' } },
   { keys: ['g'], intent: 'refresh', when: (s) => !s.edit, hint: { keys: 'g', label: 'refresh' } },
   { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
   { capture: 'setDraft', when: (s) => !!s.edit },

package/dist/builtin-views/settings/web.jsx

@@ -2,9 +2,9 @@
 /**
  * Model ladders settings — web presenter for the `settings` view.
  *
- * Mouse-first: enum fields (default provider, persona strength) are click-to-pick
- * chips that save immediately; free-text fields (matrix model ids, new persona)
- * open an inline editor prefilled with the current value, with Save/Cancel.
+ * Mouse-first: the enum field (default provider) is a click-to-pick chip that
+ * saves immediately; free-text fields (matrix model ids) open an inline editor
+ * prefilled with the current value, with Save/Cancel.
  *
  * @module settings/web
  */
@@ -16,33 +16,6 @@ import { Loading, NotReady, ErrorState } from '@crouton-kit/crouter/web';
 const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
 const PROVIDERS = ['anthropic', 'openai'];
 
-/** Inline editor for a free-text field (matrix model id, new persona pair). */
-/** @param {{ state: SettingsState, dispatch: (intent:string, payload?:unknown)=>void }} props */
-function Editor({ state, dispatch }) {
-  if (!state.edit) return null;
-  return (
-    <div className="rounded border border-cyan-300 bg-cyan-50 p-3">
-      <div className="mb-2 text-sm text-slate-600">Editing <span className="font-semibold text-slate-900">{state.edit.label}</span></div>
-      <div className="flex items-center gap-2">
-        <input
-          autoFocus
-          value={state.edit.draft}
-          placeholder={state.edit.kind === 'personaNew' ? 'kind strength' : 'model id'}
-          onChange={(e) => dispatch('setDraft', e.target.value)}
-          onKeyDown={(e) => {
-            if (e.key === 'Enter') { e.preventDefault(); dispatch('submitEdit'); }
-            else if (e.key === 'Escape') { e.preventDefault(); dispatch('cancelEdit'); }
-          }}
-          className="flex-1 rounded border border-slate-300 bg-white px-3 py-2 font-mono text-sm outline-none focus:border-cyan-500"
-        />
-        <button type="button" onClick={() => dispatch('submitEdit')} className="rounded bg-cyan-600 px-3 py-2 text-sm font-semibold text-white hover:bg-cyan-700">Save</button>
-        <button type="button" onClick={() => dispatch('cancelEdit')} className="rounded border border-slate-300 bg-white px-3 py-2 text-sm text-slate-600 hover:bg-slate-100">Cancel</button>
-      </div>
-      {state.edit.kind === 'personaNew' ? <div className="mt-2 text-xs text-slate-500">Format: <code>kind strength</code> or <code>kind=strength</code> (strength = ultra·strong·medium·light).</div> : null}
-    </div>
-  );
-}
-
 /** A small segmented control of fixed choices that saves on click. */
 /** @param {{ choices: string[], value: string, onPick: (c:string)=>void }} props */
 function Segmented({ choices, value, onPick }) {
@@ -80,8 +53,6 @@ export default function Settings({ state, dispatch }) {
   }
 
   const ladders = state.modelLadders;
-  const personas = Object.keys(state.personaStrengths).sort((a, b) => a.localeCompare(b));
-  const editingPersonaNew = !!state.edit && state.edit.kind === 'personaNew';
 
   return (
     <div className="h-full overflow-auto text-sm">
@@ -144,23 +115,6 @@ export default function Settings({ state, dispatch }) {
             </div>
           ))}
         </div>
-
-        {/* Persona strengths — enum per persona, click to pick. */}
-        <div className="space-y-2">
-          <div className="font-semibold">Persona strengths</div>
-          {personas.length === 0 ? <div className="text-xs text-slate-400">None set yet.</div> : null}
-          {personas.map((persona) => (
-            <div key={persona} className="flex items-center gap-3">
-              <span className="w-40 truncate font-mono text-slate-800">{persona}</span>
-              <Segmented choices={STRENGTHS} value={state.personaStrengths[persona] ?? 'strong'} onPick={(s) => dispatch('applyValue', { kind: 'personaStrength', persona, value: s })} />
-            </div>
-          ))}
-          {editingPersonaNew ? (
-            <Editor state={state} dispatch={dispatch} />
-          ) : (
-            <button type="button" onClick={() => dispatch('beginEditFor', { kind: 'addPersona' })} className="rounded border border-dashed border-emerald-400 px-3 py-1.5 text-sm font-semibold text-emerald-700 hover:bg-emerald-50">+ add persona strength</button>
-          )}
-        </div>
       </div>
     </div>
   );