@alexandrealvaro/agentic 0.7.0-beta.1 → 0.9.0-beta.1

package/README.md

@@ -46,6 +46,35 @@ A short TUI shows the detected mode, agent, and feature signals (frontend / `.cl
 
 If your project already has an `AGENTS.md` (or `CLAUDE.md`), the installer appends a managed `Skills installed by agentic` section bracketed by `<!-- agentic-managed-skills:start -->` / `:end -->` markers. User content outside those markers is byte-preserved; re-runs update only the managed block.
 
+## Project maturity profiles
+
+The kit ships four profiles that select which skills auto-install. Same WORKFLOW principles bind every profile; only the artifact set scales.
+
+| Profile | Universal install set | Conditional posture | Recommended for |
+| --- | --- | --- | --- |
+| `poc` | philosophy, ground, audit | all blocked | spike, hackathon, exploration |
+| `solo` | + bootstrap, spec, task, review | architecture / adr / hooks opt-in; design auto if frontend; subagent auto for Claude Code | solo developer shipping a real product |
+| `team` (default) | + architecture, adr | hooks opt-in; design / subagent / skill follow autoIf | team product, shared discipline |
+| `mature` | same as team | hooks **recommended**; future evals + spike skills land here | regulated / public-facing production |
+
+Select at init time:
+
+```bash
+npx @alexandrealvaro/agentic@beta init --profile poc
+```
+
+Or change later:
+
+```bash
+npx @alexandrealvaro/agentic@beta profile set solo    # add solo's universal skills
+npx @alexandrealvaro/agentic@beta profile show        # show current per-agent profile
+npx @alexandrealvaro/agentic@beta profile list        # list all profiles
+```
+
+`profile set` runs the equivalent of `update` after writing the new profile, so the install set matches. The state-aware three-way diff prompts before overwriting user-edited files.
+
+Existing v0.7 installs with no profile field migrate to `team` automatically — same install set as before, no user action needed.
+
 ## Updating an existing project
 
 To pull upstream kit changes into a project that already has agentic skills installed:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexandrealvaro/agentic",
-  "version": "0.7.0-beta.1",
+  "version": "0.9.0-beta.1",
   "description": "Bootstrap and audit AGENTS.md, ARCHITECTURE.md, ADRs, skills, and subagents for engineering production code with LLMs",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
   },
   "scripts": {
     "start": "node bin/agentic.js",
-    "test": "node bin/agentic.js --help && node bin/agentic.js init --help && node bin/agentic.js update --help && node --test test/*.test.js",
+    "test": "node bin/agentic.js --help && node bin/agentic.js init --help && node bin/agentic.js update --help && node bin/agentic.js profile --help && node --test test/*.test.js",
     "prepublishOnly": "npm test"
   },
   "keywords": [

package/src/commands/init.js

@@ -5,6 +5,14 @@ import { dirname, join } from 'node:path';
 import { detectAgents, detectFeatures, detectMode } from '../lib/detect.js';
 import { installSkills } from '../lib/install.js';
 import { saveState, loadState } from '../lib/state.js';
+import {
+  DEFAULT_PROFILE,
+  PROFILES,
+  PROFILE_NAMES,
+  availableConditionalsForProfile,
+  profileOrDefault,
+  requiredSkillsForProfile,
+} from '../lib/profiles.js';
 import { updateRootDoc } from '../lib/rootdoc.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -43,23 +51,18 @@ const ROOT_DOC_LABEL = {
   absent: '',
 };
 
-export const REQUIRED_SKILLS = [
-  'agentic-bootstrap',
-  'agentic-philosophy',
-  'agentic-architecture',
-  'agentic-adr',
-  'agentic-spec',
-  'agentic-task',
-  'agentic-audit',
-  'agentic-review',
-  'agentic-ground',
-];
+/**
+ * Backward-compatible export: the `team` profile's universal skill list.
+ * Tests and downstream code that imported REQUIRED_SKILLS pre-v0.8 get the
+ * same list. New code should call `requiredSkillsForProfile(profileName)`.
+ */
+export const REQUIRED_SKILLS = requiredSkillsForProfile('team');
 
 /**
- * Conditional skills.
- * - autoIf(features): true → pre-checked / installed by default in non-interactive.
- * - agents: which agents have a source tree for this skill (claude-code, codex, or both).
- * - hint: shown next to the option in the TUI.
+ * Backward-compatible export: the v0.7-shape conditional skill catalog.
+ * The four entries match the four conditional skills available in v0.7
+ * with their autoIf / agents / hint configuration. The profile-aware
+ * install path overrides `autoIf` per profile via `availableConditionalsForProfile`.
  */
 export const CONDITIONAL_SKILLS = [
   {
@@ -92,6 +95,10 @@ export const CONDITIONAL_SKILLS = [
   },
 ];
 
+const CONDITIONAL_BY_NAME = Object.fromEntries(
+  CONDITIONAL_SKILLS.map((s) => [s.name, s])
+);
+
 function resolveAgents(flagValue, detectedAgents) {
   if (flagValue === 'both') return ['claude-code', 'codex'];
   if (flagValue) return [flagValue];
@@ -99,18 +106,39 @@ function resolveAgents(flagValue, detectedAgents) {
   return ['claude-code'];
 }
 
-function pickConditionalAuto(features, targetAgents) {
-  return CONDITIONAL_SKILLS.filter(
-    (s) => s.autoIf(features) && s.agents.some((a) => targetAgents.includes(a))
-  ).map((s) => s.name);
+/**
+ * Translate a profile rule (`'frontend'`, `'claude-code'`, `true`, `false`)
+ * into a boolean: should this conditional auto-install for the current
+ * features and target agents?
+ */
+function evaluateRule(rule, features, targetAgents) {
+  if (rule === 'frontend') return features.frontend === true;
+  if (rule === 'claude-code') return targetAgents.includes('claude-code');
+  if (rule === true) return true;
+  if (rule === false) return false;
+  return false;
+}
+
+function pickConditionalAuto(features, targetAgents, profileName) {
+  const out = [];
+  for (const { name, rule } of availableConditionalsForProfile(profileName)) {
+    const def = CONDITIONAL_BY_NAME[name];
+    if (!def) continue;
+    if (!def.agents.some((a) => targetAgents.includes(a))) continue;
+    if (evaluateRule(rule, features, targetAgents)) {
+      out.push(name);
+    }
+  }
+  return out;
 }
 
-function skillsForAgent(agent, optedSkills) {
+function skillsForAgent(agent, profileName, optedSkills) {
+  const universal = requiredSkillsForProfile(profileName);
   const conditional = optedSkills.filter((skillName) => {
-    const def = CONDITIONAL_SKILLS.find((s) => s.name === skillName);
+    const def = CONDITIONAL_BY_NAME[skillName];
     return def && def.agents.includes(agent);
   });
-  return [...REQUIRED_SKILLS, ...conditional];
+  return [...universal, ...conditional];
 }
 
 export async function initCommand(opts) {
@@ -120,6 +148,12 @@ export async function initCommand(opts) {
     );
   }
 
+  if (opts.profile && !PROFILE_NAMES.includes(opts.profile)) {
+    throw new Error(
+      `invalid profile "${opts.profile}". Use one of: ${PROFILE_NAMES.join(', ')}`
+    );
+  }
+
   const cwd = process.cwd();
   const interactive = process.stdout.isTTY && !opts.yes && !opts.agent;
 
@@ -127,18 +161,20 @@ export async function initCommand(opts) {
   const detectedAgents = detectAgents(cwd);
   const features = detectFeatures(cwd);
 
+  let profileName = profileOrDefault(opts.profile);
   let agents;
   let optedSkills;
 
   if (interactive) {
     p.intro('agentic init');
-    const featureLine = [
-      features.frontend ? 'frontend' : null,
-      features.hasClaudeCode ? '.claude/ present' : null,
-      features.hasCodex ? '.agents/.openai/ present' : null,
-    ]
-      .filter(Boolean)
-      .join(', ') || 'none';
+    const featureLine =
+      [
+        features.frontend ? 'frontend' : null,
+        features.hasClaudeCode ? '.claude/ present' : null,
+        features.hasCodex ? '.agents/.openai/ present' : null,
+      ]
+        .filter(Boolean)
+        .join(', ') || 'none';
 
     p.note(
       `Mode: ${MODE_LABEL[detectedMode]}\n` +
@@ -151,6 +187,21 @@ export async function initCommand(opts) {
       'Detected context'
     );
 
+    const profileChoice = await p.select({
+      message: 'Project maturity profile?',
+      options: PROFILE_NAMES.map((name) => ({
+        value: name,
+        label: name,
+        hint: PROFILES[name].note,
+      })),
+      initialValue: profileName,
+    });
+    if (p.isCancel(profileChoice)) {
+      p.cancel('Cancelled.');
+      return;
+    }
+    profileName = profileChoice;
+
     const choice = await p.select({
       message: 'Install skills for which agent(s)?',
       options: [
@@ -169,14 +220,20 @@ export async function initCommand(opts) {
     }
     agents = choice;
 
-    const conditionalOptions = CONDITIONAL_SKILLS.filter((s) =>
-      s.agents.some((a) => agents.includes(a))
-    ).map((s) => ({
-      value: s.name,
-      label: s.name,
-      hint: s.autoIf(features) ? s.hintWhenAuto : s.hintWhenManual,
-    }));
-    const initialValues = pickConditionalAuto(features, agents);
+    const conditionalOptions = availableConditionalsForProfile(profileName)
+      .map(({ name, rule }) => {
+        const def = CONDITIONAL_BY_NAME[name];
+        if (!def) return null;
+        if (!def.agents.some((a) => agents.includes(a))) return null;
+        const auto = evaluateRule(rule, features, agents);
+        return {
+          value: name,
+          label: name,
+          hint: auto ? def.hintWhenAuto : def.hintWhenManual,
+        };
+      })
+      .filter(Boolean);
+    const initialValues = pickConditionalAuto(features, agents, profileName);
 
     if (conditionalOptions.length > 0) {
       const picked = await p.multiselect({
@@ -194,14 +251,17 @@ export async function initCommand(opts) {
       optedSkills = [];
     }
 
-    const totalCount = REQUIRED_SKILLS.length + optedSkills.length;
+    const universalForProfile = requiredSkillsForProfile(profileName);
+    const totalCount = universalForProfile.length + optedSkills.length;
     const optedSummary = optedSkills.length
       ? `, plus ${optedSkills.join(', ')}`
       : '';
     const confirm = await p.confirm({
-      message: `Install ${totalCount} skill${totalCount === 1 ? '' : 's'} (${REQUIRED_SKILLS.join(
-        ', '
-      )}${optedSummary}) for ${agents.map((a) => AGENT_LABEL[a]).join(' + ')}?`,
+      message: `Install ${totalCount} skill${
+        totalCount === 1 ? '' : 's'
+      } (${universalForProfile.join(', ')}${optedSummary}) for ${agents
+        .map((a) => AGENT_LABEL[a])
+        .join(' + ')}?`,
       initialValue: true,
     });
     if (p.isCancel(confirm) || !confirm) {
@@ -210,7 +270,7 @@ export async function initCommand(opts) {
     }
   } else {
     agents = resolveAgents(opts.agent, detectedAgents);
-    optedSkills = pickConditionalAuto(features, agents);
+    optedSkills = pickConditionalAuto(features, agents, profileName);
   }
 
   const confirmReplace = interactive
@@ -224,7 +284,7 @@ export async function initCommand(opts) {
   const allActions = [];
   const installedSkillSet = new Set();
   for (const agent of agents) {
-    const agentSkills = skillsForAgent(agent, optedSkills);
+    const agentSkills = skillsForAgent(agent, profileName, optedSkills);
     for (const s of agentSkills) installedSkillSet.add(s);
     const previousStates = { [agent]: loadState(cwd, agent) };
     const { actions, nextStates } = await installSkills({
@@ -236,7 +296,9 @@ export async function initCommand(opts) {
       kitVersion: pkg.version,
     });
     allActions.push(...actions);
-    saveState(cwd, agent, nextStates[agent]);
+    const next = nextStates[agent];
+    next.profile = profileName;
+    saveState(cwd, agent, next);
   }
 
   const skillDisplayOrder = [
@@ -283,9 +345,30 @@ export async function initCommand(opts) {
         : []),
       ...(optedSkills.includes('agentic-skill') ? ['/agentic-skill'] : []),
       ...(optedSkills.includes('agentic-hooks') ? ['/agentic-hooks (WORKFLOW §11)'] : []),
-    ].join(', ');
+    ]
+      .filter((line) => {
+        // Filter the universal-set entries to only those actually installed
+        // for this profile.
+        const universalNames = requiredSkillsForProfile(profileName);
+        const universalLabels = {
+          'agentic-bootstrap': '/agentic-bootstrap (AGENTS.md)',
+          'agentic-architecture': '/agentic-architecture (ARCHITECTURE.md)',
+          'agentic-adr': '/agentic-adr',
+          'agentic-spec': '/agentic-spec (doc/specs/)',
+          'agentic-task': '/agentic-task',
+          'agentic-audit': '/agentic-audit',
+          'agentic-review': '/agentic-review (WORKFLOW §10)',
+          'agentic-ground': '/agentic-ground (WORKFLOW §4 + §5)',
+          // 'agentic-philosophy' is implicit and not listed.
+        };
+        for (const [skill, label] of Object.entries(universalLabels)) {
+          if (line === label) return universalNames.includes(skill);
+        }
+        return true;
+      })
+      .join(', ');
     p.outro(
-      `Done. In ${agents
+      `Done (profile: ${profileName}). In ${agents
         .map((a) => AGENT_LABEL[a])
         .join(' or ')}: ${slashLine}. agentic-philosophy auto-loads on non-trivial work.`
     );

package/src/commands/profile.js

@@ -0,0 +1,165 @@
+import * as p from '@clack/prompts';
+import { detectAgents } from '../lib/detect.js';
+import {
+  DEFAULT_PROFILE,
+  PROFILES,
+  PROFILE_NAMES,
+  validateProfile,
+} from '../lib/profiles.js';
+import { loadState, saveState } from '../lib/state.js';
+import { updateCommand } from './update.js';
+
+const VALID_AGENTS = ['claude-code', 'codex'];
+
+const AGENT_LABEL = {
+  'claude-code': 'Claude Code',
+  codex: 'Codex',
+};
+
+function readProjectProfile(cwd) {
+  const perAgent = {};
+  for (const agent of VALID_AGENTS) {
+    const state = loadState(cwd, agent);
+    if (state) perAgent[agent] = state.profile ?? DEFAULT_PROFILE;
+  }
+  return perAgent;
+}
+
+function showProfile(cwd) {
+  const perAgent = readProjectProfile(cwd);
+  if (Object.keys(perAgent).length === 0) {
+    process.stdout.write(
+      'No agentic install detected (no .claude/agentic-state.json or .agents/agentic-state.json).\n'
+    );
+    process.stdout.write(
+      `Run \`agentic init\` to scaffold; default profile is \`${DEFAULT_PROFILE}\`.\n`
+    );
+    return;
+  }
+  for (const [agent, profile] of Object.entries(perAgent)) {
+    process.stdout.write(`${AGENT_LABEL[agent]}: ${profile}\n`);
+  }
+}
+
+function listProfiles() {
+  for (const name of PROFILE_NAMES) {
+    const def = PROFILES[name];
+    process.stdout.write(`${name}\n  ${def.note}\n`);
+    process.stdout.write(`  Universal: ${def.universal.join(', ')}\n`);
+    const conditional = Object.entries(def.conditional)
+      .filter(([, rule]) => rule !== 'blocked')
+      .map(([skill, rule]) => `${skill}=${formatRule(rule)}`)
+      .join(', ');
+    process.stdout.write(`  Conditional: ${conditional || 'none'}\n\n`);
+  }
+}
+
+function formatRule(rule) {
+  if (rule === true) return 'recommended';
+  if (rule === false) return 'opt-in';
+  if (typeof rule === 'string') return `auto-if-${rule}`;
+  return String(rule);
+}
+
+async function setProfile(cwd, name, opts) {
+  validateProfile(name);
+
+  const perAgent = readProjectProfile(cwd);
+  if (Object.keys(perAgent).length === 0) {
+    throw new Error(
+      'no agentic install detected. Run `agentic init --profile <name>` first.'
+    );
+  }
+
+  const interactive = process.stdout.isTTY && !opts.yes;
+
+  const currentProfiles = [...new Set(Object.values(perAgent))];
+  if (currentProfiles.length === 1 && currentProfiles[0] === name) {
+    process.stdout.write(`Profile already \`${name}\` for all installed agents. No change.\n`);
+    return;
+  }
+
+  if (interactive) {
+    p.intro(`agentic profile set ${name}`);
+    p.note(
+      Object.entries(perAgent)
+        .map(([agent, profile]) => `${AGENT_LABEL[agent]}: ${profile} → ${name}`)
+        .join('\n'),
+      'Profile change'
+    );
+    p.note(PROFILES[name].note, `${name} profile`);
+
+    const confirm = await p.confirm({
+      message:
+        'This may add or remove skills under the new profile. Continue? (`agentic update` runs after.)',
+      initialValue: true,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+      p.cancel('Cancelled.');
+      return;
+    }
+  }
+
+  // Write the new profile to each installed agent's state file before
+  // running update, so update reads the new profile.
+  for (const agent of Object.keys(perAgent)) {
+    const state = loadState(cwd, agent);
+    state.profile = name;
+    saveState(cwd, agent, state);
+  }
+
+  // Run the equivalent of `agentic update` so the install set matches the
+  // new profile. The update command picks profile up from the state files
+  // we just wrote.
+  await updateCommand({
+    agent: undefined,
+    yes: opts.yes,
+    dryRun: false,
+    force: false,
+  });
+
+  if (interactive) {
+    p.outro(`Profile set to \`${name}\`. Install state refreshed.`);
+  } else {
+    process.stdout.write(`Profile set to \`${name}\`. Install state refreshed.\n`);
+  }
+}
+
+export async function profileCommand(arg, opts) {
+  const cwd = process.cwd();
+
+  if (!arg) {
+    showProfile(cwd);
+    return;
+  }
+
+  if (arg === 'list') {
+    listProfiles();
+    return;
+  }
+
+  if (arg === 'show') {
+    showProfile(cwd);
+    return;
+  }
+
+  if (arg === 'set') {
+    if (!opts.name) {
+      throw new Error(
+        'profile set requires a profile name. Usage: `agentic profile set <name>`'
+      );
+    }
+    await setProfile(cwd, opts.name, opts);
+    return;
+  }
+
+  // If `arg` is not a subcommand, treat it as `set <name>` shorthand.
+  if (PROFILE_NAMES.includes(arg)) {
+    await setProfile(cwd, arg, opts);
+    return;
+  }
+
+  throw new Error(
+    `unknown subcommand "${arg}". Use \`show\`, \`list\`, or \`set <name>\` (or pass a profile name directly).`
+  );
+}

package/src/commands/update.js

@@ -5,9 +5,27 @@ import { dirname, join } from 'node:path';
 import { detectAgents, detectFeatures } from '../lib/detect.js';
 import { installSkills, removeOrphanSkills } from '../lib/install.js';
 import { loadState, saveState } from '../lib/state.js';
+import {
+  DEFAULT_PROFILE,
+  availableConditionalsForProfile,
+  profileOrDefault,
+  requiredSkillsForProfile,
+} from '../lib/profiles.js';
 import { updateRootDoc } from '../lib/rootdoc.js';
 import { CONDITIONAL_SKILLS, REQUIRED_SKILLS } from './init.js';
 
+const CONDITIONAL_BY_NAME = Object.fromEntries(
+  CONDITIONAL_SKILLS.map((s) => [s.name, s])
+);
+
+function evaluateRule(rule, features, targetAgents) {
+  if (rule === 'frontend') return features.frontend === true;
+  if (rule === 'claude-code') return targetAgents.includes('claude-code');
+  if (rule === true) return true;
+  if (rule === false) return false;
+  return false;
+}
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
   readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')
@@ -48,18 +66,24 @@ function resolveAgents(flagValue, detectedAgents, previousAgents) {
   return ['claude-code'];
 }
 
-function pickConditionalAuto(features, targetAgents) {
-  return CONDITIONAL_SKILLS.filter(
-    (s) => s.autoIf(features) && s.agents.some((a) => targetAgents.includes(a))
-  ).map((s) => s.name);
+function pickConditionalAuto(features, targetAgents, profileName) {
+  const out = [];
+  for (const { name, rule } of availableConditionalsForProfile(profileName)) {
+    const def = CONDITIONAL_BY_NAME[name];
+    if (!def) continue;
+    if (!def.agents.some((a) => targetAgents.includes(a))) continue;
+    if (evaluateRule(rule, features, targetAgents)) out.push(name);
+  }
+  return out;
 }
 
-function skillsForAgent(agent, optedSkills) {
+function skillsForAgent(agent, profileName, optedSkills) {
+  const universal = requiredSkillsForProfile(profileName);
   const conditional = optedSkills.filter((skillName) => {
-    const def = CONDITIONAL_SKILLS.find((s) => s.name === skillName);
+    const def = CONDITIONAL_BY_NAME[skillName];
     return def && def.agents.includes(agent);
   });
-  return [...REQUIRED_SKILLS, ...conditional];
+  return [...universal, ...conditional];
 }
 
 function previousAgentsFromStates(cwd) {
@@ -71,13 +95,19 @@ function previousAgentsFromStates(cwd) {
   return out;
 }
 
-function previouslyOptedConditional(previousStates, currentAgents) {
+function previouslyOptedConditional(previousStates, currentAgents, profileName) {
+  const available = new Set(
+    availableConditionalsForProfile(profileName).map((c) => c.name)
+  );
   const opted = new Set();
   for (const agent of currentAgents) {
     const prev = previousStates[agent];
     if (!prev) continue;
     for (const skill of Object.keys(prev.skills ?? {})) {
-      if (CONDITIONAL_SKILLS.some((s) => s.name === skill)) {
+      if (
+        CONDITIONAL_BY_NAME[skill] &&
+        available.has(skill)
+      ) {
         opted.add(skill);
       }
     }
@@ -85,6 +115,23 @@ function previouslyOptedConditional(previousStates, currentAgents) {
   return [...opted];
 }
 
+function profileFromStates(previousStates, currentAgents) {
+  // If multiple agents disagree on profile, surface and bail. Profile is
+  // expected to match across agents in the same project.
+  const seen = new Set();
+  for (const agent of currentAgents) {
+    const prev = previousStates[agent];
+    if (prev?.profile) seen.add(prev.profile);
+  }
+  if (seen.size === 0) return DEFAULT_PROFILE;
+  if (seen.size > 1) {
+    throw new Error(
+      `state files disagree on profile (${[...seen].join(', ')}). Run \`agentic profile set <name>\` to reconcile.`
+    );
+  }
+  return [...seen][0];
+}
+
 export async function updateCommand(opts) {
   if (opts.agent && !AGENT_FLAG_VALUES.includes(opts.agent)) {
     throw new Error(
@@ -107,8 +154,13 @@ export async function updateCommand(opts) {
     previousStates[agent] = loadState(cwd, agent);
   }
 
-  const previousOpted = previouslyOptedConditional(previousStates, agents);
-  const autoOpted = pickConditionalAuto(features, agents);
+  const profileName = profileFromStates(previousStates, agents);
+  const previousOpted = previouslyOptedConditional(
+    previousStates,
+    agents,
+    profileName
+  );
+  const autoOpted = pickConditionalAuto(features, agents, profileName);
   const defaultOpted = previousOpted.length ? previousOpted : autoOpted;
 
   let optedSkills;
@@ -120,17 +172,24 @@ export async function updateCommand(opts) {
     p.note(
       `Previous install: ${previousLine}\n` +
         `Updating for: ${agents.map((a) => AGENT_LABEL[a]).join(' + ')}\n` +
+        `Profile: ${profileName}\n` +
         `Kit version: ${pkg.version}`,
       'Update plan'
     );
 
-    const conditionalOptions = CONDITIONAL_SKILLS.filter((s) =>
-      s.agents.some((a) => agents.includes(a))
-    ).map((s) => ({
-      value: s.name,
-      label: s.name,
-      hint: s.autoIf(features) ? s.hintWhenAuto : s.hintWhenManual,
-    }));
+    const conditionalOptions = availableConditionalsForProfile(profileName)
+      .map(({ name, rule }) => {
+        const def = CONDITIONAL_BY_NAME[name];
+        if (!def) return null;
+        if (!def.agents.some((a) => agents.includes(a))) return null;
+        const auto = evaluateRule(rule, features, agents);
+        return {
+          value: name,
+          label: name,
+          hint: auto ? def.hintWhenAuto : def.hintWhenManual,
+        };
+      })
+      .filter(Boolean);
 
     if (conditionalOptions.length > 0) {
       const picked = await p.multiselect({
@@ -172,7 +231,7 @@ export async function updateCommand(opts) {
   const nextStates = {};
 
   for (const agent of agents) {
-    const agentSkills = skillsForAgent(agent, optedSkills);
+    const agentSkills = skillsForAgent(agent, profileName, optedSkills);
     for (const s of agentSkills) installedSkillSet.add(s);
 
     const orphanResult = await removeOrphanSkills({
@@ -196,7 +255,9 @@ export async function updateCommand(opts) {
       force,
     });
     allActions.push(...result.actions);
-    nextStates[agent] = result.nextStates[agent];
+    const next = result.nextStates[agent];
+    next.profile = profileName;
+    nextStates[agent] = next;
   }
 
   if (!dryRun) {

package/src/index.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { initCommand } from './commands/init.js';
 import { updateCommand } from './commands/update.js';
+import { profileCommand } from './commands/profile.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
@@ -22,6 +23,7 @@ export async function run(argv) {
     .command('init')
     .description('Install agentic skills into this project for Claude Code and/or Codex')
     .option('-a, --agent <agent>', 'install for a specific agent: claude-code | codex | both')
+    .option('-p, --profile <profile>', 'project maturity profile: poc | solo | team | mature (default: team)')
     .option('-y, --yes', 'skip confirmation prompts (non-interactive)')
     .action(initCommand);
 
@@ -34,5 +36,12 @@ export async function run(argv) {
     .option('--force', 'overwrite user-edited files on conflict (non-interactive default: no)')
     .action(updateCommand);
 
+  program
+    .command('profile [subcommand]')
+    .description('Show, list, or set the project maturity profile (poc | solo | team | mature)')
+    .option('-n, --name <name>', 'profile name when used with `set` subcommand')
+    .option('-y, --yes', 'skip confirmation prompts (non-interactive)')
+    .action(profileCommand);
+
   await program.parseAsync(argv);
 }

package/src/lib/profiles.js

@@ -0,0 +1,128 @@
+/**
+ * Project maturity profiles per ADR-0013.
+ *
+ * Each profile declares:
+ * - `universal`: skills that always install for this profile.
+ * - `conditional`: per-conditional-skill rules. `autoIf` is one of:
+ *   - a feature predicate name from detectFeatures (`'frontend'`, `'claude-code'`)
+ *   - `true` — recommended (pre-checked in TUI; auto-installed in non-interactive)
+ *   - `false` — allowed but not recommended (un-checked in TUI; not auto-installed)
+ *   - `'blocked'` — not available at this profile (omitted from TUI options)
+ * - `note`: human-readable summary shown in the profile-selection TUI and
+ *   in `agentic profile list`.
+ *
+ * Profiles are monotone supersets: poc ⊆ solo ⊆ team ⊆ mature.
+ */
+
+export const DEFAULT_PROFILE = 'team';
+
+export const PROFILE_NAMES = ['poc', 'solo', 'team', 'mature'];
+
+export const PROFILES = {
+  poc: {
+    universal: ['agentic-philosophy', 'agentic-ground', 'agentic-audit'],
+    conditional: {
+      'agentic-design': 'blocked',
+      'agentic-subagent': 'blocked',
+      'agentic-skill': 'blocked',
+      'agentic-hooks': 'blocked',
+    },
+    note: 'PoC / spike / experiment. Posture (philosophy) + research (ground) + drift (audit). No mandatory artifact-producing skills. Adds discipline you can grow into; never pre-imposes ceremony.',
+  },
+  solo: {
+    universal: [
+      'agentic-philosophy',
+      'agentic-ground',
+      'agentic-audit',
+      'agentic-bootstrap',
+      'agentic-spec',
+      'agentic-task',
+      'agentic-review',
+    ],
+    conditional: {
+      'agentic-architecture': false,
+      'agentic-adr': false,
+      'agentic-design': 'frontend',
+      'agentic-subagent': 'claude-code',
+      'agentic-skill': false,
+      'agentic-hooks': false,
+    },
+    note: 'Solo developer shipping a real product. Specs and tasks are universal; ADRs and architecture are opt-in for binding decisions only.',
+  },
+  team: {
+    universal: [
+      'agentic-bootstrap',
+      'agentic-philosophy',
+      'agentic-architecture',
+      'agentic-adr',
+      'agentic-spec',
+      'agentic-task',
+      'agentic-audit',
+      'agentic-review',
+      'agentic-ground',
+    ],
+    conditional: {
+      'agentic-design': 'frontend',
+      'agentic-subagent': 'claude-code',
+      'agentic-skill': false,
+      'agentic-hooks': false,
+    },
+    note: 'Team product. Full universal stack; conditional skills auto-detect by signal. This was the v0.7 default and is the migration target for existing installs.',
+  },
+  mature: {
+    universal: [
+      'agentic-bootstrap',
+      'agentic-philosophy',
+      'agentic-architecture',
+      'agentic-adr',
+      'agentic-spec',
+      'agentic-task',
+      'agentic-audit',
+      'agentic-review',
+      'agentic-ground',
+    ],
+    conditional: {
+      'agentic-design': 'frontend',
+      'agentic-subagent': 'claude-code',
+      'agentic-skill': false,
+      'agentic-hooks': true,
+    },
+    note: 'Mature / regulated product. Recommends agentic-hooks alongside the team stack for deterministic gates per WORKFLOW §11. Future evals + spike skills land here when shipped.',
+  },
+};
+
+export function validateProfile(name) {
+  if (!PROFILE_NAMES.includes(name)) {
+    throw new Error(
+      `unknown profile "${name}". Valid: ${PROFILE_NAMES.join(', ')}`
+    );
+  }
+  return name;
+}
+
+export function profileOrDefault(name) {
+  if (!name) return DEFAULT_PROFILE;
+  return validateProfile(name);
+}
+
+export function requiredSkillsForProfile(name) {
+  return [...PROFILES[validateProfile(name)].universal];
+}
+
+export function conditionalRulesForProfile(name) {
+  return { ...PROFILES[validateProfile(name)].conditional };
+}
+
+/**
+ * Returns the conditional skills available at this profile, with their
+ * effective `autoIf` posture. Skipped (blocked) skills are omitted.
+ */
+export function availableConditionalsForProfile(profileName) {
+  const rules = conditionalRulesForProfile(profileName);
+  const out = [];
+  for (const [skill, rule] of Object.entries(rules)) {
+    if (rule === 'blocked') continue;
+    out.push({ name: skill, rule });
+  }
+  return out;
+}

package/src/lib/state.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { DEFAULT_PROFILE, validateProfile } from './profiles.js';
 
 export const SCHEMA_VERSION = 1;
 export const STATE_FILE = 'agentic-state.json';
@@ -15,11 +16,12 @@ export function statePath(cwd, agent) {
   return join(cwd, dir, STATE_FILE);
 }
 
-export function emptyState(agent, kitVersion) {
+export function emptyState(agent, kitVersion, profile = DEFAULT_PROFILE) {
   return {
     schemaVersion: SCHEMA_VERSION,
     kitVersion,
     agent,
+    profile: validateProfile(profile),
     skills: {},
   };
 }
@@ -46,10 +48,23 @@ export function loadState(cwd, agent) {
       `state at ${path} declares agent "${raw.agent}" but expected "${agent}"`
     );
   }
+  // `profile` is optional and forward-compatible. Pre-v0.8 state files have
+  // no profile field; default to `team` per ADR-0013 (the v0.7 install set is
+  // byte-identical to the team profile).
+  let profile = DEFAULT_PROFILE;
+  if (raw.profile) {
+    try {
+      profile = validateProfile(raw.profile);
+    } catch (err) {
+      throw new Error(`state at ${path}: ${err.message}`);
+    }
+  }
+
   return {
     schemaVersion: raw.schemaVersion,
     kitVersion: raw.kitVersion ?? null,
     agent,
+    profile,
     skills: raw.skills ?? {},
   };
 }
@@ -75,6 +90,7 @@ function orderState(state) {
     schemaVersion: state.schemaVersion,
     kitVersion: state.kitVersion,
     agent: state.agent,
+    profile: state.profile ?? DEFAULT_PROFILE,
     skills,
   };
 }

package/src/skills/claude-code/agentic-adr/SKILL.md

@@ -24,6 +24,10 @@ Use the template below. Fill `Context`, `Decision`, `Consequences`, and `Alterna
 * `Consequences` lists positive and negative; do not balance for the sake of balance.
 * `Alternatives Considered` lists each rejected option with a one-line reason.
 
+## Interview UX
+
+When the host exposes `AskUserQuestion`, use it for multi-choice prompts (`Status: proposed / accepted / deprecated / superseded`, decider role selection, alternative-option ranking) and for confirmation gates with non-trivial branching. Inline text questions are the fallback only when the host lacks a structured-prompt primitive (Codex). One card per multi-choice gate beats chained text questions.
+
 ## Step 4 — Write the file
 
 Path: `doc/adr/<NNNN>-<short-slug>.md`. Slug: kebab-case, ≤6 words, derived from the decision title. Status: `proposed`. Date: today, ISO format. Deciders: ask the user.

package/src/skills/claude-code/agentic-architecture/SKILL.md

@@ -42,6 +42,8 @@ Print to the user:
 
 One question per gap.
 
+When the host exposes Plan Mode, the agent may render the proposed `ARCHITECTURE.md` body inside the plan for user approval before write. Plan Mode is opt-in — skip for incremental edits where the user already saw the prior content.
+
 ## Step 4 — Write the file
 
 On user confirmation, write `ARCHITECTURE.md` at the repo root. Cut every line that does not lock a binding pattern. At the end of the response, list any decision that should become an ADR — flag, do not write the ADR yet (use the `agentic-adr` skill for that).

package/src/skills/claude-code/agentic-bootstrap/SKILL.md

@@ -44,6 +44,8 @@ Print to the user:
 
 One question per gap. Skip everything filled confidently. Do **not** ask philosophical questions ("is this doc for agents or humans?", "what is the most important quality bar?") — those are decisions, not interview material.
 
+When the host exposes Plan Mode, the agent may render the proposed `AGENTS.md` body inside the plan (the user reviews and approves before write) instead of writing-then-presenting. Plan Mode is opt-in — skip for incremental edits where the user already saw the prior content.
+
 ## Step 4 — Write the file
 
 On user confirmation, write `AGENTS.md` at the repo root. Cut every line that does not change agent behavior. No "External Resources" section (URLs are derivable from `git remote` and the manifest). No appended Universal Agent Behavior block. No marketing prose.

package/src/skills/claude-code/agentic-ground/SKILL.md

@@ -55,6 +55,8 @@ Before handing off to implementation, report a soft verdict against four checks:
 
 If any check fails, surface the gap to the user and ask before proceeding rather than blocking. The user retains the authority to skip; the discipline is in surfacing, not in enforcement.
 
+When the host exposes `AskUserQuestion`, render the checkpoint as a structured multi-choice card listing the six checks with their yes/no/n.a. status plus a final `proceed / pause for more research` selector — instead of dropping the verdict as plain text. Falls back to numbered text on hosts without the primitive (Codex).
+
 ## Output contract
 
 A single message structured as:

package/src/skills/claude-code/agentic-review/SKILL.md

@@ -18,6 +18,8 @@ Confirm what to review. Default scopes, in priority order:
 
 If no diff exists, stop and tell the user — there's nothing to review.
 
+When the host exposes `AskUserQuestion`, use it at Step 0 to confirm the review scope as a multi-choice card (`branch vs main / PR#NN / commit-sha / working-tree`) instead of asking inline text. Falls back to numbered text on hosts without the primitive (Codex).
+
 ## Step 1 — Assemble the handoff
 
 The reviewer subagent will get **only** what you assemble here. No conversation history, no prior context.

package/src/skills/claude-code/agentic-spec/SKILL.md

@@ -32,6 +32,10 @@ Ask one question per missing field, in this order. Skip the philosophical questi
 
 Status starts at `draft`. Created: today, ISO format. Owner: ask. Do **not** invent values — when the user does not know, leave `<TODO>` and ask.
 
+## Interview UX
+
+When the host exposes `AskUserQuestion`, use it for multi-choice prompts (`Status: draft / accepted / shipped`, owner selection from team members, scope-vs-multiple-features confirmation) and for confirmation gates with non-trivial branching. Inline text questions are an acceptable fallback only when the host lacks a structured-prompt primitive (Codex). One question per gate; do not chain three text questions when one `AskUserQuestion` card lists the options.
+
 ## Step 4 — Write the file
 
 Path: `doc/specs/<NNNN>-<short-slug>.md`. Use the template below.

package/src/skills/claude-code/agentic-task/SKILL.md

@@ -27,6 +27,10 @@ Status starts at `proposed`. Created: today, ISO format. Notes: empty (filled du
 
 **Do not invent values.** When the user does not know something, leave `<TODO>` and ask. Stop after writing the file — do not start work.
 
+## Interview UX
+
+When the host exposes `AskUserQuestion`, use it for multi-choice prompts (status, owner selection, Spec-ref pick from existing `doc/specs/`) and for confirmation gates with non-trivial branching. Inline text questions are the fallback only when the host lacks a structured-prompt primitive (Codex). Single card per multi-choice gate beats chained text questions.
+
 ## Step 3 — Write the file
 
 Path: `doc/tasks/<NNNN>-<short-slug>.md`. Use the template below.