@frontera-sdk/cli 1.53.10 → 1.53.12

package/src/commands/local/sync-request.ts

@@ -13,9 +13,9 @@ import { mcpServersNotCarried } from '../../local/local-mcp-servers'
 import { localProject, type LocalProject } from '../../local/local-project'
 import { HISTORY_KINDS, projectAtRevision } from '../../local/local-sync-base'
 import { normalizeOrigin, unwrap } from '../../local/local-sync-client'
-import { getSyncKey, readLink, registerTargetProfile, setModelMapping, targetOf, targetProfileName, targetSession, type SyncLink } from '../../local/local-sync-link'
+import { getSyncKey, readLink, registerTargetProfile, setModelMapping, targetLabel, targetOf, targetProfileName, targetSession, targetWords, type SyncLink, type SyncTarget } from '../../local/local-sync-link'
 import { itemTitle } from '../../local/local-sync-names'
-import { checkBody, markMissingModels, markRefused, needsAPerson, planOf, type ApplyStep, type WorkspaceModel } from '../../local/local-sync-precheck'
+import { checkBody, markMissingModels, markRefused, movedOnTarget, needsAPerson, planOf, type ApplyStep, type WorkspaceModel } from '../../local/local-sync-precheck'
 import { afterApplyOf, recordAfterApply } from '../../local/local-person-steps'
 import { rows } from '../../local/local-sync-remote'
 import { evalsDetail, evalsLine, lastRender, sessionScreenshots, standInInstalls } from '../../local/local-request-evidence'
@@ -54,7 +54,7 @@ import { directoryOf, readSnapshot, snapshotItems } from '../../local/local-sync
 import { buildAndExtract } from '../automation/build-entry'
 import { findAutomationProjectRoot } from '../automation/project-root'
 import { flagBool, flagString, type CommandContext } from '../types'
-import { fetchFor, planFor, sourceFor } from './sync'
+import { chooseTarget, fetchTarget, planFor, sourceFor, targetPlan } from './sync'
 
 /**
  * `frontera local sync push` and `frontera local sync request`: change
@@ -94,13 +94,16 @@ type RequestBody = NonNullable<RequestInit['body']>
 
 /**
  * Who a command's change-request calls act as: the person signed in for the
- * target, or else the project's keys. One for the whole command: a person
+ * target, or else the target's keys. One for the whole command: a person
  * sends no key with their session, so a Blueprint change applied by a person
- * is that person's alone.
+ * is that person's alone. `target` and `profile` say where: the named target
+ * (null for the project's link) and its profile, so every step a hint prints
+ * names the same target.
  */
-type Acting =
-  | { as: 'person'; profile: string; token: string; email: string | null; organizationKeyStored: boolean }
-  | { as: 'keys'; profile: string; workspaceKey: string; organizationKey: string | null }
+type Acting = { target: string | null; profile: string } & (
+  | { as: 'person'; token: string; email: string | null; organizationKeyStored: boolean }
+  | { as: 'keys'; workspaceKey: string; organizationKey: string | null }
+)
 
 interface Platform {
   acting: Acting
@@ -163,37 +166,45 @@ async function answerAs<T>(res: Response, acting: Acting): Promise<T> {
   if (checks.length) throw new CliError(message, { code: 'SYNC_CHECKS', hint: 'fix the items the checks name, then push again', details: { checks } })
   const details = (parsed?.details ?? null) as { code?: string; gate?: Gate } | null
   if (details?.code === 'GATE_FAILED' && details.gate) {
-    throw new CliError(message, { code: 'SYNC_APPLY_GATED', hint: 'make the checks pass (`frontera local sync request evidence` attaches evals and renders), or a workspace admin applies with `--force --reason "<why>"`', details: { gate: details.gate } })
+    throw new CliError(message, { code: 'SYNC_APPLY_GATED', hint: `make the checks pass (\`${syncCommand(acting, 'request evidence')}\` attaches evals and renders), or a workspace admin applies with \`--force --reason "<why>"\``, details: { gate: details.gate } })
   }
   if (res.status === 401 && acting.as === 'person') throw new CliError(`the platform no longer takes the browser sign-in for ${acting.profile}`, { code: 'UNAUTHORIZED', hint: `sign in again with \`${signInCommand(acting.profile)}\`` })
-  if (res.status === 401) throw new CliError('the platform refused the key', { code: 'UNAUTHORIZED', hint: 'check it is a current workspace key (sk-ws-…) for this platform; `frontera local sync connect` stores a new one' })
+  if (res.status === 401) throw new CliError('the platform refused the key', { code: 'UNAUTHORIZED', hint: `check it is a current workspace key (sk-ws-…) for this platform; \`${syncCommand(acting, 'connect')}\` stores a new one` })
   if (res.status === 403) throw new CliError(message, { code: 'FORBIDDEN', hint: acting.as === 'keys' ? 'the key’s role decides what it may propose and apply; ask a workspace admin' : 'your role decides what you may propose and apply; ask a workspace admin' })
-  if (res.status === 404) throw new CliError(message, { code: 'NOT_FOUND', hint: 'the change request is gone from the workspace; propose again with `frontera local sync push`' })
-  if (res.status === 409) throw new CliError(message, { code: 'CONFLICT', hint: 'see where it stands with `frontera local sync request`' })
-  if (res.status === 400 || res.status === 422) throw new CliError(message, { code: 'VALIDATION_ERROR', hint: 'see where it stands with `frontera local sync request`' })
+  if (res.status === 404) throw new CliError(message, { code: 'NOT_FOUND', hint: `the change request is gone from the workspace; propose again with \`${syncCommand(acting, 'push')}\`` })
+  if (res.status === 409) throw new CliError(message, { code: 'CONFLICT', hint: `see where it stands with \`${syncCommand(acting, 'request')}\`` })
+  if (res.status === 400 || res.status === 422) throw new CliError(message, { code: 'VALIDATION_ERROR', hint: `see where it stands with \`${syncCommand(acting, 'request')}\`` })
   throw new CliError(`the platform answered ${res.status}: ${message}`, { code: 'UNAVAILABLE', hint: 'check the platform is reachable, then run the command again' })
 }
 
-/** The person signed in for the target when they are a member of the linked workspace, else the project's keys. */
-async function platformFor(project: LocalProject, link: SyncLink): Promise<Platform> {
-  const person = await targetSession(project, link)
-  if (!person) return keysFor(project, link)
-  const profile = targetProfileName(project, link)
-  const api = platform(link, { as: 'person', profile, token: person.token, email: person.email ?? null, organizationKeyStored: !!getSyncKey(project, 'organization') })
+/** The person signed in for the target when they are a member of its workspace, else the target's own keys: never another target's. */
+async function platformFor(target: Pick<SyncTarget, 'name' | 'owner' | 'link'>): Promise<Platform> {
+  const { link } = target
+  const person = await targetSession(target.owner, link)
+  if (!person) return keysFor(target)
+  const profile = targetProfileName(target.owner, link)
+  const api = platform(link, { as: 'person', target: target.name, profile, token: person.token, email: person.email ?? null, organizationKeyStored: !!getSyncKey(target.owner, 'organization') })
   // The platform drops the workspace from a session that isn't a member's, and every change-request call then fails.
   const me = await api.call<{ workspaceId?: string | null }>('GET', '/v1/whoami')
   if (me.workspaceId?.toLowerCase() !== link.workspace.toLowerCase()) {
-    throw new CliError(`signed in as ${person.email ?? 'someone'} for ${profile}, who is not a member of ${link.workspaceName ?? link.workspace}`, { code: 'SYNC_NOT_A_MEMBER', hint: `sign out with \`frontera auth logout --profile ${profile}\` and sign in as a member (\`${signInCommand(profile)}\`), or ask a workspace admin to add you` })
+    throw new CliError(`signed in as ${person.email ?? 'someone'} for ${profile}, who is not a member of ${targetLabel(target)}`, { code: 'SYNC_NOT_A_MEMBER', hint: `sign out with \`frontera auth logout --profile ${profile}\` and sign in as a member (\`${signInCommand(profile)}\`), or ask a workspace admin to add you` })
   }
   return api
 }
 
-function keysFor(project: LocalProject, link: SyncLink): Platform {
-  const workspaceKey = getSyncKey(project, 'workspace')
-  if (!workspaceKey) throw new CliError('no workspace key for this project on this machine', { code: 'SYNC_NO_KEY', hint: 'run `frontera local sync connect` to store one (keys are per machine)' })
-  return platform(link, { as: 'keys', profile: targetProfileName(project, link), workspaceKey, organizationKey: getSyncKey(project, 'organization') })
+/** The change-request routes of a target's platform with that target's own keys. */
+function keysFor(target: Pick<SyncTarget, 'name' | 'owner' | 'link'>): Platform {
+  const workspaceKey = getSyncKey(target.owner, 'workspace')
+  if (!workspaceKey) throw new CliError(`no workspace key for ${target.name ? `target ${target.name}` : 'this project'} on this machine`, { code: 'SYNC_NO_KEY', hint: `run \`${targetWords(target, 'frontera local sync connect')}\` to store one (keys are per machine)` })
+  return platform(target.link, { as: 'keys', target: target.name, profile: targetProfileName(target.owner, target.link), workspaceKey, organizationKey: getSyncKey(target.owner, 'organization') })
 }
 
+/** A `frontera local sync` command for where `acting` acts: `--target <name>` follows it for a named target. */
+const syncCommand = (acting: Pick<Acting, 'target'>, words: string) => targetWords({ name: acting.target }, `frontera local sync ${words}`)
+
+/** How a hint names whose keys and workspace `acting` uses: the link's words (`link`), or the named target. */
+const ownerWords = (acting: Pick<Acting, 'target'>, link: string) => (acting.target ? `target ${acting.target}` : link)
+
 /**
  * A request takes pushes, evidence, close and Apply from the one who proposed
  * it (a workspace admin aside), so a request is another's when `acting` did
@@ -212,14 +223,14 @@ function proposedByOther(acting: Acting, view: View): 'key' | 'person' | null {
 function notProposer(acting: Acting, view: View, doing: 'apply' | 'push to' | 'close' | 'attach evidence to'): CliError | null {
   const by = proposedByOther(acting, view)
   const title = view.request.title
-  if (by === 'person') return new CliError(`“${title}” was proposed by a person signed in for this project’s workspace, and no one is signed in on this computer now`, { code: 'SYNC_NOT_SIGNED_IN', hint: `sign in again with \`${signInCommand(acting.profile)}\`, then run the command again` })
+  if (by === 'person') return new CliError(`“${title}” was proposed by a person signed in for ${ownerWords(acting, 'this project')}’s workspace, and no one is signed in on this computer now`, { code: 'SYNC_NOT_SIGNED_IN', hint: `sign in again with \`${signInCommand(acting.profile)}\`, then run the command again` })
   if (by !== 'key' || acting.as !== 'person') return null
-  const closeIt = 'close it (`frontera local sync request close` closes it with that key)'
+  const closeIt = `close it (\`${syncCommand(acting, 'request close')}\` closes it with that key)`
   const withKeys = doing === 'apply' && (acting.organizationKeyStored || !view.items.some((i) => i.kind === 'blueprint'))
-  return new CliError(`“${title}” was proposed with this project’s workspace key before you signed in, so it isn’t yours to ${doing}`, {
+  return new CliError(`“${title}” was proposed with ${ownerWords(acting, 'this project')}’s workspace key before you signed in, so it isn’t yours to ${doing}`, {
     code: 'SYNC_PROPOSED_WITH_KEY',
     hint: doing === 'apply'
-      ? `${closeIt}, then push the changes again as yourself (\`${pushAgain(view)}\`) and apply${withKeys ? `; or sign out (\`frontera auth logout --profile ${acting.profile}\`) to apply it with the project’s keys` : ''}`
+      ? `${closeIt}, then push the changes again as yourself (\`${pushAgain(acting, view)}\`) and apply${withKeys ? `; or sign out (\`frontera auth logout --profile ${acting.profile}\`) to apply it with ${ownerWords(acting, 'the project')}’s keys` : ''}`
       : `${closeIt}, then push again to propose the changes as yourself`,
   })
 }
@@ -227,16 +238,16 @@ function notProposer(acting: Acting, view: View, doing: 'apply' | 'push to' | 'c
 /** Who proposed the change request a step is for: nobody yet, the person signed in, or the project's workspace key. */
 type ProposedBy = 'nobody' | 'you' | 'key'
 
-/** The push that proposes these refs and App releases (`--release`'s value), with the title. */
-function pushCommand(title: string | null, refs: string[], releases?: string): string {
-  return ['frontera local sync push', ...refs, ...(releases ? [`--release ${releases}`] : []), `-t "${title ?? '<title>'}"`].join(' ')
+/** The push that proposes these refs and App releases (`--release`'s value), with the title, where `acting` acts. */
+function pushCommand(acting: Pick<Acting, 'target'>, title: string | null, refs: string[], releases?: string): string {
+  return syncCommand(acting, ['push', ...refs, ...(releases ? [`--release ${releases}`] : []), `-t "${title ?? '<title>'}"`].join(' '))
 }
 
 /** The push that proposes a request's items again: a Custom App's release by `--release`, anything else by its ref. */
-function pushAgain(view: View): string {
+function pushAgain(acting: Pick<Acting, 'target'>, view: View): string {
   const release = (i: ViewItem) => (i.kind === 'app' ? releasedDeployment(i) : null)
   const refs = view.items.filter((i) => !release(i) || Object.keys(i.files).length > 1).map((i) => i.ref)
-  return pushCommand(view.request.title, refs, view.items.flatMap((i) => (release(i) ? [`${i.name}=${release(i)}`] : [])).join(','))
+  return pushCommand(acting, view.request.title, refs, view.items.flatMap((i) => (release(i) ? [`${i.name}=${release(i)}`] : [])).join(','))
 }
 
 /**
@@ -247,16 +258,16 @@ function pushAgain(view: View): string {
  */
 function withStoredKey(acting: Extract<Acting, { as: 'person' }>, push: string, proposed: ProposedBy): string {
   const signOut = `sign out (\`frontera auth logout --profile ${acting.profile}\`)`
-  const apply = 'apply (`frontera local sync request apply`)'
+  const apply = `apply (\`${syncCommand(acting, 'request apply')}\`)`
   if (proposed === 'key') return `${signOut}, then ${apply}`
   const pushIt = `push${proposed === 'you' ? ' it again' : ''} (\`${push}\`) and ${apply}`
-  return proposed === 'you' ? `close it (\`frontera local sync request close\`), ${signOut}, then ${pushIt}` : `${signOut}, then ${pushIt}`
+  return proposed === 'you' ? `close it (\`${syncCommand(acting, 'request close')}\`), ${signOut}, then ${pushIt}` : `${signOut}, then ${pushIt}`
 }
 
 /** A refusal of the person's role, with the way to act with the organization key stored instead. */
 function orStoredKey(err: unknown, acting: Acting, push: string, proposed: ProposedBy): unknown {
   if (!(err instanceof CliError) || err.code !== 'FORBIDDEN' || acting.as !== 'person' || !acting.organizationKeyStored) return err
-  return new CliError(err.message, { code: err.code, hint: `your role decides what you may propose and apply. To use the organization key stored for this project instead, ${withStoredKey(acting, push, proposed)}; or ask a workspace admin` })
+  return new CliError(err.message, { code: err.code, hint: `your role decides what you may propose and apply. To use the organization key stored for ${ownerWords(acting, 'this project')} instead, ${withStoredKey(acting, push, proposed)}; or ask a workspace admin` })
 }
 
 /**
@@ -279,8 +290,8 @@ function notSteward(acting: Acting, unmet: boolean, push: string, proposed: Prop
   return new CliError(`you are signed in as ${acting.email ?? 'someone'}, who is not a Blueprint Steward, so the Blueprint changes and grants in this change request could not be applied as you`, {
     code: 'SYNC_NOT_A_STEWARD',
     hint: proposed === 'key'
-      ? `${withStoredKey(acting, push, proposed)}: the project’s keys proposed it, and Apply uses the organization key stored for this project`
-      : `${withStoredKey(acting, push, proposed)}: the project’s keys propose it, and Apply uses the organization key stored for this project; or ask a Blueprint Steward to sign in for this project and push it`,
+      ? `${withStoredKey(acting, push, proposed)}: ${ownerWords(acting, 'the project')}’s keys proposed it, and Apply uses the organization key stored for ${ownerWords(acting, 'this project')}`
+      : `${withStoredKey(acting, push, proposed)}: ${ownerWords(acting, 'the project')}’s keys propose it, and Apply uses the organization key stored for ${ownerWords(acting, 'this project')}; or ask a Blueprint Steward to sign in for ${ownerWords(acting, 'this project')} and push it`,
   })
 }
 
@@ -306,11 +317,11 @@ function stewardData(acting: Acting, blueprint: boolean, stored: boolean) {
  * push.
  */
 function stewardNote(acting: Acting, proposed: boolean, push: string): string {
-  if (acting.as === 'person') return `Blueprint changes are applied as you (${acting.email ?? 'signed in'})${acting.organizationKeyStored ? `; the organization key stored for this project is not used while you’re signed in: to apply ${proposed ? 'this change request ' : ''}with it instead, ${withStoredKey(acting, push, proposed ? 'you' : 'nobody')}` : ''}.`
-  if (acting.organizationKey) return 'Blueprint changes are applied with the organization key stored for this project.'
+  if (acting.as === 'person') return `Blueprint changes are applied as you (${acting.email ?? 'signed in'})${acting.organizationKeyStored ? `; the organization key stored for ${ownerWords(acting, 'this project')} is not used while you’re signed in: to apply ${proposed ? 'this change request ' : ''}with it instead, ${withStoredKey(acting, push, proposed ? 'you' : 'nobody')}` : ''}.`
+  if (acting.organizationKey) return `Blueprint changes are applied with the organization key stored for ${ownerWords(acting, 'this project')}.`
   const signIn = `\`${signInCommand(acting.profile)}\``
   return proposed
-    ? `Blueprint changes are applied by a Blueprint Steward, signed in, and this change request was proposed with the project’s workspace key: to apply it as yourself, sign in (${signIn}), close it (\`frontera local sync request close\`) and push again.`
+    ? `Blueprint changes are applied by a Blueprint Steward, signed in, and this change request was proposed with ${ownerWords(acting, 'the project')}’s workspace key: to apply it as yourself, sign in (${signIn}), close it (\`${syncCommand(acting, 'request close')}\`) and push again.`
     : `Blueprint changes are applied by a Blueprint Steward, signed in: sign in before you push, so the change request is yours to apply (${signIn}).`
 }
 
@@ -589,17 +600,17 @@ async function deletionUsers(api: Platform, items: PushItem[]): Promise<Map<stri
  * with its reason and fix. A platform without the check leaves them to
  * Propose: `checked` says which.
  */
-async function precheck(api: Platform, items: PushItem[], organizationKey: string | null): Promise<{ checked: boolean; refused: string[]; plan: ApplyStep[]; problem?: string }> {
+async function precheck(api: Platform, items: PushItem[], organizationKey: string | null, target: SyncTarget): Promise<{ checked: boolean; refused: string[]; plan: ApplyStep[]; problem?: string }> {
   const body = checkBody(items)
   if (!body.length) return { checked: true, refused: [], plan: [] }
   try {
     // The organization key stored for the project, so the plan says whether it can make a Steward's steps.
     const answer = await api.call<{ checks?: unknown[]; plan?: unknown }>('POST', '/v1/change-requests/check', { items: body, ...(organizationKey ? { organizationKey } : {}) }, { organizationKey, timeoutMs: 120_000 })
-    return { checked: true, refused: markRefused(items, checksOf(answer)), plan: planOf(answer) }
+    return { checked: true, refused: markRefused(items, checksOf(answer), target), plan: planOf(answer) }
   } catch (err) {
     if (err instanceof CliError && (err.code === 'NOT_FOUND' || err.code === 'SYNC_CHECKS')) {
       // An older platform has no check; a refusal of the check itself names the items as the push would.
-      if (err.code === 'SYNC_CHECKS') return { checked: true, refused: markRefused(items, checksOf(err.details)), plan: [] }
+      if (err.code === 'SYNC_CHECKS') return { checked: true, refused: markRefused(items, checksOf(err.details), target), plan: [] }
       return { checked: false, refused: [], plan: [] }
     }
     return { checked: false, refused: [], plan: [], problem: (err as Error).message.split('\n')[0] }
@@ -616,11 +627,25 @@ async function workspaceModels(api: Platform): Promise<WorkspaceModel[]> {
   }
 }
 
-function previewText(link: SyncLink, items: PushItem[], kept: { title: string } | null, orgNote: string | null, available: boolean, usedBy: Map<string, string[]> = new Map(), person: ReturnType<typeof needsAPerson> = [], notCarried: string | null = null): string {
+/**
+ * What a named target changed since this project last delivered it, and the
+ * project did not: not proposed, so the target keeps its version, with the
+ * command that puts the project's back over it.
+ */
+function changedThereLines(target: SyncTarget, changed: Array<{ ref: string; kind: SyncKind; title: string }>): string[] {
+  if (!changed.length) return []
+  return [
+    '',
+    `Changed in ${targetLabel(target)} since this project last delivered it, so not proposed:`,
+    ...changed.map((i) => `  ${KIND_WORD[i.kind]} ${i.title}: to put the project’s version back over it, \`${targetWords(target, `frontera local sync resolve ${i.ref} --keep mine`)}\``),
+  ]
+}
+
+function previewText(target: SyncTarget, items: PushItem[], kept: { title: string } | null, orgNote: string | null, available: boolean, usedBy: Map<string, string[]> = new Map(), person: ReturnType<typeof needsAPerson> = [], notCarried: string | null = null, changedThere: Array<{ ref: string; kind: SyncKind; title: string }> = []): string {
   const ok = items.filter((i) => i.proposable && !i.sample)
   const samples = items.filter((i) => i.proposable && i.sample)
   const not = items.filter((i) => !i.proposable)
-  const name = link.workspaceName ?? link.workspace
+  const name = targetLabel(target)
   const lines = [
     ok.length
       ? `Would propose ${plural(ok.length, 'item')} to ${name}${kept ? `, updating “${kept.title}”` : ''}:`
@@ -630,6 +655,7 @@ function previewText(link: SyncLink, items: PushItem[], kept: { title: string }
   ]
   if (samples.length) lines.push('', 'Samples from setting up the project, left out unless named:', ...samples.map((i) => `  [ ] ${KIND_WORD[i.kind]} ${i.title}`))
   if (not.length) lines.push('', 'Not proposed:', ...not.flatMap((i) => [`  [ ] ${KIND_WORD[i.kind]} ${i.title}: ${i.reason}`, ...(i.fix ? [`      Fix: ${i.fix}`] : [])]))
+  lines.push(...changedThereLines(target, changedThere))
   const before = person.filter((p) => !p.after)
   const after = person.filter((p) => p.after)
   if (before.length) lines.push('', 'Needs a person before Apply:', ...before.flatMap((p) => [`  - ${p.step}: ${p.message}`, `      Fix: ${p.fix}`]))
@@ -637,7 +663,7 @@ function previewText(link: SyncLink, items: PushItem[], kept: { title: string }
   if (orgNote) lines.push('', orgNote)
   if (notCarried) lines.push('', notCarried)
   if (!available) lines.push('', 'This platform does not take change requests yet.')
-  if (ok.length && available) lines.push('', 'Propose with `frontera local sync push -t "<title>"`, or name items to propose only those.')
+  if (ok.length && available) lines.push('', `Propose with \`${targetWords(target, 'frontera local sync push -t "<title>"')}\`, or name items to propose only those.`)
   return lines.join('\n')
 }
 
@@ -685,7 +711,7 @@ export async function syncMapModel(ctx: CommandContext): Promise<{ data: unknown
     return { data: { local, workspace: null }, text: `${local} is no longer mapped: an item that names it isn’t proposed until it is mapped again.` }
   }
   if (!workspace) throw new UsageError('name the workspace model it goes as', `frontera local sync map-model ${local} <workspace model>; \`push --preview\` lists ${name}’s models`)
-  const offered = await workspaceModels(await platformFor(project, link))
+  const offered = await workspaceModels(await platformFor({ name: null, owner: project, link }))
   if (offered.length && !offered.some((m) => m.slug === workspace)) {
     throw new UsageError(`${name} has no chat model ${workspace}`, `choose one of: ${offered.map((m) => m.slug).slice(0, 12).join(', ')}${offered.length > 12 ? ', …' : ''}`)
   }
@@ -696,11 +722,14 @@ export async function syncMapModel(ctx: CommandContext): Promise<{ data: unknown
 
 export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; text: string }> {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
+  const target = chooseTarget(project, ctx)
+  const { link } = target
   const named = ctx.positional.slice(1)
   const preview = flagBool(ctx, 'preview')
+  const command = (words: string) => targetWords(target, `frontera local sync ${words}`)
   // Fetch first, as git does before a push: an item the workspace moved past is pulled and merged first.
-  const { plan, lock, snapshot, remote } = await planFor(project, link, { fetch: 'always', repair: 'online' })
+  // A named target is never pulled from: it is compared with what this project last delivered to it (`targetPlan`).
+  const { plan, lock, snapshot, remote, delivered } = target.name ? await targetPlan(project, target) : { ...(await planFor(project, link, { fetch: 'always', repair: 'online' })), delivered: null }
   if (!plan || !snapshot) throw new CliError('could not fetch the workspace', { code: 'SYNC_NOT_FETCHED', hint: 'run `frontera local sync fetch` and look at what it says' })
   const available = snapshot.capabilities.includes('change-requests')
   // Knowledge bases whose documents come too: opt-in, as for a pull (`*` for every one the project has).
@@ -709,19 +738,36 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
   const documentNames = asked.includes('*') ? knowledgeHere : asked
   const notHere = documentNames.filter((n) => !knowledgeHere.includes(n))
   if (notHere.length) throw new UsageError(`no knowledge base ${notHere.join(', ')} in this project`, '--documents takes knowledge base names (knowledge/<name>), or * for every one')
-  const api = await platformFor(project, link)
+  const api = await platformFor(target)
   const documents = documentNames.length
-    ? { names: new Set(documentNames), pulled: readPulledDocuments(project.root, link.workspace).bases, platform: await platformDocuments(api, documentNames, remote.items) }
+    ? { names: new Set(documentNames), pulled: readPulledDocuments(target.state, link.workspace).bases, platform: await platformDocuments(api, documentNames, remote.items) }
     : undefined
   const all = pushCandidates({ root: project.root, plan, lock, snapshot, remote: remote.items, named, ...(documents ? { documents } : {}) })
+  // A named target is never pulled from: what it changed since this project delivered it has its own words.
+  const changedThere = target.name ? plan.filter((p) => p.status === 'changed').map((p) => ({ ref: p.ref, kind: p.kind, title: p.title })) : []
+  if (target.name) {
+    const bothChanged = new Set(plan.filter((p) => p.status === 'conflict').map((p) => p.ref))
+    for (const i of all) {
+      // With no delivery to compare with, a change made on the target can't be told from one it hasn't had yet.
+      if (i.proposable && i.change !== 'new' && !delivered?.has(i.ref)) i.notes.push(`No delivery of it from this project is recorded on this computer: proposed over what ${targetLabel(target)} holds now, so a change made there is replaced`)
+      if (i.blocked === 'workspace-deleted') {
+        i.reason = `Deleted in ${targetLabel(target)} since this project last delivered it`
+        i.fix = `to deliver it again, \`${command(`resolve ${i.ref} --keep mine`)}\``
+        continue
+      }
+      if (i.blocked !== 'moved' || !bothChanged.has(i.ref)) continue
+      i.reason = `Changed in ${targetLabel(target)} too since this project last delivered it`
+      i.fix = `see what changed there with \`${command(`diff ${i.ref}`)}\`, then keep the project’s version with \`${command(`resolve ${i.ref} --keep mine`)}\`, or carry that change into the files here first`
+    }
+  }
   // Before anything is sent: models only this computer has, then the workspace's own checks.
   const known = snapshot.names?.model ? new Set(Object.keys(snapshot.names.model)) : null
   const missing = known ? markMissingModels(all, known) : new Map<string, string[]>()
-  const checked = available ? await precheck(api, all, organizationKeyOf(api.acting)) : { checked: false, refused: [] as string[], plan: [] as ApplyStep[] }
+  const checked = available ? await precheck(api, all, organizationKeyOf(api.acting), target) : { checked: false, refused: [] as string[], plan: [] as ApplyStep[] }
   const person = needsAPerson(checked.plan)
-  const kept = currentRequest(readRequests(project.root, link.workspace))
+  const kept = currentRequest(readRequests(target.state, link.workspace))
   const updating = kept && isOpen(kept.state) ? kept : null
-  const orgStored = !!getSyncKey(project, 'organization')
+  const orgStored = !!getSyncKey(target.owner, 'organization')
   const titles = Object.fromEntries(all.map((i) => [i.ref, i.title]))
   const mcp = mcpServersNotCarried(project.root)
   const notCarried = mcp ? { mcpServers: mcp.files, save: mcp.command } : null
@@ -732,34 +778,35 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
     const unknown = named.filter((r) => !byRef.has(r))
     const servers = unknown.filter((r) => r.startsWith('mcp-server'))
     if (mcp && servers.length) throw new UsageError(`a change request does not carry ${servers.join(', ')}`, mcp.line)
-    if (unknown.length) throw new UsageError(`nothing to propose in ${unknown.join(', ')}: ${unknown.length === 1 ? 'it matches' : 'they match'} the workspace, or the project has no such item`, 'list what can be proposed with `frontera local sync push --preview`')
+    if (unknown.length) throw new UsageError(`nothing to propose in ${unknown.join(', ')}: ${unknown.length === 1 ? 'it matches' : 'they match'} the workspace, or the project has no such item`, `list what can be proposed with \`${command('push --preview')}\``)
     chosen = named.map((r) => byRef.get(r)!)
   } else chosen = all
   // Samples from setting up the project go only when named.
   const leftSamples = named.length ? [] : chosen.filter((i) => i.proposable && i.sample)
   const title = flagString(ctx, 'title')?.trim()
   // The current request still taking pushes is updated; one applied or closed (here or on the platform) is not.
-  let target = updating
+  let open = updating
   let stop: CliError | null = null
-  if (target) {
-    const live = await api.call<View>('GET', `/v1/change-requests/${target.id}`).catch((err: CliError) => (err.code === 'NOT_FOUND' ? null : Promise.reject(err)))
+  if (open) {
+    const live = await api.call<View>('GET', `/v1/change-requests/${open.id}`).catch((err: CliError) => (err.code === 'NOT_FOUND' ? null : Promise.reject(err)))
     if (!live || !isOpen(live.request.state)) {
-      if (live) recordRequest(project.root, link.workspace, live)
-      target = null
+      if (live) recordRequest(target.state, link.workspace, live)
+      open = null
     } else stop = notProposer(api.acting, live, 'push to')
   }
   // Following a refusal proposes what was asked: the items named (none: every change) and the releases.
-  const again = pushCommand(target?.title ?? title ?? null, named, flagString(ctx, 'release'))
-  stop ??= notSteward(api.acting, stewardStepUnmet(person, chosen), again, target ? 'you' : 'nobody')
-  const orgNote = needsOrganizationKey(chosen) ? stewardNote(api.acting, false, pushCommand(title ?? null, named, flagString(ctx, 'release'))) : null
+  const again = pushCommand(api.acting, open?.title ?? title ?? null, named, flagString(ctx, 'release'))
+  stop ??= notSteward(api.acting, stewardStepUnmet(person, chosen), again, open ? 'you' : 'nobody')
+  const orgNote = needsOrganizationKey(chosen) ? stewardNote(api.acting, false, pushCommand(api.acting, title ?? null, named, flagString(ctx, 'release'))) : null
 
   if (preview) {
     const usedBy = available ? await deletionUsers(api, chosen) : new Map<string, string[]>()
     return {
       data: {
         link,
+        target: target.name,
         available,
-        request: target ? { id: target.id, title: target.title, state: target.state, items: target.refs.length, refs: target.refs } : null,
+        request: open ? { id: open.id, title: open.title, state: open.state, items: open.refs.length, refs: open.refs } : null,
         items: chosen.map((i) => ({ ...itemJson(i), ...(usedBy.has(i.ref) ? { usedBy: usedBy.get(i.ref) } : {}) })),
         counts: { proposable: chosen.filter((i) => i.proposable && !i.sample).length, samples: leftSamples.length, blocked: chosen.filter((i) => !i.proposable).length },
         // A push now would be refused before anything is sent: why, and the way out.
@@ -777,20 +824,25 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
         applyPlan: checked.plan,
         needsPerson: person,
         notCarried,
+        ...(target.name ? { changedThere: changedThere.map((i) => i.ref) } : {}),
         fetchedAt: snapshot.fetchedAt,
       },
-      text: previewText(link, chosen, target, stop ? `A push now would be refused: ${stop.message}; ${stop.hint}.` : orgNote, available, usedBy, person, mcp?.line),
+      text: previewText(target, chosen, open, stop ? `A push now would be refused: ${stop.message}; ${stop.hint}.` : orgNote, available, usedBy, person, mcp?.line, changedThere),
     }
   }
 
-  if (!available) throw new CliError(`${link.workspaceName ?? 'this workspace'}’s platform does not take change requests yet`, { code: 'SYNC_NO_CHANGE_REQUESTS', hint: 'make the change on the platform, or ask your administrator to update it' })
+  if (!available) throw new CliError(`${targetLabel(target)}’s platform does not take change requests yet`, { code: 'SYNC_NO_CHANGE_REQUESTS', hint: 'make the change on the platform, or ask your administrator to update it' })
   // Named items must each be proposable; with none named, an item the workspace moved past stops the push.
   const stopping = chosen.filter((i) => !i.proposable && (named.length > 0 || i.blocked === 'moved' || i.blocked === 'conflicts'))
   if (stopping.length) {
     const lines = stopping.map((i) => `  ${KIND_WORD[i.kind]} ${i.title}: ${i.reason}`)
     throw new CliError(`not proposed: ${plural(stopping.length, 'item')} cannot go yet\n${lines.join('\n')}`, {
       code: 'SYNC_PUSH_BLOCKED',
-      hint: stopping.some((i) => i.blocked === 'moved' || i.blocked === 'conflicts') ? 'pull and merge them first (`frontera local sync pull <ref>`), or name the items to propose' : 'name only items that can be proposed; `--preview` lists them',
+      hint: target.name && stopping.some((i) => i.blocked === 'moved')
+        ? `see what changed there with \`${command('diff <ref>')}\`, then keep the project’s version with \`${command('resolve <ref> --keep mine')}\`, or name only the items to propose`
+        : target.name && stopping.some((i) => i.blocked === 'conflicts')
+          ? 'resolve the conflicts from the link’s pull first (`frontera local sync resolve <ref>`), or name only the items to propose'
+          : stopping.some((i) => i.blocked === 'moved' || i.blocked === 'conflicts') ? 'pull and merge them first (`frontera local sync pull <ref>`), or name the items to propose' : `name only items that can be proposed; \`${command('push --preview')}\` lists them`,
       details: { blocked: stopping.map((i) => ({ ref: i.ref, code: i.blocked, message: i.reason })) },
     })
   }
@@ -802,10 +854,16 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
     if (held.length) {
       throw new CliError(`nothing to propose: ${plural(held.length, 'change')} here cannot go yet\n${held.flatMap((i) => [`  ${KIND_WORD[i.kind]} ${i.title}: ${i.reason}`, ...(i.fix ? [`      Fix: ${i.fix}`] : [])]).join('\n')}`, {
         code: 'SYNC_PUSH_BLOCKED',
-        hint: `fix ${held.length === 1 ? 'it' : 'them'} as said, then check with \`frontera local sync push --preview\``,
+        hint: `fix ${held.length === 1 ? 'it' : 'them'} as said, then check with \`${command('push --preview')}\``,
         details: { blocked: held.map((i) => ({ ref: i.ref, code: i.blocked, message: i.reason, ...(i.fix ? { fix: i.fix } : {}) })) },
       })
     }
+    if (target.name) {
+      throw new CliError([`nothing to propose to ${targetLabel(target)}: nothing here differs from what it holds${changedThere.length ? ', other than what changed there' : ''}`, ...changedThereLines(target, changedThere)].join('\n'), {
+        code: 'SYNC_NOTHING_TO_PUSH',
+        hint: changedThere.length ? `to put the project’s version back over a change made there, \`${command('resolve <ref> --keep mine')}\`` : `change an item in the project first; \`${command('push --preview')}\` lists what would go`,
+      })
+    }
     throw new CliError(`nothing to propose: nothing ${mcp ? 'a change request carries ' : ''}changed here since the last pull`, {
       code: 'SYNC_NOTHING_TO_PUSH',
       hint: `${mcp ? `${mcp.line} For anything else, ` : ''}change an item in the project first; \`frontera local sync status\` shows where it stands`,
@@ -813,40 +871,45 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
   }
   const description = flagString(ctx, 'description')
   if (stop) throw stop
-  if (!target && !title) throw new UsageError('give the change request a title', 'frontera local sync push -t "Tighten the refund procedure"')
+  if (!open && !title) throw new UsageError('give the change request a title', command('push -t "Tighten the refund procedure"'))
 
   // Custom App releases: each names a deployment that already exists. A later push keeps the releases the request has.
   const releases = await releaseItems(api, releaseAsks)
-  const keptReleases = target ? (await api.call<View>('GET', `/v1/change-requests/${target.id}`)).items.filter((i) => i.kind === 'app' && !releases.some((r) => r.ref === i.ref) && releasedDeployment(i)).map((i) => releaseItem(i.name, releasedDeployment(i)!)) : []
+  const keptReleases = open ? (await api.call<View>('GET', `/v1/change-requests/${open.id}`)).items.filter((i) => i.kind === 'app' && !releases.some((r) => r.ref === i.ref) && releasedDeployment(i)).map((i) => releaseItem(i.name, releasedDeployment(i)!)) : []
   // An App's settings pushed now and its release go as one item (X6).
   const items = mergeAppItems([...(await pushBody(going, functionBuilder(project, ctx), assetUploader(project, api))), ...releases.map(({ ref, files }) => ({ ref, files })), ...keptReleases])
   let view: View
   try {
-    view = target
-      ? await api.call<View>('PUT', `/v1/change-requests/${target.id}`, { ...(title ? { title } : {}), ...(description !== undefined ? { description: description || null } : {}), items, replace: true }, { timeoutMs: 120_000 })
+    view = open
+      ? await api.call<View>('PUT', `/v1/change-requests/${open.id}`, { ...(title ? { title } : {}), ...(description !== undefined ? { description: description || null } : {}), items, replace: true }, { timeoutMs: 120_000 })
       : await api.call<View>('POST', '/v1/change-requests', { title, ...(description ? { description } : {}), items }, { timeoutMs: 120_000 })
   } catch (err) {
     if (err instanceof CliError && err.code === 'SYNC_CHECKS') {
       const checks = checksOf(err.details)
-      throw new CliError(`not proposed: the workspace refused ${plural(checks.length, 'check')}\n${checkLines(checks, titles).join('\n')}`, {
+      const moved = checks.map((c) => movedOnTarget(c, target))
+      const there = moved.find((m) => m !== null)
+      throw new CliError(`not proposed: the workspace refused ${plural(checks.length, 'check')}\n${checkLines(checks.map((c, n) => ({ ...c, message: moved[n]?.reason ?? c.message })), titles).join('\n')}`, {
         code: 'SYNC_PUSH_REFUSED',
-        hint: checks.some((c) => c.code === 'stale_base' || c.code === 'exists' || c.code === 'gone') ? 'fetch and pull the items named, merge them, then push again' : 'fix the items named, then push again',
+        hint: there
+          ? `${there.fix}, then push again`
+          : checks.some((c) => c.code === 'stale_base' || c.code === 'exists' || c.code === 'gone') ? 'fetch and pull the items named, merge them, then push again' : 'fix the items named, then push again',
         details: { checks },
       })
     }
-    throw orStoredKey(err, api.acting, again, target ? 'you' : 'nobody')
+    throw orStoredKey(err, api.acting, again, open ? 'you' : 'nobody')
   }
   // A knowledge base's documents follow the request, one at a time (each up to the platform's limit).
   const staged = await stageDocuments(project, api, view)
   if (staged) view = await api.call<View>('GET', `/v1/change-requests/${view.request.id}`)
   const allTitles = { ...(kept?.titles ?? {}), ...titles }
-  recordRequest(project.root, link.workspace, view, { titles: allTitles, pushed: true })
-  writeRequestBase(project.root, view.request.id, going)
+  recordRequest(target.state, link.workspace, view, { titles: allTitles, pushed: true })
+  writeRequestBase(target.state, view.request.id, going)
   const notProposed = chosen.filter((i) => !i.proposable)
   return {
     data: {
       proposed: true,
-      created: !target,
+      target: target.name,
+      created: !open,
       request: { id: view.request.id, title: view.request.title, state: view.request.state, items: view.items.length, refs: view.items.map((i) => i.ref) },
       pushed: [...going.map((i) => i.ref), ...releases.map((r) => r.ref)],
       releases: releases.map((r) => ({ ref: r.ref, deployment: r.deployment })),
@@ -856,15 +919,16 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
       notCarried,
     },
     text: [
-      `${target ? `Updated “${view.request.title}” in` : `Proposed “${view.request.title}” to`} ${link.workspaceName ?? link.workspace}: ${plural(view.items.length, 'item')}.`,
+      `${open ? `Updated “${view.request.title}” in` : `Proposed “${view.request.title}” to`} ${targetLabel(target)}: ${plural(view.items.length, 'item')}.`,
       ...going.map((i) => `  ${pushItemLine(i)}`),
       ...releases.map((r) => `  Custom App ${r.slug}: release ${r.deployment}${r.chosen ? ' (its newest deployment)' : ''}; Apply promotes it last`),
       ...(notProposed.length ? ['', 'Not proposed:', ...notProposed.flatMap((i) => [`  ${KIND_WORD[i.kind]} ${i.title}: ${i.reason}`, ...(i.fix ? [`    Fix: ${i.fix}`] : [])])] : []),
+      ...changedThereLines(target, changedThere),
       ...(leftSamples.length ? ['', `Left out: ${plural(leftSamples.length, 'sample')} from setting up the project (${leftSamples.map((i) => i.title).join(', ')}); name ${leftSamples.length === 1 ? 'it' : 'them'} to propose`] : []),
-      ...(needsOrganizationKey(view.items) ? ['', stewardNote(api.acting, true, pushAgain(view))] : []),
+      ...(needsOrganizationKey(view.items) ? ['', stewardNote(api.acting, true, pushAgain(api.acting, view))] : []),
       ...(mcp ? ['', mcp.line] : []),
       '',
-      'Apply it with `frontera local sync request apply`; see it with `frontera local sync request`.',
+      `Apply it with \`${command('request apply')}\`; see it with \`${command('request')}\`.`,
     ].join('\n'),
   }
 }
@@ -872,10 +936,11 @@ export async function syncPush(ctx: CommandContext): Promise<{ data: unknown; te
 // ── request ─────────────────────────────────────────────────────────────────
 
 /** The base each item was changed from: the copy kept at push, the fetched snapshot, or the platform at that revision. */
-async function basesFor(project: LocalProject, link: SyncLink, view: View): Promise<Record<string, { files: Record<string, string>; known: boolean }>> {
-  const kept = readRequestBase(project.root, view.request.id)
-  const snapshot = readSnapshot(project.root)
-  const remote = snapshot && snapshot.workspace === link.workspace ? new Map(snapshotItems(project.root, snapshot).map((i) => [i.ref, i])) : new Map()
+async function basesFor(target: SyncTarget, view: View): Promise<Record<string, { files: Record<string, string>; known: boolean }>> {
+  const { link } = target
+  const kept = readRequestBase(target.state, view.request.id)
+  const snapshot = readSnapshot(target.state)
+  const remote = snapshot && snapshot.workspace === link.workspace ? new Map(snapshotItems(target.state, snapshot).map((i) => [i.ref, i])) : new Map()
   const out: Record<string, { files: Record<string, string>; known: boolean }> = {}
   for (const item of view.items) {
     if (!item.baseRevision) {
@@ -902,7 +967,7 @@ async function basesFor(project: LocalProject, link: SyncLink, view: View): Prom
     // Earlier versions the platform keeps: workflows, Functions and the Blueprint by revision.
     if (item.kind === 'agent' || !HISTORY_KINDS.includes(item.kind) || !snapshot?.capabilities.includes('item-revision')) continue
     try {
-      const source = await sourceFor(project, link)
+      const source = await sourceFor(target.owner, link, target.name)
       const asked = item.kind === 'blueprint' ? 'blueprint' : item.ref
       const answer = await source.workspace.find<{ ref: string; kind: string; revision: string; content: Record<string, unknown> }>(`/v1/sync/item?ref=${encodeURIComponent(asked)}&revision=${encodeURIComponent(item.baseRevision)}`)
       if (answer) {
@@ -992,12 +1057,12 @@ function activityOf(view: View, titles: Record<string, string>) {
     })
 }
 
-async function currentView(project: LocalProject, link: SyncLink): Promise<{ view: View; titles: Record<string, string>; api: Platform } | null> {
-  const kept = currentRequest(readRequests(project.root, link.workspace))
+async function currentView(target: SyncTarget): Promise<{ view: View; titles: Record<string, string>; api: Platform } | null> {
+  const kept = currentRequest(readRequests(target.state, target.link.workspace))
   if (!kept) return null
-  const api = await platformFor(project, link)
+  const api = await platformFor(target)
   const view = await api.call<View>('GET', `/v1/change-requests/${kept.id}`)
-  recordRequest(project.root, link.workspace, view)
+  recordRequest(target.state, target.link.workspace, view)
   return { view, titles: kept.titles, api }
 }
 
@@ -1014,13 +1079,15 @@ function titleOf(item: ViewItem, titles: Record<string, string>): string {
 
 async function show(ctx: CommandContext) {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
-  const current = await currentView(project, link)
+  const target = chooseTarget(project, ctx)
+  const { link } = target
+  const command = (words: string) => targetWords(target, `frontera local sync ${words}`)
+  const current = await currentView(target)
   if (!current) {
-    return { data: { request: null }, text: 'No change request yet. Propose what changed here with `frontera local sync push -t "<title>"`.' }
+    return { data: { request: null, target: target.name }, text: `No change request yet. Propose what changed here with \`${command('push -t "<title>"')}\`.` }
   }
   const { view, titles } = current
-  const bases = await basesFor(project, link, view)
+  const bases = await basesFor(target, view)
   const checks = lastChecks(view)
   const items = view.items.map((item) => {
     const base = bases[item.ref]!
@@ -1059,12 +1126,13 @@ async function show(ctx: CommandContext) {
   })
   const allTitles = Object.fromEntries(items.map((i) => [i.ref, i.title]))
   const activity = activityOf(view, allTitles)
-  const orgStored = !!getSyncKey(project, 'organization')
+  const orgStored = !!getSyncKey(target.owner, 'organization')
   const r = view.request
   const { acting } = current.api
   const other = isOpen(r.state) ? proposedByOther(acting, view) : null
   return {
     data: {
+      target: target.name,
       request: { id: r.id, title: r.title, description: r.description, state: r.state, stateLabel: STATE_WORD[r.state] ?? r.state, createdAt: r.createdAt, updatedAt: r.updatedAt, mergedAt: r.mergedAt },
       workspace: { name: link.workspaceName ?? null, organizationName: link.organizationName ?? null },
       items,
@@ -1075,7 +1143,7 @@ async function show(ctx: CommandContext) {
       evidence: view.evidence ?? [],
     },
     text: [
-      `${r.title} — ${STATE_WORD[r.state] ?? r.state} · ${plural(items.length, 'item')} · ${link.workspaceName ?? link.workspace}`,
+      `${r.title} — ${STATE_WORD[r.state] ?? r.state} · ${plural(items.length, 'item')} · ${targetLabel(target)}`,
       ...(r.description ? [r.description] : []),
       '',
       ...items.flatMap((i, n) => [
@@ -1090,29 +1158,31 @@ async function show(ctx: CommandContext) {
       '',
       'Activity:',
       ...activity.map((a) => `  ${a.at.slice(0, 16).replace('T', ' ')}  ${a.text}`),
-      ...(isOpen(r.state) && !other && needsOrganizationKey(view.items) ? ['', stewardNote(acting, true, pushAgain(view))] : []),
-      ...(other === 'key' ? ['', 'Proposed with the project’s workspace key before you signed in: close it (`frontera local sync request close`) and push again to apply it as yourself.'] : []),
+      ...(isOpen(r.state) && !other && needsOrganizationKey(view.items) ? ['', stewardNote(acting, true, pushAgain(acting, view))] : []),
+      ...(other === 'key' ? ['', `Proposed with ${ownerWords(acting, 'the project')}’s workspace key before you signed in: close it (\`${command('request close')}\`) and push again to apply it as yourself.`] : []),
       ...(other === 'person' ? ['', `Proposed by a person signed in, and no one is signed in on this computer now: sign in again with \`${signInCommand(acting.profile)}\` to apply it.`] : []),
-      ...(isOpen(r.state) && !other ? ['', 'Apply it with `frontera local sync request apply`, or close it with `request close`.'] : []),
+      ...(isOpen(r.state) && !other ? ['', `Apply it with \`${command('request apply')}\`, or close it with \`${targetWords(target, 'request close')}\`.`] : []),
     ].join('\n'),
   }
 }
 
 async function apply(ctx: CommandContext) {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
-  const current = await currentView(project, link)
-  if (!current) throw new UsageError('no change request to apply', 'propose one with `frontera local sync push -t "<title>"`')
+  const target = chooseTarget(project, ctx)
+  const { link } = target
+  const command = (words: string) => targetWords(target, `frontera local sync ${words}`)
+  const current = await currentView(target)
+  if (!current) throw new UsageError(`no change request to apply${target.name ? ` to target ${target.name}` : ''}`, `propose one with \`${command('push -t "<title>"')}\``)
   const { view, titles, api } = current
   const { acting } = api
-  if (view.request.state === 'merged') throw new CliError(`“${view.request.title}” is already applied`, { code: 'CONFLICT', hint: 'propose new changes with `frontera local sync push -t "<title>"`' })
-  if (view.request.state === 'closed') throw new CliError(`“${view.request.title}” is closed`, { code: 'CONFLICT', hint: 'propose the changes again with `frontera local sync push -t "<title>"`' })
+  if (view.request.state === 'merged') throw new CliError(`“${view.request.title}” is already applied`, { code: 'CONFLICT', hint: `propose new changes with \`${command('push -t "<title>"')}\`` })
+  if (view.request.state === 'closed') throw new CliError(`“${view.request.title}” is closed`, { code: 'CONFLICT', hint: `propose the changes again with \`${command('push -t "<title>"')}\`` })
   const proposed: ProposedBy = proposedByOther(acting, view) === 'key' ? 'key' : 'you'
   if (acting.as === 'person' && acting.organizationKeyStored && view.items.some((i) => i.kind === 'blueprint' || i.kind === 'agent')) {
     // The platform refuses a person who is no Steward only once Apply runs, so ask its checks, with every item so references resolve.
     const items = view.items.map((i) => ({ ref: i.ref, files: i.files, ...(i.baseRevision ? { baseRevision: i.baseRevision } : {}), ...(i.deleted ? { deleted: true } : {}) }))
     const plan = await api.call<unknown>('POST', '/v1/change-requests/check', { items }, { timeoutMs: 120_000 }).then(planOf, () => [])
-    const stop = notSteward(acting, stewardStepUnmet(needsAPerson(plan), view.items), pushAgain(view), proposed)
+    const stop = notSteward(acting, stewardStepUnmet(needsAPerson(plan), view.items), pushAgain(acting, view), proposed)
     if (stop) throw stop
   }
   const refused = notProposer(acting, view, 'apply')
@@ -1123,7 +1193,7 @@ async function apply(ctx: CommandContext) {
   // With the keys, sent whenever one is stored: an Agent's Blueprint grants are a Steward's too, in a request without Blueprint files (P5 A5).
   const organizationKey = organizationKeyOf(acting)
   if (blueprint && acting.as === 'keys' && !organizationKey) {
-    throw new CliError('this change request changes the Blueprint, which a Blueprint Steward applies as themself, and no one is signed in for this project’s workspace on this computer', { code: 'SYNC_NOT_SIGNED_IN', hint: `sign in with \`${signInCommand(acting.profile)}\`, then close this change request (\`frontera local sync request close\`) and push it again, so it is yours to apply` })
+    throw new CliError(`this change request changes the Blueprint, which a Blueprint Steward applies as themself, and no one is signed in for ${ownerWords(acting, 'this project')}’s workspace on this computer`, { code: 'SYNC_NOT_SIGNED_IN', hint: `sign in with \`${signInCommand(acting.profile)}\`, then close this change request (\`${command('request close')}\`) and push it again, so it is yours to apply` })
   }
   const migration = flagString(ctx, 'migration')?.trim()
   const force = flagBool(ctx, 'force')
@@ -1149,22 +1219,22 @@ async function apply(ctx: CommandContext) {
       })
     }
     if (refused && err instanceof CliError && err.code === 'FORBIDDEN') throw refused
-    throw orStoredKey(err, acting, pushAgain(view), proposed)
+    throw orStoredKey(err, acting, pushAgain(acting, view), proposed)
   }
   const outcome = parseOutcome(answer.outcome)
-  recordRequest(project.root, link.workspace, answer, { applied: { ok: outcome.ok } })
+  recordRequest(target.state, link.workspace, answer, { applied: { ok: outcome.ok } })
   if (!outcome.ok) {
     // Fetch, so the project sees the workspace as it was put back. The request itself applies again as it is:
     // the platform takes each put-back item's new revision as its base.
-    await fetchFor(project, link).catch(() => null)
+    await fetchTarget(project, target).catch(() => null)
     // When the checks could not be read before sending, the Steward refusal comes back as the failed step.
     const stewardFailed = /Blueprint Steward assignment required/.test(outcome.failure?.message ?? '')
-    const steward = notSteward(acting, stewardFailed, pushAgain(view), proposed)
+    const steward = notSteward(acting, stewardFailed, pushAgain(acting, view), proposed)
     // With no organization key stored, applying again fails the same way.
-    const noKey = stewardFailed ? 'ask a Blueprint Steward who is a workspace admin to approve it and apply it; or store the project’s organization key (`frontera local sync connect --workspace-key - --org-key -`), then apply again (`frontera local sync request apply`) and follow the steps it prints' : null
+    const noKey = stewardFailed ? `ask a Blueprint Steward who is a workspace admin to approve it and apply it; or store ${ownerWords(acting, 'the project')}’s organization key (\`${command('connect --workspace-key - --org-key -')}\`), then apply again (\`${command('request apply')}\`) and follow the steps it prints` : null
     throw new CliError(describeOutcome(outcome, allTitles).join('\n'), {
       code: 'SYNC_APPLY_FAILED',
-      hint: steward?.hint ?? noKey ?? (/migration instruction/i.test(outcome.failure?.message ?? '') ? 'say what to do with existing records: apply again with `--migration "<instructions>"`' : 'once what failed is fixed, apply again (`frontera local sync request apply`); a fix in the project’s files is pushed first (`frontera local sync push`)'),
+      hint: steward?.hint ?? noKey ?? (/migration instruction/i.test(outcome.failure?.message ?? '') ? 'say what to do with existing records: apply again with `--migration "<instructions>"`' : `once what failed is fixed, apply again (\`${command('request apply')}\`); a fix in the project’s files is pushed first (\`${command('push')}\`)`),
       details: { outcome, failed: outcome.failure ? { ref: outcome.failure.ref, title: failedName(outcome, allTitles), message: outcome.failure.message } : null },
     })
   }
@@ -1173,40 +1243,45 @@ async function apply(ctx: CommandContext) {
   try {
     // A deletion shows only in a full read of the workspace's index (an incremental one lists no deletions).
     const deleted = answer.items.filter((i) => i.deleted).map((i) => i.ref)
-    const result = await fetchFor(project, link, { full: deleted.length > 0 })
+    const result = await fetchTarget(project, target, { full: deleted.length > 0 })
     // A Custom App release moved a pointer; the App's own sync item (its description) is not the project's to adopt.
     const adoptable = answer.items.filter((i) => i.kind !== 'app').map((i) => i.ref)
-    const { adopted } = adoptApplied(project.root, link.workspace, adoptable, snapshotItems(project.root, result.snapshot), readLock(project.root), new Date(), { deleted })
+    // A named target's base is its own (`target.state`), so the next push to it reads what changed there since.
+    const { adopted } = adoptApplied(target.state, link.workspace, adoptable, snapshotItems(target.state, result.snapshot), readLock(target.state), new Date(), { deleted })
     // An Agent's lessons were proposed for review: not proposed again; the next pull brings what reviewers approve.
-    adoptProposedLessons(project.root, link.workspace, answer.items.flatMap((i) => (i.ref.startsWith('lessons/') ? [i.ref.slice('lessons/'.length)] : [])))
+    if (!target.name) adoptProposedLessons(project.root, link.workspace, answer.items.flatMap((i) => (i.ref.startsWith('lessons/') ? [i.ref.slice('lessons/'.length)] : [])))
     fetched = { changed: result.changed.length, adopted, error: null }
   } catch (err) {
     fetched.error = (err as Error).message
   }
   // Documents applied are the project's copies of the workspace's now: recorded as a pull records them.
-  await recordAppliedDocuments(project, link, api, answer).catch(() => null)
+  await recordAppliedDocuments(target, api, answer).catch(() => null)
   // The Agents applied: their cases' last local runs become the baseline the next request's evals compare with.
   recordApplied(project, answer.items.filter((i) => i.kind === 'agent' && !i.deleted).map((i) => i.name))
   // What the request left for a person: kept as the delivery's person-steps, which Forge shows as Pending in workspace (N6).
   const after = afterApplyOf(answer.outcome)
   // The steps change the workspace the request went to, so they name it: the folder is bound to its local runtime.
-  const { target, targetError } = after.length
-    ? await registerTargetProfile(project, link).then((name) => ({ target: name, targetError: null }), (err: Error) => ({ target: null, targetError: err.message }))
-    : { target: null, targetError: null }
-  const pending = recordAfterApply(project.root, answer.request.title, after, target ? { profile: target, target: targetOf(link) } : null)
-  const signIn = target && pending.length ? await signInStep({ profile: target, apiUrl: link.platform, named: true }) : null
+  const { profile, profileError } = after.length
+    ? await registerTargetProfile(target.owner, link).then((name) => ({ profile: name, profileError: null }), (err: Error) => ({ profile: null, profileError: err.message }))
+    : { profile: null, profileError: null }
+  // A named target's steps are a delivery of their own: the same request title applied to the link keeps its steps.
+  const delivery = target.name ? `${answer.request.title} · ${target.name}` : answer.request.title
+  const pending = recordAfterApply(project.root, delivery, after, profile ? { profile, target: targetOf(link) } : null)
+  const signIn = profile && pending.length ? await signInStep({ profile, apiUrl: link.platform, named: true }) : null
   return {
-    data: { applied: true, as: { signedIn: acting.as === 'person', email: acting.as === 'person' ? acting.email : null, profile: acting.profile }, outcome, request: { id: answer.request.id, title: answer.request.title, state: answer.request.state }, fetched, pendingInWorkspace: pending },
+    data: { applied: true, target: target.name, as: { signedIn: acting.as === 'person', email: acting.as === 'person' ? acting.email : null, profile: acting.profile }, outcome, request: { id: answer.request.id, title: answer.request.title, state: answer.request.state }, fetched, pendingInWorkspace: pending },
     text: [
-      `Applied “${answer.request.title}” to ${link.workspaceName ?? link.workspace}${acting.as === 'person' ? ` as ${acting.email ?? 'you'} (signed in)` : ''}.`,
+      `Applied “${answer.request.title}” to ${targetLabel(target)}${acting.as === 'person' ? ` as ${acting.email ?? 'you'} (signed in)` : ''}.`,
       ...describeOutcome(outcome, allTitles),
       '',
-      fetched.error ? `Could not fetch afterwards: ${fetched.error}. Run \`frontera local sync fetch\`.` : `Fetched: ${plural(fetched.adopted.length, 'item')} now match${fetched.adopted.length === 1 ? 'es' : ''} the workspace.`,
+      fetched.error
+        ? `Could not fetch afterwards: ${fetched.error}.${target.name ? '' : ' Run `frontera local sync fetch`.'}`
+        : target.name ? `Fetched ${targetLabel(target)}: the next push to it compares with what this Apply left there.` : `Fetched: ${plural(fetched.adopted.length, 'item')} now match${fetched.adopted.length === 1 ? 'es' : ''} the workspace.`,
       ...(pending.length
         ? ['', `Pending in workspace (${pending.length}), for a person:`, ...pending.map((p) => `  - ${p.changes}${p.command ? `: \`${p.command}\`` : ''}${p.check ? ' (checks itself)' : ''}`),
-          target
-            ? `They run against ${new URL(link.platform).host} with \`--profile ${target}\` (${getSyncKey(project, 'organization') ? "this project's keys" : 'as the person signed in on it'}), not the local runtime${signIn ? `; a step a signed-in person takes needs \`${signIn}\` first` : ''}.`
-            : `They name no target: the CLI could not record a profile for ${new URL(link.platform).host}${targetError ? ` (${targetError})` : ''}. Add \`--profile <a profile for that platform>\` when you run them.`,
+          profile
+            ? `They run against ${new URL(link.platform).host} with \`--profile ${profile}\` (${getSyncKey(target.owner, 'organization') ? (target.name ? `target ${target.name}’s keys` : "this project's keys") : 'as the person signed in on it'}), not the local runtime${signIn ? `; a step a signed-in person takes needs \`${signIn}\` first` : ''}.`
+            : `They name no target: the CLI could not record a profile for ${new URL(link.platform).host}${profileError ? ` (${profileError})` : ''}. Add \`--profile <a profile for that platform>\` when you run them.`,
           'Forge lists them on the project’s home; `frontera local steps` here.']
         : []),
     ].join('\n'),
@@ -1218,11 +1293,12 @@ async function apply(ctx: CommandContext) {
  * workspace's new copy (the newest document of that name), and each taken off
  * is forgotten, so the next push sees them as unchanged.
  */
-async function recordAppliedDocuments(project: LocalProject, link: SyncLink, api: Platform, view: View): Promise<void> {
+async function recordAppliedDocuments(target: SyncTarget, api: Platform, view: View): Promise<void> {
+  const { link } = target
   const items = view.items.filter((i) => i.kind === 'knowledge' && i.documents)
   if (!items.length) return
-  const snapshot = readSnapshot(project.root)
-  const remote = snapshot ? snapshotItems(project.root, snapshot) : []
+  const snapshot = readSnapshot(target.state)
+  const remote = snapshot ? snapshotItems(target.state, snapshot) : []
   for (const item of items) {
     const id = remote.find((r) => r.ref === item.ref)?.id
     if (!id) continue
@@ -1237,28 +1313,29 @@ async function recordAppliedDocuments(project: LocalProject, link: SyncLink, api
       if (newest?.id) entries[path] = { sourceId: newest.id, sha256: d.sha256, bytes: d.bytes, at: new Date().toISOString() }
     }
     // A document taken off is forgotten by the copy it was, wherever it was filed.
-    const pulled = readPulledDocuments(project.root, link.workspace).bases[item.name] ?? {}
+    const pulled = readPulledDocuments(target.state, link.workspace).bases[item.name] ?? {}
     for (const d of item.documents!.remove) {
       const at = Object.entries(pulled).find(([, was]) => was.sourceId === d.sourceId)?.[0]
       entries[at ?? d.fileName] = null
     }
-    recordPulledDocuments(project.root, link.workspace, item.name, entries)
+    recordPulledDocuments(target.state, link.workspace, item.name, entries)
   }
 }
 
 async function close(ctx: CommandContext) {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
-  const kept = currentRequest(readRequests(project.root, link.workspace))
-  if (!kept || !isOpen(kept.state)) throw new UsageError('no open change request to close', 'see where it stands with `frontera local sync request`')
-  const current = (await currentView(project, link))!
-  // Closing writes nothing to the workspace, so a request the project's key proposed is closed with that key.
-  const byKey = proposedByOther(current.api.acting, current.view) === 'key'
-  const refused = byKey ? null : notProposer(current.api.acting, current.view, 'close')
+  const target = chooseTarget(project, ctx)
+  const kept = currentRequest(readRequests(target.state, target.link.workspace))
+  if (!kept || !isOpen(kept.state)) throw new UsageError(`no open change request to close${target.name ? ` on target ${target.name}` : ''}`, `see where it stands with \`${targetWords(target, 'frontera local sync request')}\``)
+  const current = (await currentView(target))!
+  const { acting } = current.api
+  // Closing writes nothing to the workspace, so a request the key proposed is closed with that key.
+  const byKey = proposedByOther(acting, current.view) === 'key'
+  const refused = byKey ? null : notProposer(acting, current.view, 'close')
   if (refused) throw refused
-  const view = await (byKey ? keysFor(project, link) : current.api).call<View>('POST', `/v1/change-requests/${kept.id}/close`, {})
-  recordRequest(project.root, link.workspace, view)
-  return { data: { closed: true, request: { id: view.request.id, title: view.request.title, state: view.request.state } }, text: `Closed “${view.request.title}”${byKey ? ' with the project’s workspace key that proposed it' : ''}. The project’s files are unchanged; the next push opens a new change request.` }
+  const view = await (byKey ? keysFor(target) : current.api).call<View>('POST', `/v1/change-requests/${kept.id}/close`, {})
+  recordRequest(target.state, target.link.workspace, view)
+  return { data: { closed: true, target: target.name, request: { id: view.request.id, title: view.request.title, state: view.request.state } }, text: `Closed “${view.request.title}”${target.name ? ` on ${targetLabel(target)}` : ''}${byKey ? ` with ${ownerWords(acting, 'the project')}’s workspace key that proposed it` : ''}. The project’s files are unchanged; the next push opens a new change request.` }
 }
 
 /**
@@ -1271,11 +1348,11 @@ async function close(ctx: CommandContext) {
  */
 async function evidence(ctx: CommandContext) {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
-  const current = await currentView(project, link)
-  if (!current) throw new UsageError('no change request to attach evidence to', 'propose one with `frontera local sync push -t "<title>"`')
+  const target = chooseTarget(project, ctx)
+  const current = await currentView(target)
+  if (!current) throw new UsageError('no change request to attach evidence to', `propose one with \`${targetWords(target, 'frontera local sync push -t "<title>"')}\``)
   const { view, titles, api } = current
-  if (!isOpen(view.request.state)) throw new CliError(`“${view.request.title}” is ${STATE_WORD[view.request.state] ?? view.request.state}; it takes no evidence`, { code: 'CONFLICT', hint: 'propose new changes with `frontera local sync push -t "<title>"`' })
+  if (!isOpen(view.request.state)) throw new CliError(`“${view.request.title}” is ${STATE_WORD[view.request.state] ?? view.request.state}; it takes no evidence`, { code: 'CONFLICT', hint: `propose new changes with \`${targetWords(target, 'frontera local sync push -t "<title>"')}\`` })
   const refused = notProposer(api.acting, view, 'attach evidence to')
   if (refused) throw refused
   const session = flagString(ctx, 'screenshots') ?? process.env.FORGE_SESSION ?? null
@@ -1366,7 +1443,7 @@ async function evidence(ctx: CommandContext) {
   }
 
   const after = await api.call<View>('GET', `/v1/change-requests/${view.request.id}`)
-  recordRequest(project.root, link.workspace, after)
+  recordRequest(target.state, target.link.workspace, after)
   return {
     data: { attached, skipped, gate: after.gate ?? null },
     text: [
@@ -1383,17 +1460,17 @@ const PICTURE_EXT: Record<string, string> = { 'image/png': 'png', 'image/jpeg':
 /** One evidence picture, kept on this machine (in the runtime's state folder) for Forge to show. */
 async function evidenceImage(ctx: CommandContext) {
   const project = localProject(ctx.cwd)
-  const link = needLink(project)
+  const target = chooseTarget(project, ctx)
   const id = ctx.positional[2]
   if (!id || !/^[0-9a-f-]{36}$/.test(id)) throw new UsageError('say which evidence picture', 'frontera local sync request evidence-image <evidence id>')
-  const kept = currentRequest(readRequests(project.root, link.workspace))
-  if (!kept) throw new UsageError('no change request', 'propose one with `frontera local sync push -t "<title>"`')
+  const kept = currentRequest(readRequests(target.state, target.link.workspace))
+  if (!kept) throw new UsageError('no change request', `propose one with \`${targetWords(target, 'frontera local sync push -t "<title>"')}\``)
   const dir = join(project.stateDir, 'evidence', kept.id)
   for (const ext of Object.values(PICTURE_EXT)) {
     const path = join(dir, `${id}.${ext}`)
     if (existsSync(path)) return { data: { path, mime: Object.entries(PICTURE_EXT).find(([, e]) => e === ext)![0] }, text: path }
   }
-  const { bytes, mime } = await (await platformFor(project, link)).bytes(`/v1/change-requests/${kept.id}/evidence/${id}/content`)
+  const { bytes, mime } = await (await platformFor(target)).bytes(`/v1/change-requests/${kept.id}/evidence/${id}/content`)
   const ext = PICTURE_EXT[mime.split(';')[0]!.trim()]
   if (!ext) throw new CliError('the platform did not answer with a picture', { code: 'UNAVAILABLE', hint: 'run the command again' })
   mkdirSync(dir, { recursive: true })