@@ -136,11 +136,13 @@ fileignoreconfig:
     - "a test passes `var`, `env-file` and `from-stack`"
     - "an in-flight secret registry to redact against"
 - filename: src/core/project-config.ts
-  checksum: feec5219c90a2368edccab2c290284b6e7ccee7fb78443c7b4852d7b207119a4
+  checksum: 1f19da706128ee78e1fe20d8624626038893d908a7061b3f2633e741a77c93b6
 - filename: src/core/project-config.test.ts
-  checksum: ff428e7553ba60bacc1ecf61f2076dedde03b09bd7167cc052b780a783217dc0
+  checksum: 65c0a613ec77d4dc6727224d4d097de4a02b300339286db692dbaea9379565ae
+- filename: src/core/resolve.ts
+  checksum: 25cb3c5eb789bfd148efb1a990932b99970c45d5777344d34e66cf54207c5256
 - filename: src/core/resolve.test.ts
-  checksum: d745e6efbb9c4595ee7c57a2625a73d687d3e880a346f53de2d7da183971d875
+  checksum: 1a07140c5f61d2c1cbd1f9746fca2e907fd2467f804c62a0ed6c188b6944b126
 - filename: src/git/local-repository.ts
   checksum: 7f266d6d6796574721ca463a14914759c91ce25dfa5b333f103258fe2336cfe5
 - filename: src/core/layering.test.ts
@@ -152,13 +154,13 @@ fileignoreconfig:
 - filename: test/integration/projects-delete.test.ts
   checksum: 4e2960b921f69bcb5fc1b4d6089b7ded1b71ed54609d8304bf7ee84041cf7fc2
 - filename: src/core/launch-command.ts
-  checksum: d0feba27c3773df89bd527b9e1ba43233d1152927e2c9c69121e084760ed7d94
+  checksum: 4bccae32140aa3b4da94346b4bfd3b199a2a7d568f26e28d7dad58b266148038
 - filename: src/core/launch-command.test.ts
-  checksum: 76367d660556bd49cf04e494818425f844bb8e1d8f6bfd2168db5ac101d66abc
+  checksum: 2cc245f8a4af102eb9edb53184d1af2486c6bbf9588a41e56452895a4c580e99
 - filename: src/projects/project.inputs.test.ts
   checksum: f8dbd017bbe58700d010881d9bc92f6e640260668d27c91cfe1bb4ee9d1942b6
 - filename: test/integration/projects-command-flows.test.ts
-  checksum: 27cf0618ef66f038e0bc70988af281971a3511b97dd4cbc584591b78ec884042
+  checksum: 58364e1ed8e4958fe32bfa86e1598c156ab260d495f2700690b0443e3cc670b9
 - filename: src/core/redact.test.ts
   checksum: ae497ea8c3a4c3f12217d2c4c028a1da3d1324e18362d68c355ba8120902bcb3
 - filename: src/commands/launch/projects/list.test.ts
 
@@ -201,7 +201,8 @@ A new resource - environments, variables, deployments, logs, cache - is a folder
    `T` is the value type and `D` names the inputs it depends on, so `resolved.org` is a
    `string` inside a prompt or normalize callback rather than something to cast. A spec
    may carry `configPath` (a key of `ProjectConfig`, checked at compile time),
-   `dependsOn`, `prompt`, `normalize` and `default`.
+   `configLabel` (how the config-file notice names it; required alongside `configPath`,
+   enforced by `src/resources.test.ts`), `dependsOn`, `prompt`, `normalize` and `default`.
 5. **`src/resources.ts`** - spread the new flags into `catalog`, the new specs into
    `resolution`, the new dependencies into `DEPENDENCIES`, and add the repository to
    `ApiSurface` / `buildApi`. This is the one shared file, so expect to rebase on it.
@@ -441,6 +442,18 @@ from a typo in it is the wrong trade. A missing file is simply written fresh.
 it (`projectConfigLoader`), so a V1 file whose branch blocks disagree does not block a command whose
 flags already supply everything; a file named with `--config` is still read at once.
 
+**The config-file notice.** When any input came from the file, `LaunchCommand.init` prints one line
+through `this.ux.print` (stdout, like every other line the CLI prints), worded by
+`configSourceNotice` in `src/core/project-config.ts` from the `configLabel` of each such input and the
+**full path** of the file actually read (a relative `--config` is resolved first): `Using the
+organization and project UIDs from /Users/me/site/.cs-launch.json.` (one input: `Using the project UID
+from …`). It is the first line a command prints. There is no `info:` prefix; only the path is cyan -
+the one style here that means neither success (green) nor warning (yellow) - and only when
+`outputIsTTY`; the rest of the line is plain. It names no uid and no override hint by decision, prints
+with or without a terminal, and says nothing when every value came from a flag, a prompt or a
+default. `resolveInputsTraced` is what reports where each value came from; `resolveInputs` is the
+same resolution without the sources.
+
 The store's second constructor argument says whether the path was one the **user named**.
 At the implicit default path a missing or unreadable file is simply an empty config; at a
 path the user passed with `--config` it is a `UsageError` naming the path, because silence
 
@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { resolve as resolvePath, join } from 'node:path';
 
@@ -11,6 +11,7 @@ import { CancelledError, MissingInputError, UsageError } from './errors';
 import { exactlyOneOf } from './rules';
 import { LaunchApiError } from '../transport/errors';
 import { UxLike } from './render';
+import type { FlagKey } from '../resources';
 import { LaunchCommand, projectConfigLoader, resolveLaunchContext } from './launch-command';
 import * as serviceContext from './service-context';
 import { SearchListClass, utilitiesLoader } from './search-list';
@@ -525,6 +526,69 @@ describe('LaunchCommand.init terminal detection', () => {
   });
 });
 
+class ProbeWithOrg extends LaunchCommand {
+  static flags = {};
+  static inputs = { org: {} };
+
+  async run(): Promise<void> {
+    return undefined;
+  }
+}
+
+describe('LaunchCommand.init config file notice', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    tempDirs.forEach((dir) => rmSync(dir, { recursive: true, force: true }));
+    tempDirs.length = 0;
+  });
+
+  async function initInFolderHoldingAnOrg(
+    flags: Record<string, unknown>,
+  ): Promise<{ printed: string[]; configFile: string }> {
+    const dir = mkdtempSync(join(tmpdir(), 'launch-cli-'));
+    tempDirs.push(dir);
+    writeFileSync(join(dir, PROJECT_CONFIG_FILE), JSON.stringify({ project: { organizationUid: 'org-from-cwd' } }));
+    jest.spyOn(process, 'cwd').mockReturnValue(dir);
+    jest.spyOn(authHandler, 'isAuthenticated').mockReturnValue(true);
+    const instance = new ProbeWithOrg([], {} as never);
+    Object.defineProperty(instance, 'launchRegion', {
+      value: { launchHubUrl: 'https://launch-api.test' },
+      configurable: true,
+    });
+    Object.defineProperty(instance, 'config', { value: { userAgent: 'cli/2.0.0' }, configurable: true });
+    (instance as unknown as { parse: jest.Mock }).parse = jest.fn().mockResolvedValue({ flags });
+    const printed: string[] = [];
+    const ux: UxLike = { print: (message) => printed.push(message), inquire: async () => undefined as never };
+    Object.defineProperty(instance, 'ux', { value: ux, configurable: true });
+
+    await instance.init();
+
+    return { printed, configFile: join(dir, PROJECT_CONFIG_FILE) };
+  }
+
+  it('prints the notice on stdout when a value came from the config file', async () => {
+    const { printed, configFile } = await initInFolderHoldingAnOrg({});
+
+    expect(printed).toEqual([`Using the organization UID from ${configFile}.`]);
+  });
+
+  it('colours only the config file path cyan when stdout is a terminal', async () => {
+    const restore = stdoutReportingTTY(true);
+
+    const { printed, configFile } = await initInFolderHoldingAnOrg({});
+    restore();
+
+    expect(printed).toEqual([`Using the organization UID from \u001b[36m${configFile}\u001b[39m.`]);
+  });
+
+  it('prints nothing when every value came from a flag', async () => {
+    const { printed } = await initInFolderHoldingAnOrg({ org: 'org-from-flag' });
+
+    expect(printed).toEqual([]);
+  });
+});
+
 describe('LaunchCommand.init rules', () => {
   it('evaluates the rules the subclass declares as a static rules array', async () => {
     const instance = new ProbeWithRules([], {} as never) as ProbeWithRules & { error: jest.Mock };
@@ -637,6 +701,57 @@ describe('resolveLaunchContext', () => {
     expect(result.services.ux).toBe(ux);
     expect(result.services.isTTY).toBe(true);
   });
+
+  async function contextInFolderHoldingAnOrg(flags: Partial<Record<FlagKey, unknown>>) {
+    const dir = mkdtempSync(join(tmpdir(), 'launch-cli-'));
+    tempDirs.push(dir);
+    writeFileSync(join(dir, PROJECT_CONFIG_FILE), JSON.stringify({ project: { organizationUid: 'org-from-cwd' } }));
+    jest.spyOn(process, 'cwd').mockReturnValue(dir);
+
+    return resolveLaunchContext({
+      flags,
+      inputs: { org: {} },
+      launchHubUrl: 'https://launch-api.test',
+      analyticsInfo: 'cli/2.0.0',
+      ux: { print: () => undefined, inquire: async () => undefined as never },
+      isTTY: false,
+    });
+  }
+
+  it('words a notice naming the values the config file supplied and where that file is', async () => {
+    const result = await contextInFolderHoldingAnOrg({});
+
+    expect(result.configNotice).toBe(`Using the organization UID from ${result.configPath}.`);
+  });
+
+  it('names a config file passed by a relative --config path by its full path', async () => {
+    const dir = realpathSync(mkdtempSync(join(tmpdir(), 'launch-cli-')));
+    tempDirs.push(dir);
+    writeFileSync(join(dir, 'staging.json'), JSON.stringify({ project: { organizationUid: 'org-from-staging' } }));
+    const startedIn = process.cwd();
+    process.chdir(dir);
+
+    try {
+      const result = await resolveLaunchContext({
+        flags: { config: 'staging.json' },
+        inputs: { org: {} },
+        launchHubUrl: 'https://launch-api.test',
+        analyticsInfo: 'cli/2.0.0',
+        ux: { print: () => undefined, inquire: async () => undefined as never },
+        isTTY: false,
+      });
+
+      expect(result.configNotice).toBe(`Using the organization UID from ${join(dir, 'staging.json')}.`);
+    } finally {
+      process.chdir(startedIn);
+    }
+  });
+
+  it('words no notice when the flags supplied every value the config file also holds', async () => {
+    const result = await contextInFolderHoldingAnOrg({ org: 'org-from-flag' });
+
+    expect(result.configNotice).toBeUndefined();
+  });
 });
 
 describe('projectConfigLoader', () => {
 
@@ -4,12 +4,12 @@ import { Command } from '@contentstack/cli-command';
 import { cliux, configHandler, isAuthenticated } from '@contentstack/cli-utilities';
 
 import { EXIT_RUNTIME, PROJECT_CONFIG_FILE, STDIN_MAX_LISTENERS } from './constants';
-import { ProjectConfig, ProjectConfigStore } from './project-config';
+import { ProjectConfig, ProjectConfigStore, configSourceNotice } from './project-config';
 import { RegionLike, resolveLaunchHubUrl } from './region';
 import { LaunchError, UsageError } from './errors';
-import { catalog, FlagKey } from '../resources';
+import { catalog, FlagKey, resolutionTable } from '../resources';
 import { AnyInputs, Resolved } from './inputs';
-import { resolveInputs } from './resolve';
+import { resolveInputsTraced } from './resolve';
 import { Rule } from './rules';
 import { cancelOnInterrupt } from './interruptible-ux';
 import { UxLike } from './render';
@@ -34,6 +34,7 @@ export interface ResolveLaunchContextResult<S extends AnyInputs> {
   resolved: Resolved<S>;
   dataDir: string;
   configPath: string;
+  configNotice?: string;
 }
 
 export async function resolveLaunchContext<S extends AnyInputs>(
@@ -53,14 +54,20 @@ export async function resolveLaunchContext<S extends AnyInputs>(
     outputIsTTY: args.outputIsTTY,
   });
 
-  const resolved = await resolveInputs(args.inputs, {
+  const { resolved, sources } = await resolveInputsTraced(args.inputs, {
     parsed: args.flags,
     projectConfig: projectConfigLoader(new ProjectConfigStore(configPath, Boolean(namedConfig)), Boolean(namedConfig)),
     services,
     rules: args.rules,
   });
 
-  return { services, resolved, dataDir, configPath };
+  const configLabels = Object.entries(sources)
+    .filter(([, source]) => source === 'config')
+    .map(([key]) => resolutionTable[key as FlagKey].configLabel)
+    .filter((label): label is string => label !== undefined);
+  const configNotice = configSourceNotice(configLabels, resolvePath(configPath), args.outputIsTTY === true);
+
+  return { services, resolved, dataDir, configPath, configNotice };
 }
 
 export function projectConfigLoader(store: ProjectConfigStore, named: boolean): ProjectConfig | (() => ProjectConfig) {
@@ -116,7 +123,7 @@ export abstract class LaunchCommand<S extends AnyInputs = AnyInputs> extends Com
 
     const region = this.launchRegion ?? {};
 
-    const { services, resolved, dataDir, configPath } = await resolveLaunchContext<S>({
+    const { services, resolved, dataDir, configPath, configNotice } = await resolveLaunchContext<S>({
       flags,
       inputs: this.contract.inputs as S,
       rules: this.contract.rules,
@@ -133,6 +140,10 @@ export abstract class LaunchCommand<S extends AnyInputs = AnyInputs> extends Com
     this.resolved = resolved;
     this.dataDir = dataDir;
     this.configPath = configPath;
+
+    if (configNotice !== undefined) {
+      this.ux.print(configNotice);
+    }
   }
 
   protected async confirm(message: string): Promise<boolean> {
 
@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { UsageError } from './errors';
-import { DEFAULT_BLOCK_KEY, ProjectConfigStore } from './project-config';
+import { DEFAULT_BLOCK_KEY, ProjectConfigStore, configSourceNotice } from './project-config';
 
 const tempDirs: string[] = [];
 
@@ -410,3 +410,35 @@ describe('ProjectConfigStore.save', () => {
     expect(new ProjectConfigStore(path).load()).toEqual({ uid: 'p1', organizationUid: 'org1' });
   });
 });
+
+describe('configSourceNotice', () => {
+  it('names the one value it took from the config file', () => {
+    expect(configSourceNotice(['project'], '/work/site/.cs-launch.json', false)).toBe(
+      'Using the project UID from /work/site/.cs-launch.json.',
+    );
+  });
+
+  it('joins two values with "and" and speaks of UIDs', () => {
+    expect(configSourceNotice(['organization', 'project'], '/work/site/.cs-launch.json', false)).toBe(
+      'Using the organization and project UIDs from /work/site/.cs-launch.json.',
+    );
+  });
+
+  it('separates three or more values with commas and puts "and" before the last', () => {
+    const labels = ['organization', 'project', 'environment'];
+
+    expect(configSourceNotice(labels, '/work/site/.cs-launch.json', false)).toBe(
+      'Using the organization, project and environment UIDs from /work/site/.cs-launch.json.',
+    );
+  });
+
+  it('names a config file the user pointed at by its full path', () => {
+    expect(configSourceNotice(['project'], '/work/shared/envs/staging.json', false)).toBe(
+      'Using the project UID from /work/shared/envs/staging.json.',
+    );
+  });
+
+  it('has nothing to say when no value came from the config file', () => {
+    expect(configSourceNotice([], '/work/site/.cs-launch.json', false)).toBeUndefined();
+  });
+});
@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 
 import { UsageError } from './errors';
+import { styled } from './style';
 
 export interface ProjectConfig {
   uid?: string | null;
@@ -192,3 +193,14 @@ export class ProjectConfigStore {
     return isBlock(parsed) ? parsed : `The config file at '${this.path}' does not hold a project config.`;
   }
 }
+
+export function configSourceNotice(labels: string[], configPath: string, colour: boolean): string | undefined {
+  if (labels.length === 0) {
+    return undefined;
+  }
+
+  const last = labels[labels.length - 1];
+  const named = labels.length === 1 ? `${last} UID` : `${labels.slice(0, -1).join(', ')} and ${last} UIDs`;
+
+  return `Using the ${named} from ${styled(configPath, 'cyan', colour)}.`;
+}
@@ -32,6 +32,7 @@ export interface LooseArgs {
 
 export interface ResolutionSpec<T, D extends FlagKey = never, R extends T = T> {
   configPath?: ProjectConfigKey;
+  configLabel?: string;
   dependsOn?: readonly D[];
   prompt?(args: PromptArgs<D>): Promise<T>;
   normalize?(value: T, args: NormalizeArgs<D>): Promise<R>;
@@ -40,6 +41,7 @@ export interface ResolutionSpec<T, D extends FlagKey = never, R extends T = T> {
 
 export interface AnyResolutionSpec {
   configPath?: ProjectConfigKey;
+  configLabel?: string;
   dependsOn?: readonly FlagKey[];
   prompt?(args: LooseArgs): Promise<unknown>;
   normalize?(value: unknown, args: LooseNormalizeArgs): Promise<unknown>;
 
@@ -5,7 +5,7 @@ import { FlagKey } from '../resources';
 import { AnyInputs, inputs } from './inputs';
 import * as resolutionModule from '../resources';
 import { AnyResolutionSpec } from './resolution';
-import { resolveInputs } from './resolve';
+import { resolveInputs, resolveInputsTraced } from './resolve';
 import { atLeastOneOf, exactlyOneOf } from './rules';
 
 function withResolution<T>(replacement: Record<string, AnyResolutionSpec>, run: () => Promise<T>): Promise<T> {
@@ -802,3 +802,18 @@ describe('MissingInputError', () => {
     expect(error.flag).toBe('org');
   });
 });
+
+describe('resolveInputsTraced', () => {
+  it('reports where each resolved value came from alongside the values', async () => {
+    const traced = await resolveInputsTraced(inputs({ org: { required: true }, limit: {}, skip: {} }), {
+      parsed: { skip: 5 },
+      projectConfig: { organizationUid: 'from-config' },
+      services: services(),
+    });
+
+    expect(traced).toEqual({
+      resolved: { org: 'from-config', limit: 100, skip: 5 },
+      sources: { org: 'config', limit: 'default', skip: 'flag' },
+    });
+  });
+});