@antomanc/aginit 0.1.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@antomanc/aginit",
-  "version": "0.1.0",
-  "description": "Minimal, modular AI-first project bootstrapper for T3 Code, Antigravity, and Codex",
+  "version": "0.3.0",
+  "description": "Set up a new or existing project for AI coding agents in one command: AGENTS.md, Matt Pocock skills, Graft codebase graph, Vitest/Playwright. Orchestrates upstream tools, idempotent.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,10 +19,11 @@
     "src",
     "bin",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
   ],
-  "author": "Antonio Mancuso <an.manc25@gmail.com>",
+  "author": "Antonio Mancini <an.manc25@gmail.com>",
   "homepage": "https://github.com/antomanc/aginit#readme",
   "bugs": {
     "url": "https://github.com/antomanc/aginit/issues"
@@ -36,25 +37,31 @@
   },
   "keywords": [
     "ai",
-    "agents",
-    "antigravity",
+    "ai-agents",
+    "coding-agents",
+    "agents-md",
+    "agent-skills",
     "codex",
-    "t3-code",
-    "skills",
+    "antigravity",
     "graft",
+    "scaffolder",
     "bootstrap",
-    "scaffolder"
+    "project-template",
+    "developer-tools",
+    "cli",
+    "vitest",
+    "playwright"
   ],
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "commander": "^12.1.0",
+    "commander": "^15.0.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@types/node": "^22.8.0",
-    "tsx": "^4.19.2",
-    "typescript": "^5.6.3",
-    "vitest": "^4.1.11"
+    "@types/node": "^22.20.5",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
   },
   "license": "MIT",
   "engines": {
@@ -64,8 +71,9 @@
     "build": "tsc",
     "watch": "tsc --watch",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "check": "pnpm typecheck && pnpm test && pnpm build && pnpm audit",
+    "check:skills": "node scripts/check-skill-drift.mjs",
     "smoke": "node scripts/smoke-test.mjs"
   }
 }

package/src/adapters/agent-browser.ts

@@ -0,0 +1,162 @@
+import path from 'node:path';
+import { fileExists, readTextFile } from '../utils/fs.js';
+import { commandExists, runExecutable } from '../utils/shell.js';
+import { logger } from '../utils/logger.js';
+import { SkillSourceConfig } from '../config/schema.js';
+
+const AGENT_BROWSER_SKILL = 'agent-browser';
+const AGENT_BROWSER_CLI = 'agent-browser';
+const AGENT_BROWSER_PACKAGE = 'vercel-labs/agent-browser';
+
+/**
+ * Whether a configured skill source will install the agent-browser skill stub
+ * whose instructions assume the `agent-browser` CLI exists.
+ */
+export function agentBrowserConfigured(sources: SkillSourceConfig[]): boolean {
+  return sources.some(
+    (source) =>
+      source.skills.includes(AGENT_BROWSER_SKILL) ||
+      (source.package === AGENT_BROWSER_PACKAGE &&
+        (source.skills.length === 0 || source.skills.includes('*')))
+  );
+}
+
+/** Whether the agent-browser skill stub is already on disk. */
+export function agentBrowserStubInstalled(targetDir: string): boolean {
+  return fileExists(path.join(targetDir, '.agents', 'skills', AGENT_BROWSER_SKILL, 'SKILL.md'));
+}
+
+export interface UsernsRestriction {
+  sysctl: string;
+  value: string;
+  fixValue: string;
+}
+
+/**
+ * Detect the Linux sysctls that block Chrome's sandbox when set to their
+ * restrictive value: Chrome's renderer sandbox runs on unprivileged user
+ * namespaces, so agent-browser launches die with "No usable sandbox!".
+ *
+ * Returns null when the kernel does not expose the knobs (other distros,
+ * macOS, Windows) or none of them is restrictive.
+ */
+export function findUsernsRestriction(procRoot = '/proc'): UsernsRestriction | null {
+  const knobs: Array<[sysctl: string, blockingValue: string, fixValue: string]> = [
+    ['kernel.apparmor_restrict_unprivileged_userns', '1', '0'],
+    ['kernel.unprivileged_userns_clone', '0', '1']
+  ];
+  for (const [sysctl, blockingValue, fixValue] of knobs) {
+    const raw = readTextFile(path.join(procRoot, 'sys', ...sysctl.split('.')));
+    if (raw !== null && raw.trim() === blockingValue) {
+      return { sysctl, value: raw.trim(), fixValue };
+    }
+  }
+  return null;
+}
+
+export interface AgentBrowserSetupOptions {
+  dryRun?: boolean;
+  silent?: boolean;
+  /** Working directory for the provisioning commands (defaults to cwd). */
+  cwd?: string;
+  /** Root of the proc filesystem; overridable for tests. */
+  procRoot?: string;
+}
+
+/**
+ * Provision the runtime the agent-browser skill stub depends on: the globally
+ * installed CLI (`npm i -g agent-browser`, matching the skill's own install
+ * line — npm ships with Node and works regardless of the project's package
+ * manager) and its browser binaries (`agent-browser install`, idempotent).
+ *
+ * A blocked Chrome sandbox is reported as a warning only: it needs a system
+ * change aginit must not make on the user's behalf. Returns false when the
+ * CLI or the browser binaries could not be provisioned.
+ */
+export async function setupAgentBrowser(options: AgentBrowserSetupOptions = {}): Promise<boolean> {
+  const { dryRun = false, silent = false, cwd = process.cwd(), procRoot = '/proc' } = options;
+
+  const cliPresent = await commandExists('agent-browser');
+  if (!cliPresent) {
+    if (!silent) logger.dim('Installing agent-browser CLI globally (npm -g)...');
+    const cli = await runExecutable('npm', ['install', '-g', AGENT_BROWSER_SKILL], {
+      cwd,
+      dryRun,
+      silent: true,
+      timeout: 600_000
+    });
+    if (!cli.ok && !dryRun) {
+      if (!silent) {
+        logger.warn(`Failed installing agent-browser CLI: ${cli.stderr || cli.stdout}`);
+        logger.dim('  Install it manually: npm i -g agent-browser && agent-browser install');
+      }
+      return false;
+    }
+  }
+
+  if (!silent) logger.dim('Ensuring agent-browser browser binaries...');
+  const browser = await runExecutable(AGENT_BROWSER_CLI, ['install'], {
+    cwd,
+    dryRun,
+    silent: true,
+    timeout: 600_000
+  });
+  if (!browser.ok && !dryRun) {
+    if (!silent) {
+      logger.warn(`Failed downloading agent-browser browsers: ${browser.stderr || browser.stdout}`);
+      logger.dim('  Retry manually: agent-browser install');
+    }
+    return false;
+  }
+
+  const restriction = findUsernsRestriction(procRoot);
+  if (restriction && !silent) {
+    logger.warn(
+      `Chrome's sandbox is blocked: ${restriction.sysctl}=${restriction.value} restricts unprivileged user namespaces, so agent-browser launches fail with "No usable sandbox!".`
+    );
+    logger.dim(
+      `  → Fix (machine-wide): echo '${restriction.sysctl}=${restriction.fixValue}' | sudo tee /etc/sysctl.d/99-agent-browser-userns.conf && sudo sysctl --system`
+    );
+    logger.dim(
+      '  → Narrower option: pass --args "--no-sandbox" to agent-browser for that launch (Chrome sandbox disabled for that session)'
+    );
+  }
+  return true;
+}
+
+export interface AgentBrowserDiagnostic {
+  message: string;
+  fix?: string;
+}
+
+/**
+ * Run upstream's own diagnostics (`agent-browser doctor --quick --offline
+ * --json`) and return the failing checks, so aginit reports browser health
+ * instead of reimplementing it. Returns null when the report cannot be
+ * parsed (older CLI, unexpected output) — callers should then skip the check
+ * rather than guess.
+ */
+export async function runAgentBrowserDiagnostics(): Promise<AgentBrowserDiagnostic[] | null> {
+  const res = await runExecutable(
+    AGENT_BROWSER_CLI,
+    ['doctor', '--quick', '--offline', '--json'],
+    {
+      silent: true,
+      timeout: 60_000
+    }
+  );
+  try {
+    const parsed = JSON.parse(res.stdout) as {
+      checks?: Array<{ status?: string; message?: string; fix?: string }>;
+    };
+    if (!Array.isArray(parsed.checks)) return null;
+    return parsed.checks
+      .filter((check) => check?.status === 'fail')
+      .map((check) => ({
+        message: String(check?.message || 'check failed'),
+        ...(check?.fix ? { fix: String(check.fix) } : {})
+      }));
+  } catch {
+    return null;
+  }
+}

package/src/adapters/agents-md.ts

@@ -31,18 +31,51 @@ export function generateAgentsMarkdown(
     testE2E = `- Test (E2E / Browser): \`${pmAdapter.runCmd('test:e2e')}\``;
   }
 
-  const selectedSkills = config.skills.sources.flatMap((source) => source.skills);
-  const engineering = selectedSkills.filter((skill) =>
-    ['tdd', 'code-review', 'diagnosing-bugs'].includes(skill)
-  );
+  // A source with an empty skill list (or `*`) installs every skill it ships.
+  const skillInstalled = (skill: string) =>
+    config.skills.sources.some(
+      (source) =>
+        source.skills.length === 0 || source.skills.includes('*') || source.skills.includes(skill)
+    );
+  const mattSkills = (() => {
+    const source = config.skills.sources.find((s) => s.package === 'mattpocock/skills');
+    if (!source) return [];
+    return source.skills.length ? source.skills : ['*'];
+  })();
+  const hasSkills = config.skills.sources.length > 0;
+
+  const specSkillNames = ['to-spec', 'to-tickets', 'implement-spec'];
+  let engineeringCapability = '';
+  if (mattSkills.includes('*')) {
+    engineeringCapability =
+      '- **Engineering**: the full Matt Pocock skill set installed in `.agents/skills/` — start with `ask-matt` to route to the right one.';
+  } else if (mattSkills.length) {
+    const engineering = mattSkills.filter((skill) => !specSkillNames.includes(skill));
+    if (engineering.length) {
+      engineeringCapability = `- **Engineering**: ${engineering.map((skill) => '`' + skill + '`').join(', ')}`;
+    }
+  }
+
+  let proseCapability = '';
+  if (skillInstalled('humanizer')) {
+    proseCapability =
+      '- **Prose & Copy**: Use `humanizer` skill to eliminate AI writing tells and refine documentation.';
+  }
+
+  let simplicityCapability = '';
+  if (skillInstalled('ponytail')) {
+    simplicityCapability =
+      '- **Simplicity**: Use `ponytail` skill for the smallest complete change and to cut over-engineering.';
+  }
+
   let uiCapability = '';
-  if (isWeb && selectedSkills.includes('impeccable')) {
+  if (isWeb && skillInstalled('impeccable')) {
     uiCapability =
       '- **UI & Design**: Use `impeccable` skill for frontend polish, design critique, and token craft.';
   }
 
   let browserCapability = '';
-  if (hasVisualAgent && selectedSkills.includes('agent-browser')) {
+  if (hasVisualAgent && skillInstalled('agent-browser')) {
     browserCapability =
       '- **Browser Verification**: Use `agent-browser` skill for interactive inspection and visual QA.';
   }
@@ -53,12 +86,11 @@ export function generateAgentsMarkdown(
       '- **Codebase Graph**: Use `graft ask "<query>" --source` or `graft map` for orientation before raw grep.';
   }
 
-  let specWorkflow = '';
-  if (config.skills.workflow === 'spec' && selectedSkills.includes('to-spec')) {
-    specWorkflow = '- **Spec & Tickets Workflow**: `to-spec`, `to-tickets`, `implement-spec`';
-  }
+  const specCapability = skillInstalled('to-spec')
+    ? '- **Spec & Tickets Workflow**: `to-spec`, `to-tickets`, `implement-spec`'
+    : '';
 
-  const sections = [
+  const sections: Array<string | undefined> = [
     `# ${config.name}`,
     '',
     `AI-first ${config.preset} project configured with \`aginit\`.`,
@@ -70,24 +102,24 @@ export function generateAgentsMarkdown(
     '',
     '## Essential Commands',
     `- Package Manager: \`${pm}\``,
-    devCommand,
-    hasCommand('build') ? `- Build: \`${pmAdapter.runCmd('build')}\`` : '',
-    hasCommand('typecheck') ? `- Typecheck: \`${pmAdapter.runCmd('typecheck')}\`` : '',
-    hasCommand('test') ? `- Test: \`${pmAdapter.runCmd('test')}\`` : '',
-    hasCommand('test:unit') ? `- Unit Test: \`${pmAdapter.runCmd('test:unit')}\`` : '',
-    testE2E,
+    devCommand || undefined,
+    hasCommand('build') ? `- Build: \`${pmAdapter.runCmd('build')}\`` : undefined,
+    hasCommand('typecheck') ? `- Typecheck: \`${pmAdapter.runCmd('typecheck')}\`` : undefined,
+    hasCommand('test') ? `- Test: \`${pmAdapter.runCmd('test')}\`` : undefined,
+    hasCommand('test:unit') ? `- Unit Test: \`${pmAdapter.runCmd('test:unit')}\`` : undefined,
+    testE2E || undefined,
     '',
     '## AI Capabilities & Skills',
-    selectedSkills.length
+    hasSkills
       ? 'Configured skills install into `.agents/skills/` (shared by Antigravity and Codex):'
       : 'Skills installation is disabled in this configuration.',
-    engineering.length
-      ? `- **Engineering**: ${engineering.map((skill) => '\`' + skill + '\`').join(', ')}`
-      : '',
-    specWorkflow,
-    uiCapability,
-    browserCapability,
-    graftCapability,
+    engineeringCapability || undefined,
+    proseCapability || undefined,
+    simplicityCapability || undefined,
+    specCapability || undefined,
+    uiCapability || undefined,
+    browserCapability || undefined,
+    graftCapability || undefined,
     '',
     '## Bootstrap & First Session',
     'When the user asks to "bootstrap this project" or kicks off a new initiative:',
@@ -97,9 +129,11 @@ export function generateAgentsMarkdown(
     ''
   ];
 
+  // Conditional lines are `undefined` and dropped; `''` entries are the blank
+  // separators between sections and must survive.
   return (
     sections
-      .filter((s) => s !== '')
+      .filter((s): s is string => s !== undefined)
       .join('\n')
       .trim() + '\n'
   );

package/src/adapters/git.ts

@@ -33,6 +33,8 @@ blob-report/
 
 # Codebase intelligence cache (graft builds locally, git-ignored)
 /graft/
+# ripgrep hint graft writes next to that cache; regenerated by \`graft build\`
+.ignore
 `;
 
 export async function setupGit(

package/src/adapters/skills.ts

@@ -81,25 +81,28 @@ export async function installAllSkills(
 }
 
 export function getInstalledSkills(targetDir: string): string[] {
+  // The lockfile only records what the skills CLI installed through aginit;
+  // skills added by hand live on disk only, so report the union of both.
+  const installed = new Set<string>();
+
   const lockPath = path.join(targetDir, 'skills-lock.json');
   if (fileExists(lockPath)) {
     const lock = readJsonFile<SkillsLockFile>(lockPath);
-    if (lock && lock.skills) {
-      return Object.keys(lock.skills);
-    }
+    for (const name of Object.keys(lock?.skills ?? {})) installed.add(name);
   }
 
-  // Check .agents/skills directory directly
   const skillsDir = path.join(targetDir, '.agents', 'skills');
   if (fileExists(skillsDir)) {
     try {
-      return fs.readdirSync(skillsDir).filter((f) => !f.startsWith('.'));
+      for (const entry of fs.readdirSync(skillsDir)) {
+        if (!entry.startsWith('.')) installed.add(entry);
+      }
     } catch {
-      return [];
+      // Unreadable directory: keep whatever the lockfile reported.
     }
   }
 
-  return [];
+  return [...installed];
 }
 
 export async function updateSkills(

package/src/cli/doctor.ts

@@ -10,6 +10,12 @@ import {
 } from '../config/schema.js';
 import { detectPackageManager } from '../adapters/package-manager.js';
 import { getInstalledSkills } from '../adapters/skills.js';
+import {
+  agentBrowserConfigured,
+  agentBrowserStubInstalled,
+  findUsernsRestriction,
+  runAgentBrowserDiagnostics
+} from '../adapters/agent-browser.js';
 import { readProjectConfig } from '../config/validation.js';
 import { logger } from '../utils/logger.js';
 
@@ -198,20 +204,89 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
 
   // 9. Installed skills check
   const installedSkills = getInstalledSkills(targetDir);
+  const skillsDisabled = projectConfig !== null && projectConfig.skills.sources.length === 0;
   checks.push({
     name: 'Local Agent Skills (.agents/skills/)',
     category: 'Project Config',
-    ok: installedSkills.length > 0,
-    detail:
-      installedSkills.length > 0
+    ok: skillsDisabled || installedSkills.length > 0,
+    detail: skillsDisabled
+      ? 'Disabled in configuration (skills.sources is empty)'
+      : installedSkills.length > 0
         ? `${installedSkills.length} skills installed: ${installedSkills.join(', ')}`
         : 'No skills found in .agents/skills/',
     suggestion:
-      installedSkills.length === 0
-        ? 'Run `aginit init` or `npx skills add ...` to install skills'
-        : undefined
+      skillsDisabled || installedSkills.length > 0
+        ? undefined
+        : 'Run `aginit init` or `npx skills add ...` to install skills'
   });
 
+  // 10. agent-browser runtime (only when the project ships the skill)
+  const agentBrowserWanted =
+    projectConfig !== null &&
+    (agentBrowserConfigured(projectConfig.skills.sources) || agentBrowserStubInstalled(targetDir));
+  if (agentBrowserWanted) {
+    const abExists = await commandExists('agent-browser');
+    let abVersion = '';
+    if (abExists) {
+      const av = await runExecutable('agent-browser', ['--version'], { silent: true });
+      abVersion = av.ok ? av.stdout : '';
+    }
+    checks.push({
+      name: 'agent-browser CLI',
+      category: 'AI Tooling',
+      ok: abExists,
+      version: abVersion,
+      detail: abExists
+        ? `Installed globally (${abVersion || 'version unknown'})`
+        : 'agent-browser skill is installed but the CLI is not in PATH',
+      suggestion: abExists
+        ? undefined
+        : 'Install the runtime: `npm i -g agent-browser && agent-browser install`'
+    });
+
+    if (abExists) {
+      const diagnostics = await runAgentBrowserDiagnostics();
+      if (diagnostics !== null) {
+        checks.push({
+          name: 'agent-browser browser runtime',
+          category: 'AI Tooling',
+          ok: diagnostics.length === 0,
+          detail:
+            diagnostics.length === 0
+              ? 'Upstream doctor reports browser and launch environment healthy'
+              : diagnostics.map((d) => d.message).join('; '),
+          suggestion:
+            diagnostics.length === 0
+              ? undefined
+              : (diagnostics.find((d) => d.fix)?.fix ?? 'Run `agent-browser doctor` for details')
+        });
+      }
+    }
+  }
+
+  // 11. Chrome sandbox prerequisites — agent-browser and Playwright both
+  // launch Chrome from the same sandbox on Linux.
+  const sandboxRelevant = agentBrowserWanted || projectConfig?.browser.playwright === true;
+  if (sandboxRelevant) {
+    const restriction = findUsernsRestriction();
+    if (restriction) {
+      checks.push({
+        name: 'Chrome sandbox (unprivileged user namespaces)',
+        category: 'Environment',
+        ok: false,
+        detail: `${restriction.sysctl}=${restriction.value} blocks Chrome's sandbox: browser launches fail with "No usable sandbox!"`,
+        suggestion: `Lift it: echo '${restriction.sysctl}=${restriction.fixValue}' | sudo tee /etc/sysctl.d/99-agent-browser-userns.conf && sudo sysctl --system — or pass --args "--no-sandbox" per launch`
+      });
+    } else if (process.platform === 'linux') {
+      checks.push({
+        name: 'Chrome sandbox (unprivileged user namespaces)',
+        category: 'Environment',
+        ok: true,
+        detail: 'Unprivileged user namespaces available to Chrome'
+      });
+    }
+  }
+
   // Print grouped results
   const categories: Array<'Environment' | 'AI Tooling' | 'Project Config'> = [
     'Environment',

package/src/cli/main.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
 import { createProject } from './new.js';
 import { initCurrentDirectory } from './init.js';
 import { runDoctor } from './doctor.js';
@@ -14,15 +15,26 @@ import {
   runInteractiveWizard
 } from './wizard.js';
 
+/**
+ * Read the version from package.json so releases only bump one place.
+ * Resolves from `src/cli/main.ts` and from `dist/cli/main.js` alike.
+ */
+function readVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
 export function createCliProgram(): Command {
   const program = new Command();
 
   program
     .name('aginit')
-    .description(
-      'Minimal, modular AI-first project bootstrapper for T3 Code, Antigravity, and Codex'
-    )
-    .version('0.1.0');
+    .description('Set up a new or existing project for AI coding agents')
+    .version(readVersion());
 
   // Root action: interactive wizard when in TTY, else display help
   program.action(async () => {
@@ -40,10 +52,6 @@ export function createCliProgram(): Command {
     .option('-p, --preset <preset>', 'Project preset: web | cli | generic', 'generic')
     .option('-f, --framework <framework>', 'Web framework: none | vite | next | existing', 'none')
     .option('-m, --package-manager <pm>', 'Package manager: pnpm | npm | yarn | bun', 'pnpm')
-    .option(
-      '--spec-workflow',
-      'Include full spec and tickets skills (to-spec, to-tickets, implement-spec)'
-    )
     .option('--no-skills', 'Skip installing AI skills')
     .option('--no-graft', 'Skip codebase graph (Graft) setup')
     .option('--no-git', 'Skip git repository initialization')
@@ -53,7 +61,6 @@ export function createCliProgram(): Command {
       let finalPreset = options.preset;
       let finalFramework = options.framework;
       let finalPackageManager = options.packageManager;
-      let finalSpecWorkflow = options.specWorkflow;
 
       if (!finalName) {
         if (!isInteractive()) {
@@ -71,24 +78,18 @@ export function createCliProgram(): Command {
           packageManager:
             command.getOptionValueSource('packageManager') === 'cli'
               ? (options.packageManager as PackageManager)
-              : undefined,
-          specWorkflow:
-            command.getOptionValueSource('specWorkflow') === 'cli'
-              ? options.specWorkflow
               : undefined
         });
         finalName = answers.projectName;
         finalPreset = answers.preset;
         finalFramework = answers.framework;
         finalPackageManager = answers.packageManager;
-        finalSpecWorkflow = answers.specWorkflow;
       }
 
       const complete = await createProject(finalName, {
         preset: finalPreset as PresetType,
         framework: finalFramework as WebFramework,
         packageManager: finalPackageManager as PackageManager,
-        specWorkflow: finalSpecWorkflow,
         skills: options.skills,
         graft: options.graft,
         git: options.git,
@@ -104,10 +105,6 @@ export function createCliProgram(): Command {
     .option('-p, --preset <preset>', 'Project preset: web | cli | generic')
     .option('-f, --framework <framework>', 'Web framework: none | vite | next | existing')
     .option('-m, --package-manager <pm>', 'Package manager: pnpm | npm | yarn | bun')
-    .option(
-      '--spec-workflow',
-      'Include full spec and tickets skills (to-spec, to-tickets, implement-spec)'
-    )
     .option('--no-skills', 'Skip installing AI skills')
     .option('--no-graft', 'Skip codebase graph (Graft) setup')
     .option('--no-git', 'Skip git repository initialization')
@@ -116,32 +113,27 @@ export function createCliProgram(): Command {
       let finalPreset = options.preset;
       let finalFramework = options.framework;
       let finalPackageManager = options.packageManager;
-      let finalSpecWorkflow = options.specWorkflow;
 
       const isPresetExplicit = command.getOptionValueSource('preset') === 'cli';
       const isFrameworkExplicit = command.getOptionValueSource('framework') === 'cli';
       const isPmExplicit = command.getOptionValueSource('packageManager') === 'cli';
-      const isSpecExplicit = command.getOptionValueSource('specWorkflow') === 'cli';
 
       const savedConfig = readProjectConfig(process.cwd());
       if (isInteractive() && !isPresetExplicit && !options.dryRun && !savedConfig) {
         const answers = await promptInitProject({
           preset: isPresetExplicit ? (options.preset as PresetType) : undefined,
           framework: isFrameworkExplicit ? (options.framework as WebFramework) : undefined,
-          packageManager: isPmExplicit ? (options.packageManager as PackageManager) : undefined,
-          specWorkflow: isSpecExplicit ? options.specWorkflow : undefined
+          packageManager: isPmExplicit ? (options.packageManager as PackageManager) : undefined
         });
         finalPreset = answers.preset;
         finalFramework = answers.framework;
         finalPackageManager = answers.packageManager;
-        finalSpecWorkflow = answers.specWorkflow;
       }
 
       const complete = await initCurrentDirectory({
         preset: finalPreset as PresetType,
         framework: finalFramework as WebFramework,
         packageManager: finalPackageManager as PackageManager,
-        specWorkflow: finalSpecWorkflow,
         skills: options.skills,
         graft: options.graft,
         git: options.git,