@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/shared/models-config.test.ts

@@ -0,0 +1,124 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  validateModelsConfig,
+  mergeModelsConfig,
+  normalizeModelsConfigForPi,
+  withImageInput,
+  type ModelsConfig,
+} from './models-config'
+
+test('empty config is valid', () => {
+  assert.deepEqual(validateModelsConfig({ providers: {} }), [])
+})
+
+test('flags empty provider key', () => {
+  const errs = validateModelsConfig({ providers: { '': { models: [{ id: 'a' }] } } })
+  assert.ok(errs.some((e) => e.toLowerCase().includes('provider')))
+})
+
+test('flags model with empty id', () => {
+  const errs = validateModelsConfig({ providers: { p: { models: [{ id: '' }] } } })
+  assert.ok(errs.some((e) => e.toLowerCase().includes('id')))
+})
+
+test('flags duplicate model id within a provider', () => {
+  const errs = validateModelsConfig({
+    providers: { p: { models: [{ id: 'x' }, { id: 'x' }] } },
+  })
+  assert.ok(errs.some((e) => e.toLowerCase().includes('duplicate')))
+})
+
+test('flags non-finite numeric field', () => {
+  const errs = validateModelsConfig({
+    providers: { p: { models: [{ id: 'x', contextWindow: Number.NaN }] } },
+  })
+  assert.ok(errs.some((e) => e.toLowerCase().includes('contextwindow')))
+})
+
+test('merge preserves unknown top-level, provider, and model fields', () => {
+  const original: ModelsConfig = {
+    $schema: 'https://x',
+    providers: {
+      p: {
+        baseUrl: 'http://old',
+        authHeader: true,
+        compat: { supportsDeveloperRole: false },
+        models: [{ id: 'm', thinkingLevelMap: { high: 'max' }, contextWindow: 1000 }],
+      },
+    },
+  } as ModelsConfig
+  const edited: ModelsConfig = {
+    providers: { p: { baseUrl: 'http://new', models: [{ id: 'm', contextWindow: 2000 }] } },
+  }
+  const merged = mergeModelsConfig(original, edited)
+  assert.equal((merged as Record<string, unknown>).$schema, 'https://x')
+  assert.equal(merged.providers.p.baseUrl, 'http://new')
+  assert.equal(merged.providers.p.authHeader, true)
+  assert.deepEqual(merged.providers.p.compat, { supportsDeveloperRole: false })
+  assert.equal(merged.providers.p.models![0].contextWindow, 2000)
+  assert.deepEqual(merged.providers.p.models![0].thinkingLevelMap, { high: 'max' })
+})
+
+test('merge adds new and drops removed providers/models', () => {
+  const original: ModelsConfig = {
+    providers: { keep: { models: [{ id: 'a' }, { id: 'gone' }] }, drop: {} },
+  }
+  const edited: ModelsConfig = {
+    providers: { keep: { models: [{ id: 'a' }] }, fresh: { models: [{ id: 'b' }] } },
+  }
+  const merged = mergeModelsConfig(original, edited)
+  assert.deepEqual(Object.keys(merged.providers).sort(), ['fresh', 'keep'])
+  assert.deepEqual(merged.providers.keep.models!.map((m) => m.id), ['a'])
+})
+
+test('normalizes Ollama Cloud reasoning effort support for thinking models', () => {
+  const normalized = normalizeModelsConfigForPi({
+    providers: {
+      'ollama-cloud': {
+        baseUrl: 'https://ollama.com/v1',
+        api: 'openai-completions',
+        compat: {
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false,
+          supportsUsageInStreaming: true,
+        },
+        models: [
+          {
+            id: 'glm-5.2:cloud',
+            reasoning: true,
+          },
+        ],
+      },
+    },
+  })
+
+  assert.equal(normalized.providers['ollama-cloud'].compat?.supportsReasoningEffort, true)
+  assert.equal(normalized.providers['ollama-cloud'].compat?.supportsDeveloperRole, false)
+  assert.equal(normalized.providers['ollama-cloud'].compat?.supportsUsageInStreaming, true)
+})
+
+test('withImageInput enables image while keeping text', () => {
+  assert.deepEqual(withImageInput(['text'], true), ['text', 'image'])
+})
+
+test('withImageInput defaults missing input to text before enabling image', () => {
+  assert.deepEqual(withImageInput(undefined, true), ['text', 'image'])
+})
+
+test('withImageInput is idempotent when image already present', () => {
+  assert.deepEqual(withImageInput(['text', 'image'], true), ['text', 'image'])
+})
+
+test('withImageInput removes image but keeps text when disabled', () => {
+  assert.deepEqual(withImageInput(['text', 'image'], false), ['text'])
+})
+
+test('withImageInput keeps text when disabling on a text-only model', () => {
+  assert.deepEqual(withImageInput(['text'], false), ['text'])
+})
+
+test('withImageInput adds missing text for an image-only input', () => {
+  assert.deepEqual(withImageInput(['image'], true), ['text', 'image'])
+  assert.deepEqual(withImageInput(['image'], false), ['text'])
+})

package/apps/sessrumnir/src/shared/models-config.ts

@@ -0,0 +1,167 @@
+import { t } from './i18n'
+
+export interface CustomModelCost {
+  input: number
+  output: number
+  cacheRead: number
+  cacheWrite: number
+}
+
+export interface ModelCompat {
+  supportsReasoningEffort?: boolean
+  supportsDeveloperRole?: boolean
+  supportsUsageInStreaming?: boolean
+  [key: string]: unknown
+}
+
+export interface CustomModel {
+  id: string
+  name?: string
+  api?: string
+  reasoning?: boolean
+  input?: string[]
+  contextWindow?: number
+  maxTokens?: number
+  cost?: CustomModelCost
+  // Preserve fields the editor does not expose (compat, thinkingLevelMap, ...).
+  [key: string]: unknown
+}
+
+export interface ProviderConfig {
+  baseUrl?: string
+  api?: string
+  apiKey?: string
+  models?: CustomModel[]
+  compat?: ModelCompat
+  // Preserve headers, authHeader, modelOverrides, compat, ...
+  [key: string]: unknown
+}
+
+export interface ModelsConfig {
+  providers: Record<string, ProviderConfig>
+  [key: string]: unknown
+}
+
+const NUMERIC_MODEL_FIELDS: Array<keyof CustomModel> = ['contextWindow', 'maxTokens']
+
+/**
+ * Validate a models config. Returns human-readable error strings; an empty array
+ * means valid. Provider keys are inherently unique in the object, so duplicate-key
+ * detection belongs to the editor (array) layer.
+ */
+export function validateModelsConfig(config: ModelsConfig): string[] {
+  const errors: string[] = []
+  const providers = config.providers ?? {}
+  for (const [key, provider] of Object.entries(providers)) {
+    if (key.trim().length === 0) {
+      errors.push(t('errors.models.providerKeyEmpty'))
+    }
+    const models = provider.models ?? []
+    const seen = new Set<string>()
+    for (const model of models) {
+      const id = (model.id ?? '').trim()
+      if (id.length === 0) {
+        errors.push(t('errors.models.modelMissingId', { key }))
+        continue
+      }
+      if (seen.has(id)) {
+        errors.push(t('errors.models.duplicateModelId', { key, id }))
+      }
+      seen.add(id)
+      for (const field of NUMERIC_MODEL_FIELDS) {
+        const value = model[field]
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value))) {
+          errors.push(t('errors.models.fieldNotFiniteNumber', { key, id, field }))
+        }
+      }
+    }
+  }
+  return errors
+}
+
+/**
+ * Produce the object to write to models.json. Overlays edited known fields onto
+ * the original so unknown fields (top-level, per-provider, per-model) are kept.
+ * Providers/models absent from `edited` are dropped; new ones are added.
+ */
+export function mergeModelsConfig(original: ModelsConfig, edited: ModelsConfig): ModelsConfig {
+  const result: ModelsConfig = { ...original, providers: {} }
+  for (const [key, prov] of Object.entries(edited.providers ?? {})) {
+    const origProv = original.providers?.[key] ?? {}
+    const origModels = origProv.models ?? []
+    const mergedModels = (prov.models ?? []).map((m) => {
+      const origModel = origModels.find((o) => o.id === m.id) ?? {}
+      return { ...origModel, ...m }
+    })
+    result.providers[key] = { ...origProv, ...prov, models: mergedModels }
+  }
+  return normalizeModelsConfigForPi(result)
+}
+
+export function normalizeModelsConfigForPi(config: ModelsConfig): ModelsConfig {
+  const providers: ModelsConfig['providers'] = {}
+  let changed = false
+
+  for (const [key, provider] of Object.entries(config.providers ?? {})) {
+    let nextProvider = provider
+
+    if (shouldEnableOllamaCloudReasoningEffort(provider)) {
+      nextProvider = {
+        ...nextProvider,
+        compat: {
+          ...(nextProvider.compat ?? {}),
+          supportsReasoningEffort: true,
+        },
+      }
+      changed = true
+    }
+
+    providers[key] = nextProvider
+  }
+
+  return changed ? { ...config, providers } : config
+}
+
+function isOllamaCloudProvider(provider: ProviderConfig): boolean {
+  const baseUrl = provider.baseUrl?.replace(/\/+$/, '')
+  return (baseUrl === 'https://ollama.com' || baseUrl === 'https://ollama.com/v1') && provider.api === 'openai-completions'
+}
+
+function shouldEnableOllamaCloudReasoningEffort(provider: ProviderConfig): boolean {
+  if (!isOllamaCloudProvider(provider)) return false
+  if (provider.compat?.supportsReasoningEffort === true) return false
+  return (provider.models ?? []).some((model) => model.reasoning === true)
+}
+
+const TEXT_INPUT = 'text'
+const IMAGE_INPUT = 'image'
+
+/**
+ * Toggle image (vision) support in a model's `input` modalities while always
+ * keeping text. Returns a new array; never mutates the input.
+ */
+export function withImageInput(input: string[] | undefined, enabled: boolean): string[] {
+  const base = input && input.length > 0 ? input : [TEXT_INPUT]
+  const withText = base.includes(TEXT_INPUT) ? base : [TEXT_INPUT, ...base]
+  if (enabled) {
+    return withText.includes(IMAGE_INPUT) ? [...withText] : [...withText, IMAGE_INPUT]
+  }
+  return withText.filter((modality) => modality !== IMAGE_INPUT)
+}
+
+/**
+ * Resolve a model id to its display name from a models config, scanning every
+ * provider's models. Returns the raw id when the config is missing or has no
+ * matching model with a name (the caller's fallback).
+ */
+export function modelDisplayName(modelId: string, config: ModelsConfig | null): string {
+  if (!modelId || !config) return modelId
+  for (const provider of Object.values(config.providers ?? {})) {
+    for (const model of provider.models ?? []) {
+      if (model.id === modelId && typeof model.name === 'string' && model.name.trim().length > 0) {
+        return model.name
+      }
+    }
+  }
+  return modelId
+}

package/apps/sessrumnir/src/shared/package-filter.ts

@@ -0,0 +1,19 @@
+import type { CatalogPackage } from './ipc-contracts'
+
+/**
+ * Match every whitespace-separated token against the combined name, description
+ * and author. Tokenizing lets multi-word queries like "ollama cloud" match a
+ * package named "pi-ollama-cloud". Pure, so it runs the same in the main
+ * process (initial crawl filter) and the renderer (live search filtering).
+ */
+export function filterCatalog(
+  packages: CatalogPackage[],
+  query: string | undefined
+): CatalogPackage[] {
+  if (!query || !query.trim()) return packages
+  const tokens = query.trim().toLowerCase().split(/\s+/)
+  return packages.filter((pkg) => {
+    const haystack = `${pkg.name} ${pkg.description} ${pkg.author}`.toLowerCase()
+    return tokens.every((token) => haystack.includes(token))
+  })
+}

package/apps/sessrumnir/src/shared/package-spec.test.ts

@@ -0,0 +1,51 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { isValidPackageSpec } from './package-spec'
+
+test('accepts a scoped npm spec with version', () => {
+  assert.equal(isValidPackageSpec('npm:@earendil/pi-free@1.2.3'), true)
+})
+
+test('accepts a bare npm spec and a dist-tag', () => {
+  assert.equal(isValidPackageSpec('npm:pi-ollama-cloud@latest'), true)
+  assert.equal(isValidPackageSpec('left-pad'), true)
+  assert.equal(isValidPackageSpec('@scope/name'), true)
+})
+
+test('accepts a git source with a ref', () => {
+  assert.equal(isValidPackageSpec('git:github.com/user/repo@main'), true)
+})
+
+test('rejects an empty or whitespace spec', () => {
+  assert.equal(isValidPackageSpec(''), false)
+  assert.equal(isValidPackageSpec('   '), false)
+  assert.equal(isValidPackageSpec('npm:foo bar'), false)
+})
+
+test('rejects shell metacharacters that enable command injection', () => {
+  for (const spec of [
+    'foo; rm -rf ~',
+    'foo && calc',
+    'foo | tee x',
+    'foo`id`',
+    'foo$(id)',
+    'foo > out',
+    'foo\nbar',
+    'foo"bar',
+    "foo'bar",
+    'foo\\bar',
+    'foo%PATH%',
+    'foo^bar',
+  ]) {
+    assert.equal(isValidPackageSpec(spec), false, `expected reject: ${JSON.stringify(spec)}`)
+  }
+})
+
+test('rejects a spec that starts like a CLI flag', () => {
+  assert.equal(isValidPackageSpec('-rf'), false)
+  assert.equal(isValidPackageSpec('--force'), false)
+})
+
+test('rejects an over-long spec', () => {
+  assert.equal(isValidPackageSpec(`npm:${'a'.repeat(300)}`), false)
+})

package/apps/sessrumnir/src/shared/package-spec.ts

@@ -0,0 +1,25 @@
+/**
+ * Validation for Pi package specifications typed by the user or supplied by the
+ * remote catalog. The spec is forwarded to `pi install/remove <spec>`, which on
+ * Windows can run through a `.cmd/.bat/.ps1` shim with `shell:true`. Rejecting
+ * shell metacharacters here prevents an install/remove spec from injecting
+ * additional commands in that configuration.
+ */
+
+const MAX_PACKAGE_SPEC_LENGTH = 200
+
+// First character must be alphanumeric or `@` (scope) — never `-`, so a spec
+// can't be parsed as a CLI flag. Remaining characters are limited to those that
+// appear in concrete specs: scopes/paths (@ /), exact versions (. - +), protocol
+// (:), and word characters. Excludes whitespace and every shell metacharacter
+// (including cmd.exe's `^` escape and semver-range chars `~`/`^` we don't need).
+const PACKAGE_SPEC_PATTERN = /^[A-Za-z0-9@][A-Za-z0-9@/._:+-]*$/
+
+/** True when `spec` is a safe package specification to hand to the Pi CLI. */
+export function isValidPackageSpec(spec: string): boolean {
+  return (
+    spec.length > 0 &&
+    spec.length <= MAX_PACKAGE_SPEC_LENGTH &&
+    PACKAGE_SPEC_PATTERN.test(spec)
+  )
+}

package/apps/sessrumnir/src/shared/path-compare.test.ts

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { pathGroupKey, pathsEqual, isPathCaseInsensitive } from './path-compare'
+
+test('pathsEqual matches exact paths (case-sensitive mode)', () => {
+  assert.equal(pathsEqual('/home/alice/App', '/home/alice/App', false), true)
+  assert.equal(pathsEqual('/home/alice/App', '/home/alice/app', false), false)
+})
+
+test('pathsEqual folds case when case-insensitive (Windows mode)', () => {
+  assert.equal(
+    pathsEqual('C:\\Users\\UPN\\Documents\\workday', 'C:\\Users\\UPN\\documents\\workday', true),
+    true
+  )
+  assert.equal(pathsEqual('C:\\a', 'C:\\b', true), false)
+})
+
+test('pathsEqual strips a single trailing separator', () => {
+  assert.equal(pathsEqual('/home/alice/proj/', '/home/alice/proj', false), true)
+  assert.equal(pathsEqual('C:\\work\\repo\\', 'C:\\work\\repo', true), true)
+  assert.equal(pathsEqual('/a/b/', '/a/c', false), false)
+})
+
+test('pathGroupKey folds only in case-insensitive mode', () => {
+  assert.equal(pathGroupKey('C:\\Work\\Repo', true), 'c:\\work\\repo')
+  assert.equal(pathGroupKey('/Home/Alice', false), '/Home/Alice')
+  assert.equal(pathGroupKey('/Home/Alice/', false), '/Home/Alice')
+})
+
+test('isPathCaseInsensitive honors explicit override', () => {
+  assert.equal(isPathCaseInsensitive(true), true)
+  assert.equal(isPathCaseInsensitive(false), false)
+})
+
+test('isPathCaseInsensitive uses Node process.platform when no bridge', () => {
+  // Node test runner has process.platform; matches host OS.
+  assert.equal(isPathCaseInsensitive(), process.platform === 'win32')
+})

package/apps/sessrumnir/src/shared/path-compare.ts

@@ -0,0 +1,76 @@
+/**
+ * Platform-aware path comparison shared by main and renderer.
+ * Case-insensitive only on win32.
+ *
+ * Renderer note: sandboxed pages (`nodeIntegration: false`) have no Node
+ * `process` global. The preload bridge exposes `piDesktop.system.platform`
+ * (from the preload's process polyfill) so this helper still detects Windows.
+ */
+
+function readBridgedPlatform(): string | undefined {
+  try {
+    const g = globalThis as {
+      piDesktop?: { system?: { platform?: string } }
+    }
+    const bridged = g.piDesktop?.system?.platform
+    return typeof bridged === 'string' ? bridged : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function readNodePlatform(): string | undefined {
+  try {
+    if (typeof process !== 'undefined' && typeof process.platform === 'string') {
+      return process.platform
+    }
+  } catch {
+    // ignore
+  }
+  return undefined
+}
+
+/**
+ * Resolve whether path comparisons should fold case.
+ * Order: explicit override (tests) → bridged platform (renderer) → Node process (main).
+ */
+export function isPathCaseInsensitive(
+  caseInsensitive?: boolean
+): boolean {
+  if (typeof caseInsensitive === 'boolean') return caseInsensitive
+  const platform = readBridgedPlatform() ?? readNodePlatform()
+  return platform === 'win32'
+}
+
+/** Strip trailing slash/backslash for stable equality. */
+function stripTrailingSep(path: string): string {
+  return path.replace(/[\\/]+$/, '')
+}
+
+/**
+ * Whether two filesystem paths refer to the same location.
+ * Optional `caseInsensitive` override is for tests and callers that already
+ * know the target filesystem semantics.
+ */
+export function pathsEqual(
+  a: string,
+  b: string,
+  caseInsensitive?: boolean
+): boolean {
+  const fold = isPathCaseInsensitive(caseInsensitive)
+  const na = stripTrailingSep(a)
+  const nb = stripTrailingSep(b)
+  return fold ? na.toLowerCase() === nb.toLowerCase() : na === nb
+}
+
+/**
+ * Stable map/group key for a path (case-fold only when pathsEqual does).
+ */
+export function pathGroupKey(
+  path: string,
+  caseInsensitive?: boolean
+): string {
+  const fold = isPathCaseInsensitive(caseInsensitive)
+  const n = stripTrailingSep(path)
+  return fold ? n.toLowerCase() : n
+}

package/apps/sessrumnir/src/shared/permission-mode.ts

@@ -0,0 +1,8 @@
+import type { PermissionMode } from './ipc-contracts'
+
+/** Every permission mode, in the order the UI lists them. */
+export const PERMISSION_MODES: readonly PermissionMode[] = ['plan-readonly', 'ask-edits', 'ask-commands', 'trusted']
+
+export function isPermissionMode(value: unknown): value is PermissionMode {
+  return typeof value === 'string' && (PERMISSION_MODES as readonly string[]).includes(value)
+}

package/apps/sessrumnir/src/shared/pi-command.test.ts

@@ -0,0 +1,165 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { t, type Translate } from './i18n'
+import {
+  BUILTIN_SOURCE,
+  commandDisplayName,
+  commandSourceLabel,
+  filterCommands,
+  groupCommands,
+  invocationToken,
+  isSlashCommandToken,
+  skillDisplayName,
+  type PiCommand,
+} from './pi-command'
+
+const cmds: PiCommand[] = [
+  { name: 'skill:web-search', description: 'Search the web', source: 'skill' },
+  { name: 'review', description: 'Review a diff', source: 'prompt' },
+  { name: 'deploy', description: 'Deploy via extension', source: 'extension' },
+]
+
+test('empty query returns all commands', () => {
+  assert.equal(filterCommands(cmds, '').length, 3)
+})
+
+test('matches on name (case-insensitive)', () => {
+  const r = filterCommands(cmds, 'WEB')
+  assert.equal(r.length, 1)
+  assert.equal(r[0].name, 'skill:web-search')
+})
+
+test('matches on description', () => {
+  const r = filterCommands(cmds, 'diff')
+  assert.equal(r.length, 1)
+  assert.equal(r[0].name, 'review')
+})
+
+test('strips a single leading slash from the query', () => {
+  assert.equal(filterCommands(cmds, '/review').length, 1)
+})
+
+test('no match returns empty array', () => {
+  assert.deepEqual(filterCommands(cmds, 'zzz'), [])
+})
+
+test('bare slash is a command token', () => {
+  assert.equal(isSlashCommandToken('/'), true)
+})
+
+test('slash followed by a name is a command token', () => {
+  assert.equal(isSlashCommandToken('/skill:plan'), true)
+})
+
+test('trailing space ends the command token (issue #50)', () => {
+  assert.equal(isSlashCommandToken('/skill:plan '), false)
+})
+
+test('arguments after the command are not a command token', () => {
+  assert.equal(isSlashCommandToken('/skill:plan implement login'), false)
+})
+
+test('text without a leading slash is not a command token', () => {
+  assert.equal(isSlashCommandToken('hello'), false)
+  assert.equal(isSlashCommandToken(''), false)
+  assert.equal(isSlashCommandToken(' /plan'), false)
+})
+
+test('newline ends the command token', () => {
+  assert.equal(isSlashCommandToken('/plan\nmore'), false)
+})
+
+test('skill invocation token adds the skill: prefix and trailing space', () => {
+  assert.equal(invocationToken('plan', 'skill'), '/skill:plan ')
+})
+
+test('skill invocation token does not double an existing skill: prefix', () => {
+  assert.equal(invocationToken('skill:plan', 'skill'), '/skill:plan ')
+})
+
+test('skillDisplayName strips the skill: prefix only once and only at the start', () => {
+  assert.equal(skillDisplayName('skill:plan'), 'plan')
+  assert.equal(skillDisplayName('plan'), 'plan')
+  assert.equal(skillDisplayName('my-skill:plan'), 'my-skill:plan')
+})
+
+test('commandDisplayName drops the skill: prefix from skills (issue #60)', () => {
+  assert.equal(commandDisplayName(cmds[0]), 'web-search')
+})
+
+test('commandDisplayName shows built-ins in slash form and others as-is', () => {
+  assert.equal(commandDisplayName({ name: 'compact', description: '', source: BUILTIN_SOURCE }), '/compact')
+  assert.equal(commandDisplayName(cmds[1]), 'review')
+  assert.equal(commandDisplayName(cmds[2]), 'deploy')
+})
+
+test('non-skill invocation token is /name with trailing space', () => {
+  assert.equal(invocationToken('review', 'prompt'), '/review ')
+  assert.equal(invocationToken('deploy', 'extension'), '/deploy ')
+})
+
+test('groupCommands orders groups skills, prompts, builtins, extensions', () => {
+  const mixed: PiCommand[] = [
+    { name: 'deploy', description: '', source: 'extension' },
+    { name: 'compact', description: '', source: BUILTIN_SOURCE },
+    { name: 'review', description: '', source: 'prompt' },
+    { name: 'skill:plan', description: '', source: 'skill' },
+  ]
+  const { grouped } = groupCommands(mixed)
+  assert.deepEqual(
+    grouped.map((g) => g.label),
+    ['Skills', 'Prompts', 'Commands', 'Extensions']
+  )
+})
+
+test('groupCommands drops empty groups', () => {
+  const { grouped } = groupCommands([{ name: 'review', description: '', source: 'prompt' }])
+  assert.deepEqual(
+    grouped.map((g) => g.label),
+    ['Prompts']
+  )
+})
+
+test('groupCommands puts unknown sources in a trailing Other group', () => {
+  const { grouped } = groupCommands([
+    { name: 'review', description: '', source: 'prompt' },
+    { name: 'mystery', description: '', source: 'plugin' },
+  ])
+  assert.deepEqual(
+    grouped.map((g) => g.label),
+    ['Prompts', 'Other']
+  )
+  assert.equal(grouped[1].items[0].name, 'mystery')
+})
+
+test('commandSourceLabel translates known sources', () => {
+  assert.deepEqual(
+    ['skill', 'prompt', BUILTIN_SOURCE, 'extension'].map((source) => commandSourceLabel(source, t)),
+    ['skill', 'prompt', 'builtin', 'extension']
+  )
+})
+
+test('commandSourceLabel shows an unknown source as Pi sent it', () => {
+  const unknownSource = 'plugin'
+  let translatorCalled = false
+  const spy = ((key: string) => {
+    translatorCalled = true
+    return key
+  }) as unknown as Translate
+  assert.equal(commandSourceLabel(unknownSource, spy), unknownSource)
+  assert.equal(translatorCalled, false)
+})
+
+test('groupCommands flat list matches visual group order', () => {
+  const mixed: PiCommand[] = [
+    { name: 'deploy', description: '', source: 'extension' },
+    { name: 'skill:plan', description: '', source: 'skill' },
+    { name: 'mystery', description: '', source: 'plugin' },
+    { name: 'review', description: '', source: 'prompt' },
+  ]
+  const { flat } = groupCommands(mixed)
+  assert.deepEqual(
+    flat.map((c) => c.name),
+    ['skill:plan', 'review', 'deploy', 'mystery']
+  )
+})