@frontera-sdk/cli 1.52.45 → 1.52.47

package/src/commands/agent/index-commands.ts

@@ -410,6 +410,47 @@ const discard: Command = {
   },
 }
 
+/**
+ * `frontera agent behavior clear <agent>`: take an Agent's behavior settings
+ * away on its draft (Forge improvement plan X4; P5 A15). An Agent whose live
+ * version has behavior settings serves customers, and the built-in Chat
+ * neither offers nor runs it; before, putting one back in Chat took a raw API
+ * call with a session token. Publishing the draft makes it take effect, which
+ * stays the person's step.
+ */
+const behavior: Command = {
+  meta: {
+    noun: 'agent',
+    verb: 'behavior',
+    args: [
+      { name: 'action', required: true, description: 'clear: take every behavior setting away on the draft' },
+      { name: 'agent', required: true, description: 'agent id or slug' },
+    ],
+    flags: {},
+    summary: 'Take an Agent\'s behavior settings away on its draft, so once published it serves the built-in Chat again',
+    details: [
+      'An Agent whose live version has behavior settings (procedures, guardrails, variables, session defaults or Analysis) serves customers: the built-in Chat neither offers nor runs it. `clear` stages none on the draft; `frontera agent publish <agent>` makes it take effect. In a project, deleting `agents/<slug>/operating.json` and proposing the Agent does the same.',
+    ],
+    examples: ['frontera agent behavior clear support-desk', 'frontera agent publish support-desk'],
+  },
+  async run(ctx) {
+    const action = ctx.positional[0]
+    if (action !== 'clear') throw new UsageError(action ? `\`agent behavior ${action}\` is not a command` : 'say what to do: clear', 'frontera agent behavior clear <agent>')
+    const ref = ctx.positional[1]
+    if (!ref) throw new UsageError('missing <agent>', 'frontera agent behavior clear <id-or-slug> — see `frontera agent list`')
+    const client = api(ctx)
+    const id = await resolveAgentRef(client, ref)
+    const view = await client.agentOperatingConfig(id).catch(() => null)
+    const had = view ? (view.draft ?? view.live) != null : null
+    if (had === false) return { data: { agent: ref, cleared: false, reason: 'no behavior settings' }, text: `${ref} has no behavior settings: it already serves the built-in Chat once published.` }
+    await client.stageAgentOperatingConfig(id, null)
+    return {
+      data: { agent: ref, cleared: true, staged: true },
+      text: [`Cleared ${ref}'s behavior settings on its draft.`, `  Publish it to take effect: \`frontera agent publish ${ref}\`. Once published, the built-in Chat offers it again.`].join('\n'),
+    }
+  },
+}
+
 const archive: Command = {
   meta: {
     noun: 'agent',
@@ -615,6 +656,7 @@ export const agentCommands: Command[] = [
   publish,
   diff,
   discard,
+  behavior,
   archive,
   restore,
   versions,

package/src/commands/app/deploy.ts

@@ -284,7 +284,7 @@ export const appDeploy: Command = {
     }
 
     const client = new AppsApi(ctx.apiUrl, ctx.token)
-    const app = await client.ensureApp(project.slug, project.displayName, project.appId)
+    const app = await client.ensureApp(project.slug, project.displayName, project.appId, { icon: project.icon })
 
     ctx.output.note(
       `  bundle ${distFiles.length} files, ${formatBytes(distFiles.reduce((n, f) => n + f.bytes.byteLength, 0))}`,

package/src/commands/app/dev.ts

@@ -109,7 +109,7 @@ export const appDev: Command = {
     }
     if (installed) ctx.output.note(`[dev] ${installed.summary}`)
     const apps = new AppsApi(ctx.apiUrl, ctx.token)
-    const app = await apps.ensureApp(project.slug, project.displayName, project.appId)
+    const app = await apps.ensureApp(project.slug, project.displayName, project.appId, { icon: project.icon })
     writeAppId(project.root, app.id)
     // The solution this App is in, if any: where status reads how this server's sessions fare.
     const solution = enclosingSolution(project.root)
@@ -132,7 +132,7 @@ export const appDev: Command = {
             appId,
             mint: (id) => apps.appToken(id),
             // Gone from the runtime (`local snapshot restore`): registered again by its slug, as `app dev` started.
-            reRegister: async () => (await apps.ensureApp(project.slug, project.displayName, null)).id,
+            reRegister: async () => (await apps.ensureApp(project.slug, project.displayName, null, { icon: project.icon })).id,
             onReRegistered: (id) => {
               if (id === appId) return
               ctx.output.note(`[dev] the runtime no longer had ${app.slug} (a restore of its database?): registered it again as ${id}; \`frontera app deploy\` puts its code back`)

package/src/commands/app/save.ts

@@ -21,7 +21,7 @@ export const appSave: Command = {
 
     // save and deploy are the only verbs that may bring an app into
     // existence; every read verb resolves instead.
-    const app = await client.ensureApp(project.slug, project.displayName, project.appId)
+    const app = await client.ensureApp(project.slug, project.displayName, project.appId, { icon: project.icon })
     const { tgz } = packDirectory(project.root, ctx.output, 'packaged')
     const res = await client.saveDraft(app.id, tgz, project.parentVersion)
 

package/src/commands/auth/add.ts

@@ -2,6 +2,7 @@ import { verifyKey } from '../../auth-verify'
 import { ensureMigrated } from '../../config'
 import { credentialStore } from '../../credential-store'
 import { CliError, UsageError } from '../../errors'
+import { keyReach, reachWords } from '../../key-reach'
 import { canPrompt, promptConfirm, promptSecret } from '../../prompt'
 import {
   assertApiUrl,
@@ -129,8 +130,11 @@ export const authAdd: Command = {
       replaced: Boolean(existing),
     }
 
+    // What the key can reach: an organization key acts only in the workspaces on its list (X3).
+    const reach = verified.kind === 'organization' ? await keyReach(apiUrl, token) : null
+    if (reach) Object.assign(data, { workspaces: reach })
     const scope = verified.kind === 'organization'
-      ? "it authors this organization's Blueprint"
+      ? `it authors this organization's Blueprint${reach ? `, and ${reachWords(reach)}` : ''}`
       : `workspace ${verified.workspaceId}`
 
     return {

package/src/commands/auth/current.ts

@@ -2,6 +2,7 @@ import { credentialStore } from '../../credential-store'
 import { describeSelection } from '../../config'
 import { CliError } from '../../errors'
 import { listProfiles } from '../../profiles'
+import { findContext } from '../../project-context'
 import { flagString, type Command } from '../types'
 
 /**
@@ -80,11 +81,16 @@ export const authCurrent: Command = {
       ? "organization Blueprint author"
       : `workspace ${metadata.workspaceId ?? 'unknown'}`
 
+    // The binding's organization profile, for organization-scoped commands here (X3).
+    const found = selection.source === 'directory' ? findContext(ctx.cwd) : null
+    const org = found?.organizationProfile ?? null
+    if (org) Object.assign(data, { organizationProfile: org })
     const lines = [
       `${selection.profile}${where}`,
       `  ${metadata.apiUrl} — ${scope}`,
       `  key ${data.hasSecret ? metadata.fingerprint : 'MISSING — run `frontera auth add ' + selection.profile + '`'}`,
     ]
+    if (org) lines.push(`  This project uses ${found!.profile} for workspace commands and ${org} for organization commands${found!.organizationTrusted ? '' : ' (not bound on this machine: run `frontera auth use` here again)'}`)
     if (envToken) {
       lines.push('  FRONTERA_TOKEN is set and takes precedence over this profile’s stored key')
     }

package/src/commands/auth/index-commands.ts

@@ -1,6 +1,7 @@
 import { authAdd } from './add'
 import { authCurrent } from './current'
 import { authList } from './list'
+import { authLogin, authLogout } from './login'
 import { authRemove } from './remove'
 import { authUse } from './use'
 import { authVerify } from './verify'
@@ -13,4 +14,6 @@ export const authCommands: readonly Command[] = [
   authUse,
   authVerify,
   authRemove,
+  authLogin,
+  authLogout,
 ]

package/src/commands/auth/login.ts

@@ -0,0 +1,84 @@
+import { describeSelection } from '../../config'
+import { credentialStore } from '../../credential-store'
+import { awaitDeviceSession, forgetDeviceSession, readDeviceSession, requestDeviceCode, saveDeviceSession, sessionEmail } from '../../device-login'
+import { CliError, UsageError } from '../../errors'
+import { flagBool, flagString, type Command, type CommandContext } from '../types'
+
+/**
+ * `frontera auth login --browser` and `frontera auth logout` (Forge
+ * improvement plan N5): a person's session for the commands that act as a
+ * person, approved in the browser. The profile's key stays what every other
+ * command uses; the session is kept beside it, used only by those commands,
+ * and lasts 12 hours. No token is ever printed, pasted or copied out of a
+ * browser.
+ */
+
+function openBrowser(url: string): void {
+  const command = process.platform === 'darwin' ? ['open', url] : process.platform === 'win32' ? ['cmd', '/c', 'start', '', url] : ['xdg-open', url]
+  try {
+    Bun.spawn(command, { stdout: 'ignore', stderr: 'ignore' }).unref()
+  } catch {
+    // Opening is convenience only; the address is always printed.
+  }
+}
+
+async function selected(ctx: CommandContext) {
+  const { selection, metadata } = await describeSelection({ profile: flagString(ctx, 'profile') }, { cwd: ctx.cwd })
+  if (!selection.profile || !metadata) {
+    throw new CliError('no Frontera profile is selected for this directory', { code: 'PROFILE_NOT_SELECTED', hint: 'pick one with `frontera auth use <profile>`, or name it with --profile' })
+  }
+  return { profile: selection.profile, apiUrl: metadata.apiUrl }
+}
+
+export const authLogin: Command = {
+  meta: {
+    noun: 'auth',
+    verb: 'login',
+    args: [],
+    flags: { browser: 'boolean', 'no-open': 'boolean' },
+    flagHelp: { 'no-open': 'print the approval address without opening a browser' },
+    summary: 'Sign in as yourself in the browser, for the commands that act as a person',
+    details: [
+      'Prints a code and opens the platform’s approval page; approve the code there while signed in. The CLI then keeps a session for the selected profile, beside its key, and uses it only for commands that act as a person (they refuse API keys). The session lasts 12 hours; `frontera auth logout` ends it sooner.',
+      'Approve only a code you started yourself, in your own terminal, just now.',
+    ],
+    examples: ['frontera auth login --browser', 'frontera auth login --browser --profile acme --no-open'],
+    offline: true,
+  },
+  async run(ctx) {
+    if (!flagBool(ctx, 'browser')) throw new UsageError('say how to sign in', 'frontera auth login --browser')
+    const { profile, apiUrl } = await selected(ctx)
+    const store = credentialStore()
+    const existing = await readDeviceSession(store, profile, apiUrl)
+    if (existing) {
+      return { data: { profile, signedIn: true, email: existing.email ?? null, expiresAt: existing.expiresAt, reused: true }, text: `Already signed in for ${profile}${existing.email ? ` as ${existing.email}` : ''}, until ${existing.expiresAt}. \`frontera auth logout\` ends it.` }
+    }
+    const code = await requestDeviceCode(apiUrl)
+    ctx.output.note(`To sign in, open ${code.verificationUri} and enter the code ${code.userCode}`)
+    if (!flagBool(ctx, 'no-open')) openBrowser(code.verificationUriComplete)
+    const session = await ctx.output.task('Waiting for you to approve it in the browser', () => awaitDeviceSession(apiUrl, code))
+    const email = await sessionEmail(apiUrl, session.token)
+    await saveDeviceSession(store, profile, { ...session, ...(email ? { email } : {}) })
+    return {
+      data: { profile, signedIn: true, email, expiresAt: session.expiresAt, reused: false },
+      text: `Signed in for ${profile}${email ? ` as ${email}` : ''} until ${session.expiresAt}. Commands that act as a person use this session; every other command keeps using the profile's key.`,
+    }
+  },
+}
+
+export const authLogout: Command = {
+  meta: {
+    noun: 'auth',
+    verb: 'logout',
+    args: [],
+    flags: {},
+    summary: 'End the browser sign-in for the selected profile; its key stays',
+    examples: ['frontera auth logout', 'frontera auth logout --profile acme'],
+    offline: true,
+  },
+  async run(ctx) {
+    const { profile } = await selected(ctx)
+    const forgotten = await forgetDeviceSession(credentialStore(), profile)
+    return { data: { profile, signedOut: forgotten }, text: forgotten ? `Signed out of ${profile}'s browser session; its key stays.` : `No browser session for ${profile}.` }
+  },
+}

package/src/commands/auth/use.ts

@@ -25,10 +25,15 @@ export const authUse: Command = {
     noun: 'auth',
     verb: 'use',
     args: [{ name: 'profile', required: true, description: 'profile to select for this directory tree' }],
-    flags: { dir: 'string' },
+    flags: { dir: 'string', 'org-profile': 'string' },
+    flagHelp: { 'org-profile': 'the organization profile organization-scoped commands use here (Blueprint authoring, governed Actions), beside a workspace profile on the same origin' },
     summary: 'Select a profile for this directory and everything under it',
+    details: [
+      '`--org-profile <name>` names the organization profile for organization-scoped commands beside a workspace profile: in this directory, workspace commands use the workspace key and organization commands the organization key, with no `--profile`. It is named, never guessed from the origin: two customers can share one host.',
+    ],
     examples: [
       'frontera auth use acme-prod',
+      'frontera auth use acme-prod --org-profile acme-org',
       'frontera auth use globex-dev --dir ~/Customers/globex',
     ],
     offline: true,
@@ -53,8 +58,20 @@ export const authUse: Command = {
       })
     }
 
+    // An organization profile for organization-scoped commands here (X3): an organization key on the same origin.
+    const orgProfile = flagString(ctx, 'org-profile')
+    let orgMetadata: ReturnType<typeof requireProfile> | null = null
+    if (orgProfile) {
+      assertProfileName(orgProfile)
+      orgMetadata = requireProfile(orgProfile)
+      if (metadata.credentialKind !== 'workspace') throw new UsageError(`${name} is an organization profile; --org-profile goes beside a workspace profile`, `frontera auth use <workspace profile> --org-profile ${orgProfile}`)
+      if (orgMetadata.credentialKind !== 'organization') throw new UsageError(`${orgProfile} holds a workspace key, not an organization key`, 'add the organization key as its own profile: `frontera auth add <name> --api-url <origin>` with an sk-org- key')
+      if (orgMetadata.apiUrl !== metadata.apiUrl) throw new UsageError(`${orgProfile} is for ${orgMetadata.apiUrl}, and ${name} for ${metadata.apiUrl}`, 'both profiles must reach the same deployment')
+      if ((await store.get(orgProfile)) === null) throw new CliError(`profile "${orgProfile}" has no stored key`, { code: 'PROFILE_SECRET_MISSING', hint: `re-add it with \`frontera auth add ${orgProfile} --api-url ${orgMetadata.apiUrl}\`` })
+    }
+
     const { root, source } = resolveBindingRoot(ctx.cwd, flagString(ctx, 'dir'))
-    const path = writeContext(root, name)
+    const path = writeContext(root, name, process.env, orgProfile)
     const gitignore = ensureGitignored(root)
 
     const scope = metadata.credentialKind === 'organization'
@@ -73,10 +90,12 @@ export const authUse: Command = {
         workspaceId: metadata.workspaceId,
         orgId: metadata.orgId,
         fingerprint: metadata.fingerprint,
+        ...(orgProfile ? { organizationProfile: orgProfile } : {}),
       },
       text: [
         `Selected ${name} for ${root}`,
         `  ${metadata.apiUrl} — ${scope}`,
+        ...(orgProfile ? [`  This project uses ${name} for workspace commands and ${orgProfile} for organization commands`] : []),
         `  wrote ${relative(root, path) || path}${gitignore === 'present' ? '' : `, ${gitignore} .gitignore entry`}`,
       ].join('\n'),
     }

package/src/commands/automation/bindings.ts

@@ -1,6 +1,7 @@
 /**
  * `frontera function bind|unbind|bindings` — the operator's half of making an
- * automation callable from a conversation.
+ * automation callable from a conversation, or startable from a Custom App
+ * (`--app`, X6).
  *
  * The author's half is in the manifest (`trigger: { agent: true }`, plus a
  * description of the automation and of every input) and is checked at deploy.
@@ -31,22 +32,37 @@ function requireAgent(ctx: CommandContext): string {
   const agent = flagString(ctx, 'agent')
   if (!agent) {
     throw new UsageError(
-      'missing --agent <agent-slug>',
-      'a binding names exactly one agent — there is no "all agents" form on purpose',
+      'missing --agent <agent-slug> or --app <app-slug>',
+      'a binding names exactly one agent or one Custom App — there is no "all" form on purpose',
     )
   }
   return agent
 }
 
+/**
+ * `--app <slug>`: the App lane (X6). A Custom App's code holds no secrets, so
+ * it starts a Function bound to it, as the person using it. One of `--agent`
+ * and `--app`, never both: they are different permissions.
+ */
+function appOf(ctx: CommandContext): string | null {
+  const app = flagString(ctx, 'app')
+  if (app === undefined) return null
+  if (flagString(ctx, 'agent') !== undefined) throw new UsageError('pass --agent or --app, not both', 'an Agent binding and an App binding are separate permissions: make each with its own command')
+  if (!/^[a-z0-9-]+$/.test(app)) throw new UsageError(`--app takes a Custom App's slug, got "${app}"`, '`frontera app list` shows each App’s slug')
+  return app
+}
+
 const bind: Command = {
   meta: {
     noun: 'function',
     verb: 'bind',
     args: [{ name: 'slug', required: true, description: 'automation slug' }],
-    flags: { agent: 'string', approval: 'string', wait: 'string' },
-    summary: 'Let one agent run this automation from a conversation',
+    flags: { agent: 'string', app: 'string', approval: 'string', wait: 'string', off: 'boolean' },
+    flagHelp: { app: 'a Custom App by its slug: the App may start the Function as the person using it', off: 'with --app: keep the binding, switched off' },
+    summary: 'Let one agent run this automation from a conversation, or one Custom App start it',
     examples: [
       'frontera function bind reconcile-invoices --agent finance-analyst',
+      'frontera function bind start-return --app returns-desk',
       'frontera function bind reconcile-invoices --agent analyst --approval auto',
       'frontera function bind reconcile-invoices --agent analyst --wait 120',
     ],
@@ -54,6 +70,15 @@ const bind: Command = {
 
   async run(ctx) {
     const slug = requireSlug(ctx)
+    const app = appOf(ctx)
+    if (app) {
+      if (flagString(ctx, 'approval') !== undefined || flagString(ctx, 'wait') !== undefined) throw new UsageError('--approval and --wait are an Agent binding’s', 'an App starts a Function when a person clicks, so there is no approval card or wait')
+      const result = await new AutomationApi(ctx.apiUrl, ctx.token, ctx.workspaceId).bindApp(slug, app, { enabled: ctx.flags.off !== true })
+      return {
+        data: result,
+        text: `${result.appDisplayName} (${result.appSlug}) may start ${slug}${result.enabled ? '' : ' — switched off'}.${result.inertReason === 'no_live_version' ? ` ${slug} has no live version yet, so the binding starts nothing until it is promoted.` : ''}\nIn a project, apps/${app}.json lists it after a pull; a change request carries that file.`,
+      }
+    }
     const agent = requireAgent(ctx)
 
     // `required` is the default at every layer, and it is spelled out here
@@ -96,13 +121,19 @@ const unbind: Command = {
     noun: 'function',
     verb: 'unbind',
     args: [{ name: 'slug', required: true, description: 'automation slug' }],
-    flags: { agent: 'string' },
-    summary: 'Stop one agent being able to run this automation',
-    examples: ['frontera function unbind reconcile-invoices --agent finance-analyst'],
+    flags: { agent: 'string', app: 'string' },
+    flagHelp: { app: 'a Custom App by its slug: it may no longer start the Function' },
+    summary: 'Stop one agent being able to run this automation, or one Custom App starting it',
+    examples: ['frontera function unbind reconcile-invoices --agent finance-analyst', 'frontera function unbind start-return --app returns-desk'],
   },
 
   async run(ctx) {
     const slug = requireSlug(ctx)
+    const app = appOf(ctx)
+    if (app) {
+      await new AutomationApi(ctx.apiUrl, ctx.token, ctx.workspaceId).unbindApp(slug, app)
+      return { data: { unbound: true }, text: `${app} can no longer start ${slug}.` }
+    }
     const agent = requireAgent(ctx)
     await new AutomationApi(ctx.apiUrl, ctx.token, ctx.workspaceId).unbind(slug, agent)
     return { data: { unbound: true }, text: `${agent} can no longer run ${slug}.` }
@@ -126,10 +157,12 @@ const bindings: Command = {
         description: 'automation slug — omit it and pass --agent to ask from the agent side',
       },
     ],
-    flags: { agent: 'string' },
-    summary: 'List the agents that may run an automation, or what one agent may run',
+    flags: { agent: 'string', apps: 'boolean' },
+    flagHelp: { apps: 'the Custom Apps that may start it, instead of the agents' },
+    summary: 'List the agents (or Custom Apps) that may run an automation, or what one agent may run',
     examples: [
       'frontera function bindings reconcile-invoices',
+      'frontera function bindings start-return --apps',
       'frontera function bindings --agent finance-analyst',
     ],
   },
@@ -139,6 +172,17 @@ const bindings: Command = {
     const agent = flagString(ctx, 'agent')
     const slug = ctx.positional[0]
 
+    if (ctx.flags.apps === true) {
+      if (!slug) throw new UsageError('--apps lists one Function’s Apps: pass its slug', 'frontera function bindings <slug> --apps')
+      const rows = await client.appBindings(slug)
+      return {
+        data: rows,
+        text: rows.length === 0
+          ? `No Custom App can start ${slug}.`
+          : table(['app', 'name', 'enabled', 'starts it now', 'bound by'], rows.map((b) => [b.appSlug, b.appDisplayName, String(b.enabled), b.projects === false ? `no (${b.inertReason === 'no_live_version' ? 'nothing live' : 'switched off'})` : 'yes', b.createdBy])),
+      }
+    }
+
     if (!slug && !agent) {
       throw new UsageError(
         'pass an automation slug, or --agent <agent-slug>',

package/src/commands/automation/index-commands.ts

@@ -6,8 +6,7 @@ import { validateManifest } from '@frontera-sdk/functions'
 
 import { AutomationApi } from '../../api/automation-api'
 import { UsageError } from '../../errors'
-import { outsideImports } from '../../function-outside-imports'
-import { packDirectory } from '../../pack'
+import { packFunctionSource } from '../../pack'
 import { automationInit } from './init'
 import { automationPull } from './pull'
 import { automationRun, automationRuns } from './run'
@@ -120,7 +119,7 @@ const deploy: Command = {
     let source: Uint8Array | undefined
     if (projectRoot) {
       // With the files it imports from outside its folder, so a pull brings a Function that builds.
-      source = packDirectory(projectRoot, ctx.output, 'source', outsideImports(projectRoot, resolve(file))).tgz
+      source = packFunctionSource(projectRoot, resolve(file), ctx.output, 'source').tgz
     } else {
       // Degrade honestly rather than refuse. Authoring inside this monorepo is
       // still supported and simply cannot retain source — there is no

package/src/commands/blueprint/bind.ts

@@ -61,6 +61,17 @@ async function datasetRevision(client: BlueprintAuthoringApi, name: string) {
   return current
 }
 
+/**
+ * The object type file's `backing` once bound: the dataset and the mapping,
+ * merged into what the file says, never in place of it, so `editable` and the
+ * rest stay (Forge improvement plan X11; a rebind lost the editable fields,
+ * P5 A4).
+ */
+export function boundBacking(before: unknown, dataset: string, mapping: Record<string, unknown>): Record<string, unknown> {
+  const kept = before && typeof before === 'object' && !Array.isArray(before) ? (before as Record<string, unknown>) : {}
+  return { ...kept, dataset, mapping }
+}
+
 export const blueprintBind: Command = {
   meta: {
     noun: 'blueprint',
@@ -213,7 +224,7 @@ export const blueprintBind: Command = {
         }
         writeTree(treeRoot, [{
           ...file,
-          document: { ...file.document, backing: { dataset: datasetName, mapping: written } },
+          document: { ...file.document, backing: boundBacking(file.document.backing, datasetName, written) },
         }])
         treeUpdated = true
       }

package/src/commands/blueprint/declarative.ts

@@ -24,6 +24,7 @@ import {
 import { metricRuleProblems } from '../../blueprint/metric-rules'
 import { actionRuleProblems, type ActionRuleProblems, type InheritedConflict } from '../../blueprint/action-rules'
 import { pickCurrentRevision } from '../../blueprint/dataset-revision'
+import { nameCheckWords, orgNameCheck } from '../../blueprint/org-name-check'
 import {
   assertPrunesLeaveNoDanglingReference,
   diff,
@@ -1693,9 +1694,12 @@ export const blueprintNew: Command = {
       document: scaffold(kind, apiName, options),
     }
     writeTree(directory, [file])
+    // In a project linked to a workspace: is the name already the organization's, outside the slice (X11)?
+    const check = await orgNameCheck(ctx.cwd, kind, apiName)
+    const warning = nameCheckWords(kind, apiName, check)
     return {
-      data: { path: relative },
-      text: `Wrote ${relative}. Edit it, then \`frontera blueprint plan\`.`,
+      data: { path: relative, organizationName: check },
+      text: [`Wrote ${relative}. Edit it, then \`frontera blueprint plan\`.`, ...(warning ? [warning] : [])].join('\n'),
     }
   },
 }

package/src/commands/conversation/index-commands.ts

@@ -0,0 +1,66 @@
+import { UsageError } from '../../errors'
+import { conversationTranscript, searchConversations, type TranscriptTurn } from '../../mcp/mcp-conversations'
+import { flagBool, flagString, type Command } from '../types'
+import { projectRuntime } from './local-runtime'
+
+/**
+ * `frontera conversation get|search`: the project's local runtime's
+ * conversations, read whole (Forge improvement plan N7), the same reads as
+ * the MCP tools `conversation_get` and `conversation_search`.
+ */
+
+function turnLines(turns: TranscriptTurn[]): string[] {
+  return turns.flatMap((t) => [
+    `Turn ${t.turn}${t.procedure?.name ? ` · procedure ${t.procedure.name}` : ''}`,
+    ...(t.user ? [`  Person: ${t.user}`] : []),
+    ...t.toolCalls.map((c) => `  Tool: ${c.name}${c.ok ? '' : c.waiting ? ' (waiting on a person)' : ' (no result)'}`),
+    `  Agent: ${t.reply || '(no reply)'}`,
+    ...(t.replyChecks?.length ? [`  Reply check changed this reply (${t.replyChecks.length})`] : []),
+    '',
+  ])
+}
+
+export const conversationGet: Command = {
+  meta: {
+    noun: 'conversation',
+    verb: 'get',
+    args: [{ name: 'conversation', required: true, description: 'The conversation id (a test case’s, or one `conversation search` found)' }],
+    flags: { 'no-traces': 'boolean' },
+    flagHelp: { 'no-traces': 'leave out what each turn’s trace says (its procedure and the reply check)' },
+    summary: 'Read one conversation on the project’s local runtime: every turn, tool call, procedure and reply check',
+    examples: ['frontera conversation get 6f1c…', 'frontera conversation get 6f1c… --json'],
+    offline: true,
+  },
+  async run(ctx) {
+    const id = ctx.positional[0]
+    if (!id) throw new UsageError('missing <conversation>', '`frontera conversation search` lists them')
+    const link = projectRuntime(ctx.cwd)
+    const transcript = await conversationTranscript(link, id, { traces: !flagBool(ctx, 'no-traces') })
+    if (!transcript) throw new UsageError(`no conversation ${id} on the local runtime`, '`frontera conversation search` lists them')
+    return { data: transcript, text: [`Conversation ${id}: ${transcript.turns.length} turn${transcript.turns.length === 1 ? '' : 's'}`, '', ...turnLines(transcript.turns)].join('\n').trimEnd() }
+  },
+}
+
+export const conversationSearch: Command = {
+  meta: {
+    noun: 'conversation',
+    verb: 'search',
+    args: [{ name: 'query', required: false, description: 'Words the conversation contains' }],
+    flags: { agent: 'string', tests: 'boolean', limit: 'string' },
+    flagHelp: { agent: 'only this Agent’s conversations (its slug)', tests: 'only conversations test runs started', limit: 'at most this many (default 20)' },
+    summary: 'Find conversations on the project’s local runtime, newest first',
+    examples: ['frontera conversation search "refund"', 'frontera conversation search --agent sdr --tests'],
+    offline: true,
+  },
+  async run(ctx) {
+    const link = projectRuntime(ctx.cwd)
+    const limit = Number(flagString(ctx, 'limit') ?? 20)
+    const hits = await searchConversations(link, { query: ctx.positional[0], agent: flagString(ctx, 'agent'), tests: flagBool(ctx, 'tests'), limit: Number.isFinite(limit) ? limit : 20 })
+    return {
+      data: { conversations: hits },
+      text: hits.length ? hits.map((h) => `${h.conversationId}  ${h.updatedAt ?? ''}  ${h.agent ?? ''}  ${h.title ?? ''}`.trimEnd()).join('\n') : 'No conversations match.',
+    }
+  },
+}
+
+export const conversationCommands: readonly Command[] = [conversationGet, conversationSearch]

package/src/commands/conversation/local-runtime.ts

@@ -0,0 +1,18 @@
+import { CliError } from '../../errors'
+import { localProject } from '../../local/local-project'
+import { runtimeLink, type RuntimeLink } from '../../mcp/mcp-runtime'
+
+/**
+ * The local runtime `frontera conversation` and `frontera trace` read (Forge
+ * improvement plan N7): the one of the project this folder is in. Reading a
+ * workspace's conversations, which are customer data, from a coding agent is
+ * an open question the plan leaves to its owner, so these commands never
+ * reach a workspace.
+ */
+export function projectRuntime(cwd: string): RuntimeLink {
+  const link = runtimeLink(localProject(cwd))
+  if (typeof link === 'string') {
+    throw new CliError(link, { code: 'LOCAL_NOT_RUNNING', hint: 'run it in the project folder with its local runtime started (`frontera local start`); a workspace’s conversations are read in the product, not from here' })
+  }
+  return link
+}