@frontera-sdk/cli 1.52.39 → 1.52.41

package/src/commands/local/init.ts

@@ -8,7 +8,8 @@ import { slugify } from '../../local/local-project'
 import { readProviderSetup } from '../../local/local-providers'
 import { readLink } from '../../local/local-sync-link'
 import { generateSyntheticData, addMissingBackings, loadScenario, SCENARIO_TEMPLATE } from '../../local/local-synthetic-data'
-import { writeSolutionScaffold } from '../../local/local-scaffold'
+import { isoDay, writeSampleOptions } from '../../local/local-sample-remake'
+import { migrateMcpConfigs, writeSolutionScaffold } from '../../local/local-scaffold'
 import { flagBool, flagString, type Command, type CommandContext } from '../types'
 import { localSync } from './sync'
 
@@ -37,6 +38,7 @@ export const localInit: Command = {
       'org-key': 'string',
       kinds: 'string',
       'no-sample-data': 'boolean',
+      'no-app-code': 'boolean',
       rows: 'string',
       seed: 'string',
     },
@@ -48,7 +50,6 @@ export const localInit: Command = {
       'frontera local init acme --from-workspace --platform $URL --workspace-key -',
     ],
     offline: true,
-    internal: true,
   },
 
   async run(ctx) {
@@ -73,6 +74,12 @@ export const localInit: Command = {
     // The starter Agent takes the model the FDE chose for new Agents (`frontera local model-default`);
     // a project started from a workspace gets the workspace's Agents instead of the examples.
     const scaffold = writeSolutionScaffold(target, name, force, { agentModel: readProviderSetup().defaults.agentModel, samples: !fromWorkspace })
+    // A config kept (not --force) that still launches `frontera local docs-mcp` launches `frontera mcp`.
+    for (const file of migrateMcpConfigs(target)) {
+      if (!scaffold.written.includes(file)) scaffold.written.push(file)
+      const at = scaffold.skipped.indexOf(file)
+      if (at >= 0) scaffold.skipped.splice(at, 1)
+    }
     const listed = (files: string[]) => files.filter((f) => !f.startsWith('vendor/'))
     const written = [...new Set(listed([...scaffold.written, ...harness.written]))]
     const skipped = listed([...scaffold.skipped, ...harness.skipped]).filter((f) => !written.includes(f))
@@ -131,14 +138,16 @@ async function startFromWorkspace(ctx: CommandContext, target: string): Promise<
   } else if (!readLink(target)) {
     throw new UsageError('no workspace to start from', 'pass --platform <url> --workspace-key - with the key on stdin')
   }
-  const kinds = flagString(ctx, 'kinds') ?? 'blueprint,skills,functions,plugins,knowledge,workflows,agents,evaluations'
+  // Everything a solution is made of: Apps, Chat Apps and slide themes too, so a pulled project has what the workspace lists.
+  const kinds = flagString(ctx, 'kinds') ?? 'blueprint,skills,functions,plugins,knowledge,workflows,agents,evaluations,themes,chat-apps,apps'
   // `none` links the project and pulls nothing, for someone who picks items next (`local sync pull <kind/name>…`).
   if (kinds === 'none') {
     const link = readLink(target)
     return { workspace: link?.workspaceName ?? link?.workspace ?? 'the workspace', pulled: 0, sampleRows: 0 }
   }
   ctx.output.note(`Pulling ${kinds.split(',').join(', ')}`)
-  const pull = (await localSync.run({ ...sub, positional: ['pull'], flags: { kinds } })).data as { pulled: string[]; warnings: string[] }
+  // Custom Apps come with their code (apps/<slug>/), unless --no-app-code.
+  const pull = (await localSync.run({ ...sub, positional: ['pull'], flags: { kinds, ...(flagBool(ctx, 'no-app-code') ? { 'no-app-code': true } : {}) } })).data as { pulled: string[]; warnings: string[] }
   for (const w of pull.warnings) ctx.output.note(`  could not read ${w}`)
   let sampleRows = 0
   const wantsData = !flagBool(ctx, 'no-sample-data') && existsSync(join(target, 'blueprint', 'object-types'))
@@ -152,7 +161,11 @@ async function startFromWorkspace(ctx: CommandContext, target: string): Promise<
     }
     addMissingBackings(target)
     const scenario = await loadScenario(target, seed)
-    sampleRows = generateSyntheticData(target, { rows: Number(flagString(ctx, 'rows') ?? 200), seed, scenario: scenario ?? undefined }).reduce((n, d) => n + d.rows, 0)
+    const rows = Number(flagString(ctx, 'rows') ?? 200)
+    // Today, kept with the seed and rows: a pull that brings Blueprint items makes the same rows again.
+    const today = isoDay(new Date())
+    sampleRows = generateSyntheticData(target, { rows, seed, today: new Date(`${today}T00:00:00Z`), scenario: scenario ?? undefined }).reduce((n, d) => n + (d.kept ? 0 : d.rows), 0)
+    writeSampleOptions(target, { seed, rows, today, madeBy: 'pull' })
   }
   const link = readLink(target)
   return { workspace: link?.workspaceName ?? link?.workspace ?? 'the workspace', pulled: pull.pulled.length, sampleRows }

package/src/commands/local/key.ts

@@ -38,7 +38,6 @@ export const localKeySet: Command = {
     summary: 'Store your model-provider key for the local runtime (OS keychain)',
     examples: ['frontera local key-set anthropic', 'printf %s "$KEY" | frontera local key-set openrouter --stdin'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const provider = providerArg(ctx.positional[0])
@@ -75,7 +74,6 @@ export const localKeyList: Command = {
     summary: 'List which providers have a key for the local runtime',
     examples: ['frontera local key-list'],
     offline: true,
-    internal: true,
   },
   async run() {
     const configured = new Set(configuredProviders())
@@ -96,7 +94,6 @@ export const localKeyRemove: Command = {
     summary: 'Remove a stored model-provider key',
     examples: ['frontera local key-remove openai'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const provider = providerArg(ctx.positional[0])

package/src/commands/local/providers.ts

@@ -64,7 +64,6 @@ export const localProviders: Command = {
     summary: 'List the model providers, models and default models of your local runtimes',
     examples: ['frontera local providers', 'frontera local providers --json'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const setup = readProviderSetup()
@@ -102,7 +101,6 @@ export const localProviderAdd: Command = {
     summary: 'Add an OpenAI-compatible model provider (a gateway, Azure, a model served on this machine)',
     examples: ['frontera local provider-add ollama --base-url http://127.0.0.1:11434/v1', 'frontera local provider-add acme --base-url https://acme.example/v1 --stdin'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const slug = ctx.positional[0] ?? ''
@@ -129,7 +127,6 @@ export const localProviderRemove: Command = {
     summary: 'Remove an OpenAI-compatible provider, its key and its models',
     examples: ['frontera local provider-remove acme-gateway'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const slug = ctx.positional[0] ?? ''
@@ -158,7 +155,6 @@ export const localModelsAvailable: Command = {
     summary: "List the models a provider offers (needs the runtime running and the provider's key)",
     examples: ['frontera local models-available openrouter', 'frontera local models-available custom:acme-gateway --json'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const provider = ctx.positional[0] ?? ''
@@ -179,7 +175,6 @@ export const localModelAdd: Command = {
     summary: 'Make a model available to Agents in your local runtimes',
     examples: ['frontera local model-add openrouter openai/gpt-6-luna --name "GPT-6 Luna"', 'frontera local model-add custom:acme-gateway llama-4-70b'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const [provider = '', modelId = ''] = ctx.positional
@@ -202,7 +197,6 @@ export const localModelRemove: Command = {
     summary: 'Stop offering a model to Agents in your local runtimes',
     examples: ['frontera local model-remove gpt-6-luna'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const slug = ctx.positional[0] ?? ''
@@ -226,7 +220,6 @@ export const localModelDefault: Command = {
     summary: 'Choose the model new Agents start with and the one that grades tests',
     examples: ['frontera local model-default claude-sonnet-5-5', 'frontera local model-default gpt-6-luna --for tests'],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const slug = ctx.positional[0] ?? ''

package/src/commands/local/remove.ts

@@ -0,0 +1,116 @@
+import { existsSync, readdirSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { credentialStore } from '../../credential-store'
+import { CliError } from '../../errors'
+import { deleteProfile, getProfile } from '../../profiles'
+import { canPrompt, promptConfirm } from '../../prompt'
+import { destroyRuntimeData, localProfileName, stopRuntime } from '../../local/local-control'
+import { dockerAvailable } from '../../local/local-docker'
+import { portBlockOf, releasePorts } from '../../local/local-ports'
+import { localProject, type LocalProject } from '../../local/local-project'
+import { isAlive, readState } from '../../local/local-state'
+import { stopDevServers } from '../../mcp/mcp-apps'
+import { flagBool, type Command } from '../types'
+
+/**
+ * `frontera local remove`: delete this project's local runtime permanently.
+ *
+ * `stop --no-backup` and `reset` wipe the data of a runtime the project goes
+ * on using; this is for a project that is done with its runtime. It stops it,
+ * deletes its containers and volumes (the database and stored files), frees
+ * its port block for another project, forgets its CLI profiles and their
+ * keys, and clears the runtime's records under `.frontera/local`. The
+ * project's own files are untouched, and `frontera local start` makes a new,
+ * empty runtime.
+ */
+
+/** Left in place: written by Forge, which may still be attached to the project. */
+const KEPT_STATE_FILES = new Set(['forge.json'])
+
+function clearRuntimeFiles(project: LocalProject): void {
+  if (!existsSync(project.stateDir)) return
+  for (const name of readdirSync(project.stateDir)) {
+    if (KEPT_STATE_FILES.has(name)) continue
+    rmSync(join(project.stateDir, name), { recursive: true, force: true })
+  }
+}
+
+export const localRemove: Command = {
+  meta: {
+    noun: 'local',
+    verb: 'remove',
+    args: [],
+    flags: { force: 'boolean' },
+    summary: 'Delete the local runtime of this project and all its local data: database, stored files, keys, port block and CLI profiles',
+    details: [
+      'The local data cannot be recovered afterwards; the project\'s own files are kept. '
+        + 'Asks first unless --yes. A running runtime is refused unless --force, which stops it first. '
+        + '`frontera local start` afterwards makes a new, empty runtime.',
+    ],
+    examples: ['frontera local remove', 'frontera local remove --yes', 'frontera local remove --force --yes'],
+    offline: true,
+  },
+
+  async run(ctx) {
+    const project = localProject(ctx.cwd)
+    const state = readState(project)
+    const profile = localProfileName(project)
+    const profiles = [profile, `${profile}-org`.slice(0, 64)].filter((name) => getProfile(name))
+    const block = portBlockOf(project.id)
+    if (!state && !block && !profiles.length) {
+      return { data: { removed: false }, text: 'No local runtime here.' }
+    }
+
+    const running = Boolean(state?.supervisorPid && isAlive(state.supervisorPid))
+    if (running && !flagBool(ctx, 'force')) {
+      throw new CliError('the local runtime is running', {
+        code: 'LOCAL_RUNNING',
+        hint: 'stop it with `frontera local stop` first, or pass --force to stop and remove it',
+      })
+    }
+
+    if (!flagBool(ctx, 'yes')) {
+      const confirmed = canPrompt()
+        ? await promptConfirm(`Delete the local runtime of ${project.root}, with its database, stored files and keys? This cannot be undone.`)
+        : false
+      if (!confirmed) {
+        throw new CliError('removing the local runtime deletes its local data', {
+          code: 'USAGE',
+          hint: 're-run with --yes to confirm — its database, stored files and keys cannot be recovered afterwards',
+        })
+      }
+    }
+
+    const docker = dockerAvailable()
+    if (!docker.ok) {
+      throw new CliError(`cannot reach Docker to delete the runtime's containers and volumes: ${docker.reason}`, {
+        code: 'LOCAL_DOCKER',
+        hint: 'start Docker Desktop or OrbStack, then run `frontera local remove` again',
+      })
+    }
+
+    // Its App dev servers first, while their records (under .frontera/local) are still there to find them by.
+    const apps = stopDevServers(project)
+    await ctx.output.task('Stopping the local runtime', () => stopRuntime(project))
+    destroyRuntimeData(project)
+    clearRuntimeFiles(project)
+    releasePorts(project.id)
+    const store = credentialStore(process.env, { allowPlaintext: true })
+    for (const name of profiles) {
+      await store.delete(name)
+      deleteProfile(name)
+    }
+
+    return {
+      data: { removed: true, runtime: project.id, root: project.root, portBlockFreed: Boolean(block), profilesRemoved: profiles, ...(apps.length ? { appDevServersStopped: apps.map((a) => ({ app: a.slug, port: a.port, pid: a.pid })) } : {}) },
+      text: [
+        `Removed the local runtime of ${project.root}: its database, stored files and keys are deleted.`,
+        block ? `  Freed its ports (${block.studio}–${block.studio + 9}).` : null,
+        profiles.length ? `  Forgot the CLI profiles ${profiles.join(', ')}.` : null,
+        apps.length ? `  Stopped its App dev server${apps.length === 1 ? '' : 's'}: ${apps.map((a) => `${a.slug} (port ${a.port})`).join(', ')}.` : null,
+        '  `frontera local start` makes a new, empty runtime.',
+      ].filter(Boolean).join('\n'),
+    }
+  },
+}

package/src/commands/local/schema.ts

@@ -16,10 +16,9 @@ export const localSchema: Command = {
     verb: 'schema',
     args: [{ name: 'kind', required: false, description: SCHEMA_KINDS.join(' | ') }],
     flags: {},
-    summary: 'Print the JSON Schema of a project file (operating, agent, workflow, evals, dataset) for the runtime\'s release',
-    examples: ['frontera local schema', 'frontera local schema operating', "frontera local schema workflow | jq '.\"$defs\" | keys'"],
+    summary: 'Print the JSON Schema of a project file (Agent, its bindings, workflow, tests, dataset, slide theme, Blueprint) for the runtime\'s release',
+    examples: ['frontera local schema', 'frontera local schema operating', 'frontera local schema workflow-tests', 'frontera local schema blueprint-action', 'frontera local schema bindings', "frontera local schema workflow | jq '.\"$defs\" | keys'"],
     offline: true,
-    internal: true,
   },
   async run(ctx) {
     const kind = ctx.positional[0]
@@ -29,7 +28,7 @@ export const localSchema: Command = {
         data: kinds,
         text: [
           'Project file formats, as JSON Schema: `frontera local schema <kind>`.',
-          ...kinds.map((k) => `  ${k.kind.padEnd(10)} ${k.file}`),
+          ...kinds.map((k) => `  ${k.kind.padEnd(24)} ${k.file}`),
           '`frontera local start` keeps them in .frontera/local/schemas/<kind>.schema.json.',
         ].join('\n'),
       }

package/src/commands/local/sdk-refresh.ts

@@ -0,0 +1,59 @@
+import { UsageError } from '../../errors'
+import { localProject } from '../../local/local-project'
+import { ensureProjectBunfig } from '../../local/local-scaffold'
+import { refreshVendoredSdk, vendoredSdkState } from '../../local/local-vendored-sdk'
+import vendored from '../../vendor/sdk-sources.json'
+import { flagBool, type Command } from '../types'
+
+/**
+ * `frontera local sdk-refresh`: bring the project's vendored Functions SDK
+ * (`vendor/frontera/`, what its Function tests and typecheck use) to this
+ * CLI's copy. The files the CLI wrote and nobody changed are replaced (and
+ * `local dev` does that by itself); a file edited since is kept unless
+ * `--force`. A folder with no record of what wrote it has each differing
+ * file replaced and a copy kept. A copy known or likely to be newer than this
+ * CLI's (a newer CLI's manifest, or a pull from a newer platform release) is
+ * not replaced without `--force`.
+ */
+export const localSdkRefresh: Command = {
+  meta: {
+    noun: 'local',
+    verb: 'sdk-refresh',
+    args: [],
+    flags: { force: 'boolean' },
+    summary: "Bring the project's vendored Functions SDK (vendor/frontera/) to this CLI's copy",
+    details: [
+      "The files the CLI wrote and nobody changed are replaced; `frontera local dev` does that on its own. A file edited since the CLI wrote it is kept unless --force. A vendor/frontera/ with no vendor/frontera/.frontera-sdk.json can't tell an edit apart: each file that differs is replaced. Every edited file replaced is copied to .frontera/local/sdk-backup/<time>/ first.",
+      "It refuses to go back to an older SDK without --force: when vendor/frontera/.frontera-sdk.json says a newer CLI wrote the copy, or, with no such file, when the project was pulled from a platform release newer than this CLI. Upgrade the CLI instead; --force replaces the copy anyway.",
+    ],
+    examples: ['frontera local sdk-refresh', 'frontera local sdk-refresh --force'],
+    offline: true,
+  },
+  async run(ctx) {
+    const project = localProject(ctx.cwd)
+    const before = vendoredSdkState(project.root)
+    if (!before.vendored) throw new UsageError('this project keeps no vendored SDK (vendor/frontera/)', '`frontera local init` writes one in a new project')
+    // A copy known or likely to be newer than this CLI's is not replaced by an older one unasked.
+    if (before.newer && !flagBool(ctx, 'force')) {
+      const why = before.newer.by === 'manifest'
+        ? `vendor/frontera/ was written by a newer CLI (SDK ${before.newer.version}) than this one (${vendored.sdkVersion})`
+        : `the project was pulled from platform ${before.newer.version}, newer than this CLI's SDK (${vendored.sdkVersion}), and nothing records which SDK wrote vendor/frontera/`
+      throw new UsageError(`${why}: refreshing would replace it with an older copy, so nothing was changed`, `upgrade the Frontera CLI to ${before.newer.version} or later, then run this again; \`frontera local sdk-refresh --force\` replaces it with this CLI's copy anyway (a copy of each replaced file is kept under .frontera/local/sdk-backup/)`)
+    }
+    const done = refreshVendoredSdk(project.root, { force: flagBool(ctx, 'force'), backupAll: true })
+    // Written only when the project has none: `bun test` at its root runs the Functions' tests alone.
+    const bunfig = ensureProjectBunfig(project.root)
+    const changed = [...done.replaced, ...done.added]
+    return {
+      data: { ...done, version: vendored.sdkVersion, ...(bunfig ? { bunfig: 'bunfig.toml' } : {}) },
+      text: [
+        changed.length ? `Brought vendor/frontera/ to this CLI's SDK: ${changed.length} file${changed.length === 1 ? '' : 's'}` : 'vendor/frontera/ already matches this CLI\'s SDK',
+        ...done.replaced.map((f) => `  ~ ${f}`),
+        ...done.added.map((f) => `  + ${f}`),
+        ...done.kept.map((f) => `  · ${f} (edited since the CLI wrote it; --force replaces it)`),
+        ...(done.backup ? [`  the files replaced are copied to ${done.backup}/`] : []),
+        ...(bunfig ? ["bunfig.toml: written, so `bun test` here runs only the Functions' unit tests (functions/)"] : []),
+      ].join('\n'),
+    }
+  },
+}

package/src/commands/local/snapshot.ts

@@ -0,0 +1,100 @@
+import { CliError, UsageError } from '../../errors'
+import { appsLostWords } from '../../local/local-app-restore'
+import { BASELINE_DB, readBaseline, restoreBaseline, saveBaseline, secretsWords } from '../../local/local-db-snapshot'
+import { localIngestApi, settleKnowledge } from '../../local/local-knowledge-ingestion'
+import { localProject } from '../../local/local-project'
+import { projectSecretLines } from '../../local/local-project-secrets'
+import { waitForDatabaseReady } from '../../local/local-runtime-health'
+import { localSecretPresence } from '../../local/local-secrets'
+import { isAlive, readState } from '../../local/local-state'
+import { flagBool, type Command } from '../types'
+
+/**
+ * `frontera local snapshot save|restore`: the runtime's database as a
+ * baseline, and back. `local check` does both around its tests; this is the
+ * same, by hand: save after setting up data to come back to, restore to throw
+ * away what was written since. The catalog of managed datasets, object
+ * storage and local traces are not part of it. Workspace secrets are
+ * configuration, not data: a restore keeps them as they are now, unless
+ * `--exact` puts the baseline's back too.
+ */
+
+const ACTIONS = ['save', 'restore'] as const
+
+export const localSnapshot: Command = {
+  meta: {
+    noun: 'local',
+    verb: 'snapshot',
+    args: [{ name: 'action', required: true, description: ACTIONS.join(' | ') }],
+    flags: { exact: 'boolean' },
+    summary: 'Save the local database as a baseline, or restore it, throwing away what was written since (local check does this around its tests)',
+    details: [
+      'save keeps the database as it is now as the baseline, replacing the one before. restore puts the database back as the baseline holds it; the service, job engine and runner keep running and reconnect, and the command returns once the service reaches the database again (it waits up to 30 seconds).',
+      'Workspace secrets are configuration, not data: restore keeps them as they are now (set, changed or deleted since the baseline), and `local check` keeps them across its rollback too. `--exact` puts the baseline\'s secrets back as well.',
+      'Items applied after the baseline count as not applied once it is restored: the next `frontera local dev` applies them again (a running one does so at once).',
+      'Knowledge documents are read by a background job. save waits (up to two minutes) until no document is still being read, so the baseline never holds one half-read; restore queues any document the baseline holds unread to be read again, and waits for it.',
+    ],
+    examples: ['frontera local snapshot save', 'frontera local snapshot restore', 'frontera local snapshot restore --exact'],
+    offline: true,
+  },
+  async run(ctx) {
+    const action = ctx.positional[0]
+    if (!action || !(ACTIONS as readonly string[]).includes(action)) {
+      throw new UsageError(action ? `\`${action}\` is not a snapshot action` : 'say what to do', `use one of: ${ACTIONS.join(', ')} (\`frontera local snapshot save\`)`)
+    }
+    const project = localProject(ctx.cwd)
+    const state = readState(project)
+    if (!state?.credentials || state.phase !== 'ready' || !state.supervisorPid || !isAlive(state.supervisorPid)) {
+      throw new CliError('the local runtime is not running', { code: 'LOCAL_NOT_RUNNING', hint: 'run `frontera local start` first' })
+    }
+    const organizationId = state.credentials.organizationId
+    if (action === 'save' && flagBool(ctx, 'exact')) throw new UsageError('`--exact` is for restore', 'frontera local snapshot restore --exact')
+    const serviceUrl = `http://127.0.0.1:${state.ports.service}`
+    const ingest = localIngestApi(serviceUrl, state.credentials)
+    if (action === 'save') {
+      // A document mid-read would be kept unread, its reading lost on a restore: the save waits (bounded) for it.
+      const settled = ingest ? await settleKnowledge(ingest, state.credentials.workspaceId, { restoredAt: readBaseline(project, organizationId)?.restoredAt }) : null
+      const saved = await ctx.output.task('Saving the database as the baseline', () => saveBaseline(project, organizationId, { serviceAnswers: () => waitForDatabaseReady(`http://127.0.0.1:${state.ports.service}`) }, true))
+      if (!saved.ok) throw new CliError(saved.note, { code: 'LOCAL_SNAPSHOT_FAILED', hint: 'see `frontera local logs postgres`' })
+      const knowledge = settled?.lines ?? []
+      return {
+        data: { action, baseline: BASELINE_DB, ms: saved.ms, ...(knowledge.length ? { knowledge: knowledge.map((l) => l.replace(/^warning:\s*/, '')) } : {}) },
+        text: [`Saved the database as the baseline (${saved.ms} ms). \`frontera local snapshot restore\` puts it back.`, ...knowledge.map((l) => `  ${l}`)].join('\n'),
+      }
+    }
+    const exact = flagBool(ctx, 'exact')
+    const restored = await ctx.output.task('Restoring the database from the baseline', () =>
+      restoreBaseline(project, organizationId, { serviceAnswers: () => waitForDatabaseReady(`http://127.0.0.1:${state.ports.service}`) }, { secrets: exact ? 'baseline' : 'keep' }),
+    )
+    if (!restored.ok) throw new CliError(restored.note, { code: 'LOCAL_SNAPSHOT_FAILED', hint: 'see `frontera local logs postgres` and `frontera local logs service`' })
+    // The documents the baseline holds unread are read again: their reading went with the database the restore replaced.
+    const knowledge = ingest ? (await settleKnowledge(ingest, state.credentials.workspaceId, { afterRestore: true })).lines : []
+    // A secret the project needs that has no value since the restore: said now, not when its trigger refuses.
+    const secrets = projectSecretLines(project.root, await localSecretPresence(`http://127.0.0.1:${state.ports.service}`, state.credentials))
+      .map((l) => l.trim().replace(/^warning:\s*/, ''))
+      .filter((l) => /^Needs a value for /.test(l))
+    const lost = restored.appsLost ?? []
+    const items = (restored.reapply ?? 0) - lost.length
+    return {
+      data: {
+        action,
+        baseline: BASELINE_DB,
+        ms: restored.ms,
+        reapply: restored.reapply ?? 0,
+        // Custom Apps deployed after the baseline: not on the runtime now, deployed again by the next `local dev`.
+        ...(lost.length ? { appsLost: lost.map((a) => ({ app: a.name, dir: a.dir, deployment: a.lost, baselineDeployment: a.back })) } : {}),
+        // Names and counts only: what became of the workspace secrets.
+        workspaceSecrets: restored.secrets?.mode === 'keep' ? { kept: restored.secrets.ok, count: restored.secrets.kept, setAgain: restored.secrets.notKept, ...(restored.secrets.problem ? { problem: restored.secrets.problem } : {}) } : { kept: false, exact: exact },
+        ...(secrets.length ? { secrets } : {}),
+        ...(knowledge.length ? { knowledge: knowledge.map((l) => l.replace(/^warning:\s*/, '')) } : {}),
+      },
+      text: [
+        `Restored the database from the baseline: what was written since is gone (${restored.ms} ms).${items ? ` ${items} item${items === 1 ? '' : 's'} applied after the baseline will apply again on the next \`frontera local dev\`.` : ''}`,
+        ...(lost.length ? [`  ${appsLostWords(lost).replace(/^./, (c) => c.toUpperCase())}.`] : []),
+        ...(restored.secrets ? [`  ${secretsWords(restored.secrets).replace(/^./, (c) => c.toUpperCase())}${restored.secrets.mode === 'keep' && restored.secrets.ok && !restored.secrets.notKept.length ? ': secrets are configuration, not test data (`--exact` restores the baseline’s).' : '.'}`] : []),
+        ...secrets.map((l) => `  warning: ${l}`),
+        ...knowledge.map((l) => `  ${l}`),
+      ].join('\n'),
+    }
+  },
+}