@alexandrealvaro/agentic 0.6.0-beta.1 → 0.8.0-beta.1

package/README.md

@@ -40,11 +40,41 @@ Two categories ([ADR-0007](doc/adr/0007-workflow-operational-skills.md)) and two
 | `agentic-design` | spec-driven | auto if frontend detected | Bootstrap `DESIGN.md` from existing tokens (Figma, tailwind.config, tokens.json, CSS custom props) | `/agentic-design` |
 | `agentic-subagent` | spec-driven | auto if installing for Claude Code | Drafts `.claude/agents/<name>.md` (Claude Code only — Codex has no subagent primitive) | `/agentic-subagent` |
 | `agentic-skill` | spec-driven | opt-in only | Drafts a new Claude Code or Codex skill at the appropriate path | `/agentic-skill` |
+| `agentic-hooks` | workflow-operational | opt-in only | Scaffolds deterministic quality gates per WORKFLOW §11 (pre-commit + pre-push); detects stack and recommends a runner (Husky / lefthook / pre-commit / native) | `/agentic-hooks` |
 
 A short TUI shows the detected mode, agent, and feature signals (frontend / `.claude/` / `.agents/` presence) and lets you toggle the conditional skills. Non-interactive flags: `--agent claude-code | codex | both`, `--yes` to skip confirmations — auto-checked conditionals (e.g., `agentic-design` if the project has React) install; `agentic-skill` stays opt-in. Re-running on an installed project is idempotent — unchanged files report `·`, divergent ones prompt to replace.
 
 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:
@@ -118,7 +148,7 @@ The kit ships nine universal skills plus three conditional ones — twelve discr
 2. Decide whether the answer becomes a spec (`/agentic-spec`) or a one-off task (`/agentic-task`).
 3. Continue from step 6 of the greenfield flow.
 
-The kit's discipline scales with the project's maturity. A solo PoC may legitimately skip `/agentic-spec` and `/agentic-adr` (the WORKFLOW §1 prune principle applies — don't add an artifact that wouldn't change agent behavior). A team product running on this kit is expected to use the full sequence; CI + hooks (deferred — see Task 0013) will eventually enforce the gates that today are advisory.
+The kit's discipline scales with the project's maturity. A solo PoC may legitimately skip `/agentic-spec` and `/agentic-adr` (the WORKFLOW §1 prune principle applies — don't add an artifact that wouldn't change agent behavior). A team product running on this kit is expected to use the full sequence and additionally invoke `/agentic-hooks` once to scaffold the deterministic gates per WORKFLOW §11 (pre-commit lint / format / secret-scan; pre-push build / unit / integration). Project maturity profiles that automate the recommendation by stack are deferred — see the next planned release.
 
 ## Manual prompts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexandrealvaro/agentic",
-  "version": "0.6.0-beta.1",
+  "version": "0.8.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 = [
   {
@@ -83,8 +86,19 @@ export const CONDITIONAL_SKILLS = [
     hintWhenAuto: 'opt-in',
     hintWhenManual: 'opt-in (rarely needed)',
   },
+  {
+    name: 'agentic-hooks',
+    autoIf: () => false,
+    agents: ['claude-code', 'codex'],
+    hintWhenAuto: 'opt-in',
+    hintWhenManual: 'WORKFLOW §11 hooks scaffolder (pre-commit, pre-push)',
+  },
 ];
 
+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];
@@ -92,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) {
@@ -113,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;
 
@@ -120,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` +
@@ -144,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: [
@@ -162,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({
@@ -187,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) {
@@ -203,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
@@ -217,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({
@@ -229,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 = [
@@ -275,9 +344,31 @@ export async function initCommand(opts) {
         ? ['/agentic-subagent']
         : []),
       ...(optedSkills.includes('agentic-skill') ? ['/agentic-skill'] : []),
-    ].join(', ');
+      ...(optedSkills.includes('agentic-hooks') ? ['/agentic-hooks (WORKFLOW §11)'] : []),
+    ]
+      .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/rootdoc.js

@@ -29,6 +29,8 @@ export const SKILL_DESCRIPTIONS = {
   'agentic-design': 'Bootstrap `DESIGN.md` from existing tokens (frontend projects).',
   'agentic-subagent': 'Draft a new Claude Code subagent at `.claude/agents/<name>.md`.',
   'agentic-skill': 'Draft a new Claude Code or Codex skill at the appropriate path.',
+  'agentic-hooks':
+    'Scaffold deterministic quality gates per WORKFLOW §11 — pre-commit + pre-push, runner detected from stack signals.',
 };
 
 /**

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-hooks/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: agentic-hooks
+description: Scaffold deterministic quality gates per WORKFLOW.md §11 — pre-commit (lint, format, secret-scan), pre-push (build, unit, integration). Detects the project's stack and recommends a hook runner (Husky / lefthook / pre-commit / native), scaffolds the runner config, and updates AGENTS.md Quality Gates. Use when the user wants to wire hooks, configure pre-commit / pre-push, set up quality gates, prevent --no-verify bypass, or close the WORKFLOW §11 advisory-vs-deterministic gap. Opt-in skill; not auto-installed in the universal set.
+allowed-tools: Read, Write, Glob, Bash
+---
+
+# /agentic-hooks
+
+Scaffolds the deterministic gates `WORKFLOW.md` §11 names. The skill writes config files for a hook runner and updates `AGENTS.md` Quality Gates; it does not execute install scripts. The user is responsible for the runner's one-time bootstrap (e.g., `npx husky init`, `lefthook install`, `pre-commit install`) — the skill says exactly which command to run.
+
+## Step 0 — Confirm the gates the user wants
+
+`WORKFLOW.md` §11 names two tiers:
+
+* **Pre-commit (fast):** lint, format, secret-scan. Runs on every commit. Slow pre-commits push devs to `--no-verify`; keep it under ~5s.
+* **Pre-push (thorough):** build, unit tests, integration tests. Runs on every push. Acceptable to be slow; the cost is paid less often than commit.
+
+Confirm both tiers are in scope for this project. If the user wants only one tier, scaffold only that tier — do not add gates the user did not ask for.
+
+Visual / E2E for UI projects (Cypress, Playwright, Claude in Chrome) are mentioned by §11 but live in CI, not pre-push. Out of scope for this skill.
+
+## Step 1 — Detect the runner
+
+Read the repo signals in this order:
+
+1. **Existing runner.** `.husky/` → Husky present. `lefthook.yml` or `.lefthook.yml` → lefthook present. `.pre-commit-config.yaml` → pre-commit present. `.git/hooks/` with non-sample scripts → native hooks present.
+2. **Stack signals (if no runner present).** `package.json` → Node-rooted; recommend Husky (most common in Node ecosystem) or lefthook (cross-language fit). `pyproject.toml` → Python-rooted; recommend pre-commit. `go.mod` → Go-rooted; recommend lefthook. `Cargo.toml` → Rust-rooted; recommend lefthook. Multiple stacks → recommend lefthook (cross-language by default).
+3. **No signals.** Recommend native `.git/hooks/` only as fallback. Warn the user that native hooks are not portable across clones (every contributor has to run a setup script).
+
+If multiple runners are present, surface the conflict and ask the user before scaffolding. Never silently pick.
+
+## Step 2 — Recommend the per-stack commands
+
+For the chosen runner, propose the per-tier command set:
+
+* **Node (`package.json` present):** lint = `npm run lint` (fall back to `npx eslint .` if no `lint` script); format check = `npm run format:check` (fall back to `npx prettier --check .`); secret-scan = `gitleaks detect --no-banner` (cite the install instruction); build = `npm run build` (skip if no script); test = `npm test`.
+* **Python (`pyproject.toml` present):** lint = `ruff check .`; format check = `ruff format --check .` or `black --check .`; secret-scan = `gitleaks detect --no-banner`; test = `pytest -q`.
+* **Go (`go.mod` present):** lint = `golangci-lint run`; format check = `gofmt -d .`; secret-scan = `gitleaks detect --no-banner`; build = `go build ./...`; test = `go test ./...`.
+* **Rust (`Cargo.toml` present):** lint = `cargo clippy -- -D warnings`; format check = `cargo fmt --check`; secret-scan = `gitleaks detect --no-banner`; build = `cargo build`; test = `cargo test`.
+* **Mixed / other:** ask the user for the per-tier command list. Do not invent.
+
+Offer to swap any default. Confirm before writing.
+
+## Step 3 — Scaffold the runner config
+
+Write the runner-specific config file. Below are the canonical shapes; adapt to the user's tier choices.
+
+**Husky** — `.husky/pre-commit` and `.husky/pre-push` (shell scripts). Plus a `prepare` script in `package.json` (`"prepare": "husky"`). User runs `npm install` once to bootstrap.
+
+**lefthook** — `lefthook.yml` at the repo root with `pre-commit` and `pre-push` commands keyed by stage. User runs `lefthook install` once.
+
+**pre-commit (pre-commit.com)** — `.pre-commit-config.yaml` referencing the canonical hooks for the stack (e.g., `pre-commit/mirrors-eslint`, `psf/black`, `astral-sh/ruff-pre-commit`). User runs `pre-commit install` and `pre-commit install --hook-type pre-push`.
+
+**Native `.git/hooks/`** — `.git/hooks/pre-commit` and `.git/hooks/pre-push` plus a `setup-hooks.sh` script the user runs after every clone (since `.git/` is not committed). Document the setup-script invocation in `AGENTS.md`.
+
+## Step 4 — Update `AGENTS.md` Quality Gates section
+
+Append (or refresh, if a Quality Gates section already exists) the following content:
+
+```
+## Quality Gates
+
+Deterministic enforcement — agent cannot skip.
+
+- Pre-commit hook (fast): <stack-specific lint, format, secret-scan commands>
+- Pre-push hook (thorough): <stack-specific build, unit, integration commands>
+- Hook runner: <Husky | lefthook | pre-commit | native>; config at <path>
+- Bootstrap: <one-line setup command>
+- CI blocks on: <list — skip if CI not yet wired>
+- Never bypass: no `--no-verify`, no skipped hooks, no deleted failing tests. WORKFLOW §11 is binding.
+```
+
+Honor the existing managed-skills / managed-quality-gates markers if `agentic-bootstrap` already wrote a Quality Gates section. The skill refreshes the section in place; user content outside the markers is preserved.
+
+## Step 5 — Tell the user what to run
+
+After writing the config, output exactly the bootstrap command the user must run (e.g., `npm install` for Husky, `lefthook install` for lefthook, `pre-commit install` for pre-commit). The skill does not execute the bootstrap — that is the user's call.
+
+If the user is wiring CI alongside hooks (GitHub Actions / GitLab CI / Circle), point them at the existing `.github/workflows/`, `.gitlab-ci.yml`, or `.circleci/` directory. CI scaffolding is a separate skill's responsibility (deferred — not this one).
+
+## Output contract
+
+Filesystem changes:
+
+- The runner's config file (e.g., `.husky/pre-commit`, `lefthook.yml`, `.pre-commit-config.yaml`).
+- An updated `AGENTS.md` Quality Gates section (or appended if absent), naming the runner, the gates wired, the bootstrap command, and the no-bypass policy.
+- For the native-hooks fallback only: a `setup-hooks.sh` script the user runs after every clone.
+
+The skill does not execute the runner's install command. The skill does not write CI config. The skill does not configure agent-side hooks (`.claude/settings.json` `Stop` / `PreToolUse` / `PostToolUse`) — that is a different surface; future ADR may cover it.
+
+A narrative document, so the documentation discipline rules apply at write time:
+
+- No emoji anywhere in the scaffolded config or in the AGENTS.md update.
+- No version stamps or DRAFT markers.
+- The Quality Gates section opens with the operational rule (gates are deterministic) before listing the gates themselves.
+- One scope: Quality Gates. Do not duplicate ARCHITECTURE.md or ADR rationale here.
+- No commented-out scripts. No orphan TODO / FIXME — every deferred command references a tracked task or GitHub Issue.

package/src/skills/codex/agentic-hooks/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: agentic-hooks
+description: Scaffold deterministic quality gates per WORKFLOW.md §11 — pre-commit (lint, format, secret-scan), pre-push (build, unit, integration). Detects the project's stack and recommends a hook runner (Husky / lefthook / pre-commit / native), scaffolds the runner config, and updates AGENTS.md Quality Gates. Use when the user wants to wire hooks, configure pre-commit / pre-push, set up quality gates, prevent --no-verify bypass, or close the WORKFLOW §11 advisory-vs-deterministic gap. Opt-in skill; not auto-installed.
+---
+
+<background_information>
+Scaffolds the deterministic gates `WORKFLOW.md` §11 names. The skill writes config files for a hook runner and updates `AGENTS.md` Quality Gates; it does not execute install scripts. The user runs the runner's one-time bootstrap (`npx husky init`, `lefthook install`, `pre-commit install`) — the skill names the exact command.
+
+Codex auto-trigger on description keywords is less mature than Claude Code's. If auto-invocation does not fire when the user asks about hooks, pre-commit, or quality gates, invoke the skill manually.
+</background_information>
+
+<instructions>
+Step 0 — confirm the gates the user wants. WORKFLOW §11 names two tiers:
+- Pre-commit (fast): lint, format, secret-scan. Runs on every commit. Keep under ~5s; slow pre-commits push devs to `--no-verify`.
+- Pre-push (thorough): build, unit tests, integration tests. Runs on every push. Acceptable to be slow.
+
+Confirm both tiers are in scope. If the user wants only one, scaffold only that tier.
+
+Visual / E2E for UI projects (Cypress, Playwright) live in CI, not pre-push. Out of scope.
+
+Step 1 — detect the runner. Read repo signals in this order:
+1. Existing runner. `.husky/` → Husky. `lefthook.yml` or `.lefthook.yml` → lefthook. `.pre-commit-config.yaml` → pre-commit. `.git/hooks/` with non-sample scripts → native hooks.
+2. Stack signals (if no runner present). `package.json` → recommend Husky or lefthook. `pyproject.toml` → recommend pre-commit. `go.mod` → recommend lefthook. `Cargo.toml` → recommend lefthook. Multiple stacks → recommend lefthook (cross-language by default).
+3. No signals. Recommend native `.git/hooks/` only as fallback. Warn the user that native hooks are not portable across clones.
+
+If multiple runners are present, surface the conflict and ask the user before scaffolding. Never silently pick.
+
+Step 2 — recommend the per-stack commands:
+- Node: lint = `npm run lint` or `npx eslint .`; format check = `npm run format:check` or `npx prettier --check .`; secret-scan = `gitleaks detect --no-banner`; build = `npm run build` (skip if no script); test = `npm test`.
+- Python: lint = `ruff check .`; format check = `ruff format --check .` or `black --check .`; secret-scan = `gitleaks detect --no-banner`; test = `pytest -q`.
+- Go: lint = `golangci-lint run`; format check = `gofmt -d .`; secret-scan = `gitleaks detect --no-banner`; build = `go build ./...`; test = `go test ./...`.
+- Rust: lint = `cargo clippy -- -D warnings`; format check = `cargo fmt --check`; secret-scan = `gitleaks detect --no-banner`; build = `cargo build`; test = `cargo test`.
+- Mixed / other: ask for the per-tier command list. Do not invent.
+
+Offer to swap any default. Confirm before writing.
+
+Step 3 — scaffold the runner config. Write the runner-specific config file:
+- Husky: `.husky/pre-commit` and `.husky/pre-push` (shell scripts) + `"prepare": "husky"` in `package.json`. Bootstrap: `npm install`.
+- lefthook: `lefthook.yml` at the repo root with `pre-commit` and `pre-push` commands keyed by stage. Bootstrap: `lefthook install`.
+- pre-commit: `.pre-commit-config.yaml` with stack-specific hook references. Bootstrap: `pre-commit install` and `pre-commit install --hook-type pre-push`.
+- Native: `.git/hooks/pre-commit` and `.git/hooks/pre-push` + a `setup-hooks.sh` script the user runs after every clone (since `.git/` is not committed).
+
+Step 4 — update `AGENTS.md` Quality Gates. Append or refresh the section with: pre-commit gate list, pre-push gate list, runner name + config path, bootstrap command, CI status if known, no-bypass policy. Honor existing managed markers if `agentic-bootstrap` already wrote Quality Gates.
+
+Step 5 — tell the user the bootstrap command. Output the exact one-line command the user runs. The skill does not execute it.
+</instructions>
+
+<output_contract>
+Filesystem changes:
+- The runner's config file (`.husky/pre-commit`, `lefthook.yml`, `.pre-commit-config.yaml`, or `.git/hooks/`).
+- An updated `AGENTS.md` Quality Gates section.
+- For native-hooks fallback: a `setup-hooks.sh` script.
+
+The skill does not execute the runner's install command. The skill does not write CI config. The skill does not configure agent-side hooks (`.claude/settings.json`) — different surface, deferred.
+
+Documentation discipline rules apply at write time:
+- No emoji anywhere in scaffolded config or AGENTS.md update.
+- No version stamps or DRAFT markers.
+- Quality Gates section opens with the operational rule (gates are deterministic) before listing the gates.
+- One scope: Quality Gates. No duplication of ARCHITECTURE.md or ADR rationale.
+- No commented-out scripts. No orphan TODO / FIXME.
+</output_contract>

package/src/skills/codex/agentic-hooks/agents/openai.yaml

@@ -0,0 +1,5 @@
+interface:
+  display_name: agentic-hooks
+  short_description: Scaffold deterministic quality gates per WORKFLOW §11 (pre-commit / pre-push). Detect-then-recommend Husky / lefthook / pre-commit / native; never silently pick.
+policy:
+  allow_implicit_invocation: false