@@ -1,5 +1,16 @@
 import type { Argv } from 'yargs';
 import { QUICKSTART_BUILDER, launchQuickstart } from '@features/quickstart/index.js';
+import {
+  listFlagsCmd,
+  getFlagCmd,
+  createFlagCmd,
+  updateFlagCmd,
+  toggleFlagCmd,
+  resolveFlagCmd,
+  targetFlagCmd,
+  archiveFlagCmd,
+} from '@features/flags/index.js';
+import { safely } from '../utils/safely.js';
 
 export const flagsCommand = {
   command: 'flags <action>',
@@ -14,6 +25,129 @@ export const flagsCommand = {
           await launchQuickstart(argv as Record<string, unknown>, { features: ['flags'] });
         },
       )
+      .command(
+        'list',
+        'List all flags in project',
+        (y: Argv) => y.option('page-token', { type: 'string', describe: 'Pagination token' }),
+        safely(listFlagsCmd),
+      )
+      .command(
+        'get <flag-key>',
+        'Get flag details (variants, targeting, status)',
+        (y: Argv) => y.positional('flag-key', { type: 'string', demandOption: true }),
+        safely(getFlagCmd),
+      )
+      .command(
+        'create <flag-key>',
+        'Create a new flag',
+        (y: Argv) =>
+          y
+            .positional('flag-key', { type: 'string', demandOption: true })
+            .option('description', {
+              alias: 'd',
+              type: 'string',
+              describe: 'Flag description',
+            })
+            .option('variant', {
+              type: 'string',
+              array: true,
+              describe: 'Variant name (e.g. --variant on --variant off)',
+            })
+            .option('client', { type: 'string', describe: 'Client name for the flag' })
+            .option('from-file', { type: 'string', describe: 'Read options from JSON file' }),
+        safely(createFlagCmd),
+      )
+      .command(
+        'update <flag-key>',
+        'Update flag description or variants',
+        (y: Argv) =>
+          y
+            .positional('flag-key', { type: 'string', demandOption: true })
+            .option('description', {
+              alias: 'd',
+              type: 'string',
+              describe: 'New description',
+            })
+            .option('add-variant', {
+              type: 'string',
+              array: true,
+              describe: 'Variant name to add',
+            })
+            .option('from-file', { type: 'string', describe: 'Read options from JSON file' }),
+        safely(updateFlagCmd),
+      )
+      .command(
+        'toggle <flag-key>',
+        'Enable or disable a flag',
+        (y: Argv) =>
+          y
+            .positional('flag-key', { type: 'string', demandOption: true })
+            .option('on', { type: 'boolean', describe: 'Enable the flag' })
+            .option('off', { type: 'boolean', describe: 'Disable the flag' })
+            .conflicts('on', 'off')
+            .check((args) => {
+              if (!args.on && !args.off) {
+                throw new Error('Provide either --on or --off.');
+              }
+              return true;
+            }),
+        safely(toggleFlagCmd),
+      )
+      .command(
+        'resolve <flag-key>',
+        'Resolve flag value for given context',
+        (y: Argv) =>
+          y
+            .positional('flag-key', { type: 'string', demandOption: true })
+            .option('entity', {
+              type: 'string',
+              describe: 'Targeting key field (e.g. targeting_key)',
+              demandOption: true,
+            })
+            .option('entity-value', {
+              type: 'string',
+              describe: 'Targeting key value (e.g. user-123)',
+              demandOption: true,
+            })
+            .option('context', {
+              type: 'string',
+              array: true,
+              describe: 'Additional context key=value pair',
+            })
+            .option('client', { type: 'string', describe: 'Client name for resolution' }),
+        safely(resolveFlagCmd),
+      )
+      .command(
+        'target <flag-key>',
+        'View or update targeting rules',
+        (y: Argv) =>
+          y
+            .positional('flag-key', { type: 'string', demandOption: true })
+            .option('add', {
+              type: 'string',
+              describe: 'Add rule as variant:percentage pairs (e.g. on:80,off:20)',
+            })
+            .option('targeting-key', {
+              type: 'string',
+              describe: 'Targeting key for the rule (used with --add)',
+            })
+            .option('from-file', {
+              type: 'string',
+              describe: 'Read rule from JSON file',
+            }),
+        safely(targetFlagCmd),
+      )
+      .command(
+        'archive <flag-key>',
+        'Archive a flag',
+        (y: Argv) =>
+          y.positional('flag-key', { type: 'string', demandOption: true }).option('force', {
+            alias: 'f',
+            type: 'boolean',
+            describe: 'Skip confirmation prompt',
+          }),
+        safely(archiveFlagCmd),
+      )
       .demandCommand(1, 'Run "confidence flags --help" to see available actions.')
       .strict();
   },
 
@@ -1,13 +1,14 @@
+import type { JsonObject } from '@spotify-confidence/shared-kernel';
 import { createEventDefinition } from '@network/index.js';
-import { message, printMcpResult } from '@output/print.js';
-import { withAuth } from '../../utils/require-auth.js';
-import { resolveTargetFile } from '../../utils/read-json-file.js';
+import { message, printMcpResult } from '@output/index.js';
+import { withAuth } from '@utils/require-auth.js';
+import { resolveInput } from '@input/index.js';
 import { parseFieldArg } from './field-spec.js';
 
 export const createEvent = withAuth(async function createEvent(argv, token) {
   const eventDefinitionId = argv.name as string;
 
-  const schema = resolveTargetFile<Record<string, unknown>>(argv, () => {
+  const schema = resolveInput<JsonObject>(argv, () => {
     const fieldSpecs = (argv.field as string[] | undefined) ?? [];
     if (fieldSpecs.length === 0) {
       throw new Error('Provide at least one --field or --from-file.');
 
@@ -1,6 +1,8 @@
+import type { JsonObject } from '@spotify-confidence/shared-kernel';
+
 const FIELD_TYPES = ['string', 'int', 'double', 'bool', 'struct'] as const;
 
-export function parseFieldArg(spec: string): [string, Record<string, unknown>] {
+export function parseFieldArg(spec: string): [string, JsonObject] {
   const colonIndex = spec.indexOf(':');
   if (colonIndex === -1) {
     throw new Error(`Invalid field format "${spec}". Expected "name:type" (e.g. "page:string").`);
 
@@ -0,0 +1,39 @@
+import confirm from '@inquirer/confirm';
+import { archiveFlag } from '@network/index.js';
+import { message, fail } from '@output/index.js';
+import { withAuth } from '@utils/require-auth.js';
+
+export const archiveFlagCmd = withAuth(async function archiveFlagCmd(argv, token) {
+  const flagKey = argv['flag-key'] as string;
+
+  if (argv['dry-run']) {
+    message(JSON.stringify({ action: 'archive', flagKey }, null, 2));
+    return;
+  }
+
+  if (!argv.force) {
+    if (!process.stdin.isTTY) {
+      fail('Cannot prompt for confirmation without a TTY. Use --force to skip.');
+      return;
+    }
+
+    const confirmed = await confirm({
+      message: `Archive flag "${flagKey}"? This cannot be undone.`,
+      default: false,
+    });
+
+    if (!confirmed) {
+      message('Aborted.');
+      return;
+    }
+  }
+
+  const result = await archiveFlag(token, flagKey);
+
+  if (!result.ok) {
+    fail(result.error.message);
+    return;
+  }
+
+  message(`Flag "${flagKey}" archived.`);
+});
@@ -0,0 +1,24 @@
+import { createFlag } from '@network/index.js';
+import { message, printMcpResult } from '@output/index.js';
+import { withAuth } from '@utils/require-auth.js';
+import { resolveInput } from '@input/index.js';
+
+export const createFlagCmd = withAuth(async function createFlagCmd(argv, token) {
+  const flagKey = argv['flag-key'] as string;
+  const opts = resolveInput(argv, ['description', 'variant', 'client']);
+  const description = opts.description as string | undefined;
+  const variants = (opts.variant as string[]) ?? [];
+  const client = opts.client as string | undefined;
+
+  if (argv['dry-run']) {
+    message(JSON.stringify({ flagKey, description, variants, client }, null, 2));
+    return;
+  }
+
+  const result = await createFlag(token, flagKey, {
+    description,
+    variants: variants.length > 0 ? variants : undefined,
+    client,
+  });
+  printMcpResult(result, argv);
+});
@@ -0,0 +1,73 @@
+import { getFlag } from '@network/index.js';
+import { resolveFormat, formatJson, extractFlags, fail, message, print } from '@output/index.js';
+import { withAuth } from '@utils/require-auth.js';
+import { flagStatus } from './status.js';
+
+export const getFlagCmd = withAuth(async function getFlagCmd(argv, token) {
+  const flagKey = argv['flag-key'] as string;
+
+  const result = await getFlag(token, flagKey);
+
+  if (!result.ok) {
+    fail(result.error.message);
+    return;
+  }
+
+  const flag = result.data;
+  const flags = extractFlags(argv);
+  const format = resolveFormat(flags);
+
+  if (format === 'json') {
+    message(formatJson(flag));
+    return;
+  }
+
+  print({
+    data: {
+      'Flag Key': flag.flagId ?? flag.name.replace(/^flags\//, ''),
+      Description: flag.description ?? '',
+      Status: flagStatus(flag),
+      Created: flag.createTime ?? '',
+      Updated: flag.updateTime ?? '',
+    },
+    columns: [
+      { key: 'key', header: 'Field', width: 14 },
+      { key: 'value', header: 'Value' },
+    ],
+    flags,
+  });
+
+  if (flag.variants && flag.variants.length > 0) {
+    message('');
+    message('Variants:');
+    print({
+      data: flag.variants.map((v) => ({
+        name: v.name.split('/').pop() ?? v.name,
+        description: v.description ?? '',
+      })),
+      columns: [
+        { key: 'name', header: 'Name' },
+        { key: 'description', header: 'Description' },
+      ],
+      flags,
+    });
+  }
+
+  if (flag.rules && flag.rules.length > 0) {
+    message('');
+    message('Targeting Rules:');
+    print({
+      data: flag.rules.map((r) => ({
+        name: r.name.split('/').pop() ?? r.name,
+        enabled: String(r.enabled ?? false),
+        targetingKey: r.targetingKeySelector ?? '',
+      })),
+      columns: [
+        { key: 'name', header: 'Rule' },
+        { key: 'enabled', header: 'Enabled' },
+        { key: 'targetingKey', header: 'Targeting Key' },
+      ],
+      flags,
+    });
+  }
+});
@@ -0,0 +1,9 @@
+export { listFlagsCmd } from './list.js';
+export { getFlagCmd } from './get.js';
+export { createFlagCmd } from './create.js';
+export { updateFlagCmd } from './update.js';
+export { toggleFlagCmd } from './toggle.js';
+export { resolveFlagCmd } from './resolve.js';
+export { targetFlagCmd } from './target.js';
+export { archiveFlagCmd } from './archive.js';
+export { flagStatus } from './status.js';
@@ -0,0 +1,49 @@
+import { listFlags } from '@network/index.js';
+import { resolveFormat, formatJson, extractFlags, fail, message, print } from '@output/index.js';
+import { withAuth } from '@utils/require-auth.js';
+import { flagStatus } from './status.js';
+
+export const listFlagsCmd = withAuth(async function listFlagsCmd(argv, token) {
+  const result = await listFlags(token, {
+    pageToken: argv['page-token'] as string | undefined,
+  });
+
+  if (!result.ok) {
+    fail(result.error.message);
+    return;
+  }
+
+  const flags = extractFlags(argv);
+  const format = resolveFormat(flags);
+
+  if (format === 'json') {
+    const meta = result.data.nextPageToken
+      ? { nextPageToken: result.data.nextPageToken }
+      : undefined;
+    message(formatJson(result.data.flags ?? [], meta));
+    return;
+  }
+
+  const rows = (result.data.flags ?? []).map((f) => ({
+    key: f.flagId ?? f.name.replace(/^flags\//, ''),
+    status: flagStatus(f),
+    variants: String(f.variants?.length ?? 0),
+    updated: f.updateTime ?? '',
+  }));
+
+  print({
+    data: rows,
+    columns: [
+      { key: 'key', header: 'Flag Key' },
+      { key: 'status', header: 'Status' },
+      { key: 'variants', header: 'Variants' },
+      { key: 'updated', header: 'Updated' },
+    ],
+    flags,
+    empty: 'No flags found.',
+  });
+
+  if (result.data.nextPageToken) {
+    message(`\nNext page: --page-token ${result.data.nextPageToken}`);
+  }
+});