agent-method 1.5.0 → 1.5.1

package/README.md

@@ -1,256 +1,256 @@
-# agent-method
-
-A file-structure-first methodology for AI-agent-assisted development. Files are the interface — with optional CLI tools for validation, routing, and project management.
-
-`ai-agents` `prompt-engineering` `developer-tools` `context-engineering` `agent-framework` `markdown` `llm-tools` `ai-workflow` `cursor` `claude-code`
-
----
-
-## The problem
-
-AI-agent-assisted development breaks down in three ways:
-
-- **Context rot** — agent quality degrades as context windows fill with irrelevant conversation
-- **Amnesia** — decisions from session N are lost by session N+1
-- **Scope drift** — without structured gates, work sprawls and progress becomes invisible
-
-Existing solutions tie you to specific agent runtimes through CLI tools and slash commands. agent-method solves this with **files as the interface** — readable, portable, agent-agnostic.
-
-## Quick start
-
-### Option A: npx (recommended, zero-install)
-
-```bash
-npx agent-method init code ~/my-project
-```
-
-Replace `code` with your project type: `code`, `context`, `data`, `mix`, or `general`.
-
-Done. Templates are copied, extensions merged, placeholders filled. Open `PROJECT.md` and start working.
-
-### Option B: Setup script
-
-```bash
-git clone https://github.com/anthropics/agent-method.git
-cd agent-method
-bash setup.sh ~/my-project
-```
-
-Interactive installer — asks project name, type, runtime, tier, lifecycle, and profile.
-
-### Option C: Manual copy
-
-```
-cp -r templates/starter/ ~/my-project/
-```
-
-Delete the two entry point files you don't use and fill in `PROJECT.md`.
-
-## CLI Tools (optional)
-
-The methodology works entirely through files, but CLI tools are available for validation, routing, and project management.
-
-### Installation
-
-```bash
-npx agent-method            # zero-install, runs directly
-```
-
-Or install permanently:
-
-```bash
-npm install -g agent-method           # Node.js (global)
-pip install agent-method-tools        # Python (alternative)
-```
-
-Both distributions have identical commands, same registry, same templates.
-
-### Developer commands
-
-| Command | What it does |
-|---------|-------------|
-| `agent-method check` | Validate your entry point (auto-finds file, auto-detects type) |
-| `agent-method scan` | Detect project type from directory contents |
-| `agent-method route "<query>"` | Show how a query routes through the pipeline |
-| `agent-method refine` | Extract refinement report from SESSION-LOG.md |
-| `agent-method status` | Check if your methodology version is current |
-| `agent-method upgrade` | Brownfield-safe methodology update |
-| `agent-method init <type>` | Describe entry point contents for a project type |
-
-### Project type aliases
-
-Use friendly names with any command: `code`, `context`, `data`, `mix`, `general`.
-
-```bash
-agent-method init code                # software project
-agent-method init context             # analytical/prompt project (PromptStudy)
-agent-method init data                # data index/querying project (SysMLv2)
-agent-method init mix                 # multi-type project
-agent-method route "query" -p context # route with project type
-```
-
-### Advanced: pipeline subcommands
-
-For debugging individual pipeline stages: `agent-method pipeline classify|select|resolve|cascade|test`.
-
-### Key features
-
-- **All commands support `--json`** for machine-readable output
-- **Smart defaults** — auto-finds entry point, session log, and project type
-- **Two distributions** — `npx agent-method` (Node.js, zero-install) or `pip install agent-method-tools` (Python)
-- **CLI is opt-in** — methodology works without it; tools add convenience
-
-Run `agent-method --help` for full command reference.
-
-## What you get
-
-```
-your-project/
-  CLAUDE.md / .cursorrules / AGENT.md   # Agent entry point (pick one)
-  PROJECT.md            # Project vision — fill this in first
-  PROJECT-PROFILE.md    # Project type, lifecycle stage, extensions
-  STATE.md              # Decisions, blockers, current position
-  ROADMAP.md            # Phase breakdown with gate criteria
-  PLAN.md               # Current task with verification criteria
-  .context/
-    BASE.md             # Core context — always loaded with entry point
-    METHODOLOGY.md      # Workflows, conventions overflow (lite/standard profiles)
-```
-
-Full tier adds: `REQUIREMENTS.md`, `SUMMARY.md`, `.context/REGISTRY.md`, `docs/`, `todos/backlog.md`.
-
-Every file ships with **inline instructions** — the agent reads them and helps you populate each section.
-
-## How it works
-
-### Scoping rules
-
-The entry point contains a table mapping query types to file sets. When you ask a question, the agent loads only the relevant files and constrains its writes. Context windows stay small, responses stay focused.
-
-```markdown
-| Query type          | Read before acting           | Update after acting        |
-|---------------------|------------------------------|----------------------------|
-| **Code change**     | .context/BASE.md + specialist | Source files, test files   |
-| **Planning**        | REQUIREMENTS.md, ROADMAP.md  | STATE.md, PLAN.md         |
-```
-
-### Dependency cascade
-
-"When X changes, also update Y." The agent checks this table after every file change, preventing files from drifting out of sync.
-
-```markdown
-| When this changes    | Also update                                    |
-|----------------------|------------------------------------------------|
-| Database schema      | Migrations, type imports, .context/DATABASE.md |
-| Phase completion     | SUMMARY.md, STATE.md, ROADMAP.md               |
-```
-
-### Context pairing
-
-Instead of loading all context at once, the agent pairs `.context/BASE.md` with one specialist file per query type. A code change loads `BASE.md + DATABASE.md`. A planning query loads `REQUIREMENTS.md + ROADMAP.md`. Token usage stays low, relevance stays high.
-
-### Cross-session memory
-
-`STATE.md` persists decisions, blockers, and current position across sessions. The agent reads it at the start of every conversation — no re-explaining what happened yesterday.
-
-## Integration profiles
-
-Control how much methodology surface area gets installed. Match the profile to your model's capability.
-
-| Profile | Best for | Entry point size | What's included |
-|---------|----------|:-----------------:|-----------------|
-| **lite** | Haiku, simple projects | ~25 lines | STATE.md, minimal rules, 2 cascade rules |
-| **standard** | Sonnet (recommended) | ~40 lines | + PLAN.md, context pairing, 6 cascade rules, overflow to METHODOLOGY.md |
-| **full** | Opus, complex projects | ~60 lines | All rules inline, all intelligence layer files |
-
-Three rules followed consistently beat ten rules followed inconsistently.
-
-## Project types
-
-| Type | CLI name | What's added to the entry point |
-|------|----------|-------------------------------|
-| **General** | `general` | Universal scoping and cascade rules only |
-| **Code** | `code` | Code change, bug fix, dependency, database, API, deployment scoping + cascade |
-| **Data** | `data` | Data ingest, schema, document, entity, relationship, analytical query scoping + cascade |
-| **Analytical** | `context` | Chain work, evaluation, composition, domain research scoping + cascade |
-| **Mixed** | `mix` | Multiple extensions combined (code+data, code+analytical, etc.) |
-
-Extensions are additive — they add rows to existing tables, never override universal content.
-
-## Brownfield projects (existing codebases)
-
-For projects with existing code, `setup.sh` detects project indicators and activates brownfield mode:
-
-- **Never overwrites** existing files — only copies methodology files that don't already exist
-- **Appends** methodology sections to your existing entry point (`CLAUDE.md`, `.cursorrules`, etc.)
-- **Preserves** all your existing conventions, rules, and project terminology
-- **Suggests** the Discovery workflow (WF-08) for systematic codebase understanding:
-
-> Ask your agent: "Scan the codebase and populate the context files"
-
-The agent inventories your project, maps dependencies, extracts patterns, and bootstraps `.context/` files — all without modifying your source code.
-
-## Lifecycle stages
-
-Projects evolve. The methodology adapts.
-
-| Stage | When | What activates |
-|-------|------|----------------|
-| **Discovery** | Existing project, agent maps it first | SCAN features, WF-08 discovery workflow |
-| **Design** | New project, defining architecture | Planning workflows, decision recording |
-| **Development** | Building and iterating | Code/data/analytical workflows, full cascade |
-| **Evolution** | Maintaining and extending | Context refresh, drift detection |
-
-Transitions happen naturally — update `PROJECT-PROFILE.md` when you're ready to move on.
-
-## Supported runtimes
-
-| File | Runtime | Auto-loaded? |
-|------|---------|:------------:|
-| `CLAUDE.md` | Claude Code | Yes |
-| `.cursorrules` | Cursor | Yes |
-| `AGENT.md` | Any agent | No (paste or reference manually) |
-
-All three contain identical scoping rules, cascade structure, and conventions — only the filename and auto-loading behavior differ.
-
-## Template tiers
-
-**Starter** (7 files) — Cross-session memory, scoped context loading, project profiling, structured execution. Good for most projects.
-
-**Full** (11+ files) — Everything in starter, plus requirements tracking, execution history (`SUMMARY.md`), navigation registry, human-facing docs scaffold, and backlog capture. For complex or long-running projects.
-
-## Methodology at a glance
-
-| Concept | What it does |
-|---------|-------------|
-| **Intelligence layer** | PROJECT / STATE / ROADMAP / PLAN / SUMMARY files provide persistent cross-session memory |
-| **Scoping rules** | Table-driven query routing — agent loads only what's relevant |
-| **Dependency cascade** | "When X changes, also update Y" prevents file drift |
-| **Context pairing** | One specialist file per query type, not everything at once |
-| **Workflow stages** | Initialize → Scope → Plan → Execute → Verify → Close |
-| **Integration profiles** | lite / standard / full — match methodology depth to model capability |
-| **Brownfield merge** | Append-only integration — never overwrites, never deletes |
-| **CLI tools (optional)** | 7 developer commands + pipeline subcommands for debugging |
-| **32 agent capabilities** | Organized across 8 domains, activate behind the scenes |
-
-## Documentation
-
-| Document | Audience |
-|----------|----------|
-| [Quick start guide](docs/guides/quick-start.md) | Developers — setup and first session |
-| [For developers](docs/guides/for-developers.md) | Developers — workflows, context, troubleshooting |
-| [For managers](docs/guides/for-managers.md) | Managers — reading project status from methodology files |
-| [Template kit](templates/README.md) | Template tiers, extensions, bootstrapping |
-| [CLI tools](https://github.com/anthropics/agent-method#cli-tools-optional) | Command reference (or run `agent-method --help`) |
-| [Docs hub](docs/index.md) | Full architecture, workflow, and methodology docs |
-
-## Prior art
-
-| System | Relationship |
-|--------|-------------|
-| [GSD (get-shit-done)](https://github.com/jlowin/get-shit-done) | Inspired the structured agent workflow. agent-method removes CLI dependency, adds scoping rules and context pairing |
-| PromptStudy | Reference implementation. Scoping rules, cascade, and context pairing patterns extracted from real agent-human collaboration |
-
-## License
-
-MIT (pending)
+# agent-method
+
+A file-structure-first methodology for AI-agent-assisted development. Files are the interface — with optional CLI tools for validation, routing, and project management.
+
+`ai-agents` `prompt-engineering` `developer-tools` `context-engineering` `agent-framework` `markdown` `llm-tools` `ai-workflow` `cursor` `claude-code`
+
+---
+
+## The problem
+
+AI-agent-assisted development breaks down in three ways:
+
+- **Context rot** — agent quality degrades as context windows fill with irrelevant conversation
+- **Amnesia** — decisions from session N are lost by session N+1
+- **Scope drift** — without structured gates, work sprawls and progress becomes invisible
+
+Existing solutions tie you to specific agent runtimes through CLI tools and slash commands. agent-method solves this with **files as the interface** — readable, portable, agent-agnostic.
+
+## Quick start
+
+### Option A: npx (recommended, zero-install)
+
+```bash
+npx agent-method init code ~/my-project
+```
+
+Replace `code` with your project type: `code`, `context`, `data`, `mix`, or `general`.
+
+Done. Templates are copied, extensions merged, placeholders filled. Open `PROJECT.md` and start working.
+
+### Option B: Setup script
+
+```bash
+git clone https://github.com/anthropics/agent-method.git
+cd agent-method
+bash setup.sh ~/my-project
+```
+
+Interactive installer — asks project name, type, runtime, tier, lifecycle, and profile.
+
+### Option C: Manual copy
+
+```
+cp -r templates/starter/ ~/my-project/
+```
+
+Delete the two entry point files you don't use and fill in `PROJECT.md`.
+
+## CLI Tools (optional)
+
+The methodology works entirely through files, but CLI tools are available for validation, routing, and project management.
+
+### Installation
+
+```bash
+npx agent-method            # zero-install, runs directly
+```
+
+Or install permanently:
+
+```bash
+npm install -g agent-method           # Node.js (global)
+pip install agent-method-tools        # Python (alternative)
+```
+
+Both distributions have identical commands, same registry, same templates.
+
+### Developer commands
+
+| Command | What it does |
+|---------|-------------|
+| `npx agent-method check` | Validate your entry point (auto-finds file, auto-detects type) |
+| `npx agent-method scan` | Detect project type from directory contents |
+| `npx agent-method route "<query>"` | Show how a query routes through the pipeline |
+| `npx agent-method refine` | Extract refinement report from SESSION-LOG.md |
+| `npx agent-method status` | Check if your methodology version is current |
+| `npx agent-method upgrade` | Brownfield-safe methodology update |
+| `npx agent-method init <type>` | Describe entry point contents for a project type |
+
+### Project type aliases
+
+Use friendly names with any command: `code`, `context`, `data`, `mix`, `general`.
+
+```bash
+agent-method init code                # software project
+agent-method init context             # analytical/prompt project (PromptStudy)
+agent-method init data                # data index/querying project (SysMLv2)
+agent-method init mix                 # multi-type project
+agent-method route "query" -p context # route with project type
+```
+
+### Advanced: pipeline subcommands
+
+For debugging individual pipeline stages: `npx agent-method pipeline classify|select|resolve|cascade|test`.
+
+### Key features
+
+- **All commands support `--json`** for machine-readable output
+- **Smart defaults** — auto-finds entry point, session log, and project type
+- **Two distributions** — `npx agent-method` (Node.js, zero-install) or `pip install agent-method-tools` (Python)
+- **CLI is opt-in** — methodology works without it; tools add convenience
+
+Run `npx agent-method --help` for full command reference.
+
+## What you get
+
+```
+your-project/
+  CLAUDE.md / .cursorrules / AGENT.md   # Agent entry point (pick one)
+  PROJECT.md            # Project vision — fill this in first
+  PROJECT-PROFILE.md    # Project type, lifecycle stage, extensions
+  STATE.md              # Decisions, blockers, current position
+  ROADMAP.md            # Phase breakdown with gate criteria
+  PLAN.md               # Current task with verification criteria
+  .context/
+    BASE.md             # Core context — always loaded with entry point
+    METHODOLOGY.md      # Workflows, conventions overflow (lite/standard profiles)
+```
+
+Full tier adds: `REQUIREMENTS.md`, `SUMMARY.md`, `.context/REGISTRY.md`, `docs/`, `todos/backlog.md`.
+
+Every file ships with **inline instructions** — the agent reads them and helps you populate each section.
+
+## How it works
+
+### Scoping rules
+
+The entry point contains a table mapping query types to file sets. When you ask a question, the agent loads only the relevant files and constrains its writes. Context windows stay small, responses stay focused.
+
+```markdown
+| Query type          | Read before acting           | Update after acting        |
+|---------------------|------------------------------|----------------------------|
+| **Code change**     | .context/BASE.md + specialist | Source files, test files   |
+| **Planning**        | REQUIREMENTS.md, ROADMAP.md  | STATE.md, PLAN.md         |
+```
+
+### Dependency cascade
+
+"When X changes, also update Y." The agent checks this table after every file change, preventing files from drifting out of sync.
+
+```markdown
+| When this changes    | Also update                                    |
+|----------------------|------------------------------------------------|
+| Database schema      | Migrations, type imports, .context/DATABASE.md |
+| Phase completion     | SUMMARY.md, STATE.md, ROADMAP.md               |
+```
+
+### Context pairing
+
+Instead of loading all context at once, the agent pairs `.context/BASE.md` with one specialist file per query type. A code change loads `BASE.md + DATABASE.md`. A planning query loads `REQUIREMENTS.md + ROADMAP.md`. Token usage stays low, relevance stays high.
+
+### Cross-session memory
+
+`STATE.md` persists decisions, blockers, and current position across sessions. The agent reads it at the start of every conversation — no re-explaining what happened yesterday.
+
+## Integration profiles
+
+Control how much methodology surface area gets installed. Match the profile to your model's capability.
+
+| Profile | Best for | Entry point size | What's included |
+|---------|----------|:-----------------:|-----------------|
+| **lite** | Haiku, simple projects | ~25 lines | STATE.md, minimal rules, 2 cascade rules |
+| **standard** | Sonnet (recommended) | ~40 lines | + PLAN.md, context pairing, 6 cascade rules, overflow to METHODOLOGY.md |
+| **full** | Opus, complex projects | ~60 lines | All rules inline, all intelligence layer files |
+
+Three rules followed consistently beat ten rules followed inconsistently.
+
+## Project types
+
+| Type | CLI name | What's added to the entry point |
+|------|----------|-------------------------------|
+| **General** | `general` | Universal scoping and cascade rules only |
+| **Code** | `code` | Code change, bug fix, dependency, database, API, deployment scoping + cascade |
+| **Data** | `data` | Data ingest, schema, document, entity, relationship, analytical query scoping + cascade |
+| **Analytical** | `context` | Chain work, evaluation, composition, domain research scoping + cascade |
+| **Mixed** | `mix` | Multiple extensions combined (code+data, code+analytical, etc.) |
+
+Extensions are additive — they add rows to existing tables, never override universal content.
+
+## Brownfield projects (existing codebases)
+
+For projects with existing code, `setup.sh` detects project indicators and activates brownfield mode:
+
+- **Never overwrites** existing files — only copies methodology files that don't already exist
+- **Appends** methodology sections to your existing entry point (`CLAUDE.md`, `.cursorrules`, etc.)
+- **Preserves** all your existing conventions, rules, and project terminology
+- **Suggests** the Discovery workflow (WF-08) for systematic codebase understanding:
+
+> Ask your agent: "Scan the codebase and populate the context files"
+
+The agent inventories your project, maps dependencies, extracts patterns, and bootstraps `.context/` files — all without modifying your source code.
+
+## Lifecycle stages
+
+Projects evolve. The methodology adapts.
+
+| Stage | When | What activates |
+|-------|------|----------------|
+| **Discovery** | Existing project, agent maps it first | SCAN features, WF-08 discovery workflow |
+| **Design** | New project, defining architecture | Planning workflows, decision recording |
+| **Development** | Building and iterating | Code/data/analytical workflows, full cascade |
+| **Evolution** | Maintaining and extending | Context refresh, drift detection |
+
+Transitions happen naturally — update `PROJECT-PROFILE.md` when you're ready to move on.
+
+## Supported runtimes
+
+| File | Runtime | Auto-loaded? |
+|------|---------|:------------:|
+| `CLAUDE.md` | Claude Code | Yes |
+| `.cursorrules` | Cursor | Yes |
+| `AGENT.md` | Any agent | No (paste or reference manually) |
+
+All three contain identical scoping rules, cascade structure, and conventions — only the filename and auto-loading behavior differ.
+
+## Template tiers
+
+**Starter** (7 files) — Cross-session memory, scoped context loading, project profiling, structured execution. Good for most projects.
+
+**Full** (11+ files) — Everything in starter, plus requirements tracking, execution history (`SUMMARY.md`), navigation registry, human-facing docs scaffold, and backlog capture. For complex or long-running projects.
+
+## Methodology at a glance
+
+| Concept | What it does |
+|---------|-------------|
+| **Intelligence layer** | PROJECT / STATE / ROADMAP / PLAN / SUMMARY files provide persistent cross-session memory |
+| **Scoping rules** | Table-driven query routing — agent loads only what's relevant |
+| **Dependency cascade** | "When X changes, also update Y" prevents file drift |
+| **Context pairing** | One specialist file per query type, not everything at once |
+| **Workflow stages** | Initialize → Scope → Plan → Execute → Verify → Close |
+| **Integration profiles** | lite / standard / full — match methodology depth to model capability |
+| **Brownfield merge** | Append-only integration — never overwrites, never deletes |
+| **CLI tools (optional)** | 7 developer commands + pipeline subcommands for debugging |
+| **32 agent capabilities** | Organized across 8 domains, activate behind the scenes |
+
+## Documentation
+
+| Document | Audience |
+|----------|----------|
+| [Quick start guide](docs/guides/quick-start.md) | Developers — setup and first session |
+| [For developers](docs/guides/for-developers.md) | Developers — workflows, context, troubleshooting |
+| [For managers](docs/guides/for-managers.md) | Managers — reading project status from methodology files |
+| [Template kit](templates/README.md) | Template tiers, extensions, bootstrapping |
+| [CLI tools](https://github.com/anthropics/agent-method#cli-tools-optional) | Command reference (or run `npx agent-method --help`) |
+| [Docs hub](docs/index.md) | Full architecture, workflow, and methodology docs |
+
+## Prior art
+
+| System | Relationship |
+|--------|-------------|
+| [GSD (get-shit-done)](https://github.com/jlowin/get-shit-done) | Inspired the structured agent workflow. agent-method removes CLI dependency, adds scoping rules and context pairing |
+| PromptStudy | Reference implementation. Scoping rules, cascade, and context pairing patterns extracted from real agent-human collaboration |
+
+## License
+
+MIT (pending)

package/lib/cli/check.js

@@ -28,7 +28,7 @@ export function register(program) {
           console.error(
             "No entry point found in current directory " +
               "(looked for CLAUDE.md, .cursorrules, AGENT.md).\n" +
-              "Specify a path: agent-method check path/to/CLAUDE.md"
+              "Specify a path: npx agent-method check path/to/CLAUDE.md"
           );
           process.exit(1);
         }

package/lib/cli/init.js

@@ -44,7 +44,7 @@ export function register(program) {
         if (!directory) {
           console.log(
             "\nTo create a project, specify a directory:\n" +
-              `  agent-method init ${projectTypeArg} ~/my-project`
+              `  npx agent-method init ${projectTypeArg} ~/my-project`
           );
         }
         return;

package/lib/cli/refine.js

@@ -15,7 +15,7 @@ export function register(program) {
         if (!sessionLog) {
           console.error(
             "No SESSION-LOG.md found in current directory.\n" +
-              "Specify a path: agent-method refine path/to/SESSION-LOG.md"
+              "Specify a path: npx agent-method refine path/to/SESSION-LOG.md"
           );
           process.exit(1);
         }

package/lib/cli/scan.js

@@ -17,9 +17,9 @@ export function register(program) {
       const friendlyMap = { analytical: "context", mixed: "mix" };
       if (ptype in friendlyMap) {
         result.friendly_name = friendlyMap[ptype];
-        result.init_command = `agent-method init ${friendlyMap[ptype]}`;
+        result.init_command = `npx agent-method init ${friendlyMap[ptype]}`;
       } else {
-        result.init_command = `agent-method init ${ptype}`;
+        result.init_command = `npx agent-method init ${ptype}`;
       }
 
       console.log(`Scanning: ${directory}`);

package/lib/cli/status.js

@@ -38,7 +38,7 @@ export function register(program) {
         message =
           `Entry point ${basename_of(ep)} is outdated ` +
           `(method_version: ${epVersion}, installed: ${installed}). ` +
-          `Run \`agent-method upgrade ${directory}\` to update.`;
+          `Run \`npx agent-method upgrade ${directory}\` to update.`;
       }
 
       if (opts.json) {

package/lib/cli/upgrade.js

@@ -65,7 +65,7 @@ export function register(program) {
                 `## Method version\n\n` +
                 `method_version: ${newVer}\n` +
                 `<!-- Tracks which methodology version generated this entry point -->\n` +
-                `<!-- Use \`agent-method status\` to compare against latest -->\n\n`;
+                `<!-- Use \`npx agent-method status\` to compare against latest -->\n\n`;
               content = content.replace("## Conventions", insert + "## Conventions");
               writeFileSync(ep, content, "utf-8");
             }

package/lib/init.js

@@ -86,7 +86,7 @@ export async function initProject(projectType, directory, opts = {}) {
   console.log(`  3. Delete the two entry point files you don't use`);
   console.log(`     (keep CLAUDE.md, .cursorrules, or AGENT.md)`);
   console.log(`  4. Start a conversation — the agent reads the entry point`);
-  console.log(`\nRun \`agent-method check\` to validate your setup.`);
+  console.log(`\nRun \`npx agent-method check\` to validate your setup.`);
 }
 
 function detectBrownfield(dir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-method",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "CLI tools for the agent-method methodology — registry-driven routing, validation, and project setup for AI-agent-assisted development",
   "keywords": [
     "ai-agents",