test('defaults to read/write/shell when no tools specified', () => {
      const input = '---\nname: test\n---\nPrompt';
      const result = transforms.transformAgentForKiro(input);
      const parsed = JSON.parse(result);
      expect(parsed.tools).toEqual(['read']);
    });

  // --- Kiro adapters ---
  const KIRO_PLUGIN_ROOT_PLACEHOLDER = '{{PLUGIN_INSTALL_PATH}}';

  switch (stateDir) {
    case '.opencode': return 'opencode';
    case '.codex': return 'codex';
    case '.kiro': return 'kiro';
    case '.claude': return 'claude';

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@__tests__/gen-adapters.test.js`:
- Around line 690-695: The test description ("defaults to read/write/shell when
no tools specified") disagrees with the assertion that parsed.tools equals
['read']; update the test to make intent unambiguous by either changing the
assertion to expect the full default set (e.g., ['read','write','shell']) or,
preferably, renaming the test description to match the existing assertion (e.g.,
"defaults to read when no tools specified"); locate the test that calls
transforms.transformAgentForKiro(...) and asserts parsed.tools and apply one of
these two fixes so the test name and the assertion are consistent.

In `@bin/cli.js`:
- Around line 1707-1713: The installer currently only creates .kiro/skills,
.kiro/steering, and .kiro/agents; add creation for .kiro/hooks and
.kiro/settings and update any reporting/console output that lists install
targets to include these new dirs. Specifically, in the same block where
skillsDir, steeringDir, and agentsDir are defined and mkdirSync'd (variables
named skillsDir, steeringDir, agentsDir and calls to fs.mkdirSync), add hooksDir
and settingsDir with path.join(cwd, '.kiro', 'hooks') and path.join(cwd,
'.kiro', 'settings') and call fs.mkdirSync for each; repeat the same additions
in the duplicate block referenced around the 1846-1850 region so both installer
code paths create and report hooks and settings.
- Around line 952-955: The Kiro detection currently only checks for specific
subdirs and misses a plain .kiro directory; update the logic around kiroDir and
the platforms.push('kiro') call to also treat the presence of the .kiro
directory itself as a match (i.e., use fs.existsSync(kiroDir) ||
fs.existsSync(path.join(kiroDir, 'steering')) || ...), so that if kiroDir exists
(fresh setup) you still push 'kiro' to platforms.
- Around line 1666-1668: installForCursor is calling the Kiro transformer
(transforms.transformSkillForKiro) which is the wrong platform; update the call
in installForCursor to use the Cursor-specific transformer (e.g.,
transforms.transformSkillForCursor) and pass the same pluginInstallPath option
(path.join(installDir, 'plugins', pluginName)); ensure the transforms module
exports the Cursor transformer and update any import/reference if needed.

In `@docs/INSTALLATION.md`:
- Around line 167-168: The platform table currently lists "Kiro" but omits
"Cursor"; update the table row entries to include a "Cursor" row matching the
format used for other platforms (e.g., add a line similar to the existing Kiro
row with "Cursor" and its repo/config directories), ensure the number of
platforms matches the five-platform messaging, and keep column formatting
consistent with the table (use "Cursor" and the appropriate path like `.cursor/`
mirroring the pattern used for `Kiro` and other entries).
- Line 53: The interactive installer section header claims five platforms but
the prompt snippet below still lists only three options; update the
prompt/options snippet (the prompt block under the "Interactive installer for
Claude Code, OpenCode, Codex CLI, Cursor, and Kiro:" heading) to include Cursor
and Kiro as separate selectable options and adjust any numbering or selection
text to reflect five platforms instead of three.

In `@lib/platform/state-dir.js`:
- Around line 86-95: Detection currently only checks the local .kiro directory
and can mis-detect Kiro sessions configured via the KIRO_HOME env var; update
the detection in the block that computes kiroPath (references: _cachedStateDirs,
cacheKey, isDirectory, kiroPath) to first check process.env.KIRO_HOME (resolve
it to an absolute path or join with basePath if necessary) and, if that
directory exists and is a Kiro state dir, set _cachedStateDirs.set(cacheKey,
'KIRO_HOME') (or the same '.kiro' token if you prefer consistency) and return
immediately; keep the existing filesystem .kiro fallback only after the env
check and preserve the try/catch behavior.

---

Nitpick comments:
In `@__tests__/cli-args.test.js`:
- Around line 283-429: Add a new test that verifies installForCursor invokes the
Cursor transform exported by the plugin: create an installDir via
setupInstallDir that includes a test plugin file which exports the transform
function (or named export "transform"), replace or spy on that transform (using
Jest spyOn or a module mock), call discovery.invalidateCache() and run
installForCursor(installDir), then assert the spy was called; reference the
existing helpers installForCursor and setupInstallDir and ensure the test
resets/cleans the spy so it doesn't affect other tests.

In `@scripts/dev-install.js`:
- Around line 476-551: installKiro currently only writes skills, steering and
agents; extend it to also materialize Kiro hooks, settings and MCP artifacts so
dev installs match production. Add creation of hooksDir, settingsDir/file and
mcpDir in the installKiro() setup (similar to skillsDir/steeringDir/agentsDir),
then for each plugin look for plugin-specific hooks (e.g.,
SOURCE_DIR/plugins/<plugin>/hooks) and copy/transform them using
transforms.transformHookForKiro(pluginInstallPath,...), persist to the
.kiro/hooks directory; likewise locate global or plugin settings
(SOURCE_DIR/plugins/<plugin>/settings or a top-level settings file), run
transforms.transformSettingsForKiro(...) and write to .kiro/settings, and
materialize any MCP configs (SOURCE_DIR/plugins/<plugin>/mcp or SOURCE_DIR/mcp)
via transforms.transformMCPForKiro(...) into .kiro/mcp; reuse copyToAgentSys()
behavior and existing patterns (PLUGINS, SOURCE_DIR, AGENTSYS_DIR,
discovery.getKiroSteeringMappings, transforms.transform* functions) and
increment corresponding counters for logging.

  // Kiro detection
  try {
    const kiroPath = path.join(basePath, '.kiro');
    if (isDirectory(kiroPath)) {
      _cachedStateDirs.set(cacheKey, '.kiro');

/**
 * Transform agent markdown+frontmatter to Kiro JSON format.
 *
 * Parses frontmatter for name/description/model/tools, uses body as prompt.
 * Returns a JSON string matching Kiro's agent schema.
 */