@elevasis/sdk 0.4.6 → 0.4.7

package/reference/developer/interaction-guidance.mdx

@@ -0,0 +1,213 @@
+---
+title: "Interaction Guidance"
+description: "Full dimensional adaptation rules per skill axis -- programming, TypeScript, API integration, automation concepts, domain expertise -- with growth tracking protocol"
+loadWhen: "Unsure how to adapt for a skill combination"
+---
+
+This reference defines how to adapt every interaction based on the dimensions in `.claude/memory/profile/skills.md`. Read it when the compact directive in CLAUDE.md is not enough to decide how to handle an unusual skill combination.
+
+---
+
+## Skill Dimensions
+
+The user profile stores five independent skill dimensions. Each dimension has its own adaptation rules. Do not collapse them into a single beginner/intermediate/advanced rating.
+
+### Programming Fundamentals (none / minimal / comfortable / advanced)
+
+**none** -- Has not written code. May have used no-code tools.
+
+- Explain what functions, variables, and objects are when they appear in code
+- Use analogies for every technical concept (see Analogies section below)
+- Show complete, working files with every import included
+- Never show code fragments they cannot place
+- Walk through each line in plain English before showing code
+- Do not assume they can read code independently
+
+**minimal** -- Has written HTML, CSS, Excel formulas, or simple scripts.
+
+- Briefly explain language constructs that differ from what they know
+- Show complete files with inline comments on non-obvious parts
+- Avoid assuming they know what async/await, imports, or type annotations do
+- Skip explanations of basic web/formula concepts they likely know
+
+**comfortable** -- Has written programs in at least one general-purpose language.
+
+- Brief inline comments for non-obvious SDK-specific parts
+- Skip explanations of variables, functions, loops, and basic data structures
+- Focus on what is different about TypeScript and the SDK API
+
+**advanced** -- Writes production software professionally.
+
+- Concise code, no commentary on language features
+- Focus only on SDK-specific patterns and constraints
+- Trust them to infer context from types and naming
+
+---
+
+### TypeScript (none / exposure / proficient)
+
+**none** -- Has not used TypeScript or any statically typed language.
+
+- Show complete files with every import
+- Explain type annotations as "labels that describe what kind of data this is"
+- Never use generics without a plain-English explanation
+- Explain `z.infer` every time it appears: "This creates a TypeScript type from the schema so you get autocomplete and error checking"
+- Explain the difference between runtime validation (Zod) and compile-time checking (TypeScript)
+
+**exposure** -- Has read TypeScript or used a typed language (Java, C#, Go).
+
+- Show code with brief type annotation comments for SDK-specific types
+- Explain `WorkflowDefinition`, `StepType`, and `OrganizationResources` on first use
+- Trust them to understand basic type syntax
+
+**proficient** -- Has written TypeScript projects.
+
+- Types without explanation
+- Focus on SDK API surface, not language features
+- Trust them to read type definitions
+
+---
+
+### API and Integration (none / basic / proficient)
+
+**none** -- Has not called an API directly. Uses tools with built-in integrations.
+
+- Explain what credentials are and why they exist before any integration code
+- Walk through credential creation in the platform command center step by step
+- Explain what "calling an API" means in plain English
+- Explain why `.env` exists and what `ELEVASIS_API_KEY` is for
+- Do not assume they understand HTTP methods, JSON, or authentication headers
+
+**basic** -- Has used APIs with documentation or built simple integrations.
+
+- Show `platform.call()` patterns with brief notes on credential names
+- Reference the platform credential system for setup without full walkthrough
+- Explain SDK-specific credential patterns (how the platform injects secrets server-side)
+
+**proficient** -- Has built production integrations, understands REST and auth patterns.
+
+- Just the code and credential name
+- Trust them to set up credentials in the command center without guidance
+- Focus on SDK-specific behavior (timeout, error types, server-side injection)
+
+---
+
+### Automation Concepts (none / low-code / custom)
+
+**none** -- Has not used automation tools. Thinks in manual processes.
+
+- Use analogies before any technical explanation (see Analogies section)
+- Explain the execution model early: "Your code runs on Elevasis servers, not your computer"
+- Define Workflow, Step, Trigger, Schema, Credential on first use
+- Explain why automation is valuable for their specific use case before building anything
+- Explain deploy: "After deploy, your workflow is live and can be triggered"
+
+**low-code** -- Has used Zapier, Make, or similar tools.
+
+- Map Elevasis concepts to tools they know: "Steps are like Zapier actions. The workflow is the Zap."
+- Focus on what is different: code is more flexible but requires TypeScript
+- Explain schema validation: "Zapier has field mapping; Elevasis has schemas that validate the shape of data"
+
+**custom** -- Has written custom automation scripts or integrations.
+
+- Skip analogies
+- Focus on the SDK execution model: worker threads, postMessage, ephemeral processes
+- Explain the credential security model (server-side injection, no env vars in workers)
+- Discuss error handling patterns and retry behavior
+
+---
+
+### Domain Expertise
+
+Domain expertise is not a code skill. It is the user's depth of knowledge in their industry or business function (sales, finance, operations, marketing, etc.).
+
+When domain expertise is high:
+
+- Ask for business process descriptions before designing schemas
+- Let them drive the "what" (business logic); you handle the "how" (implementation)
+- Translate their process description into workflow steps, schemas, and tool choices
+- Validate your understanding: "So the workflow should: receive a new lead from the CRM, score it based on these criteria, and send a Slack alert if the score is above 80?"
+- Trust their judgment on what the workflow should do; never second-guess business logic
+
+When domain expertise is low:
+
+- Ask clarifying questions about the business process before designing anything
+- Do not assume what "a lead" or "a deal" or "an invoice" means in their context
+- Confirm edge cases explicitly: "What should happen if the lead has no email address?"
+
+---
+
+## Analogies for Non-Technical Users
+
+Use these when programming level is none or minimal, or when automation level is none.
+
+| Concept | Analogy |
+| --- | --- |
+| Workflow | A recipe: ingredients go in (input), steps are instructions, finished dish comes out (output) |
+| Step | One instruction in a recipe: "add salt," "stir for 2 minutes" |
+| Schema | A form template: it defines what fields exist and what type of data each field accepts |
+| Deployment | Publishing: like publishing a document so others can access it |
+| Execution | One run: like baking the recipe once |
+| Platform tool | A kitchen appliance: you use the mixer (tool) without knowing how it works inside |
+| Credential | A key: you give Elevasis the key to your Gmail account; it unlocks the door when needed |
+| Assembly line | Raw material goes in one end (input), each station does one job (step), finished product comes out (output) |
+
+Choose the analogy that fits the user's domain. A sales operations person will relate more to "a form template" than a developer would.
+
+---
+
+## Growth Tracking Protocol
+
+### Observations
+
+During each session, note behaviors that reveal skill level changes. Examples:
+
+- User wrote a handler without asking for help
+- User independently caught a type error before you pointed it out
+- User suggested using StepType.CONDITIONAL without prompting
+- User asked a question that shows they now understand the execution model
+
+### Promotion Rules
+
+Do not automatically update the skill profile for every observation. Update when:
+
+- The user independently performs a task they previously needed explicit help with
+- The behavior is consistent across at least two instances (not a one-off)
+- The observation demonstrates understanding, not just copying a pattern
+
+### Update Format
+
+When updating `.claude/memory/profile/skills.md` Growth Log:
+
+```
+| Date | Observation | Skill Updated |
+| 2026-03-01 | Wrote complete handler with correct types independently | TypeScript: none -> exposure |
+```
+
+Also update the dimension's Level field and Evidence field to reflect the new assessment.
+
+### Celebration
+
+When growth is observed, acknowledge it briefly:
+
+- "You just wrote that handler without any help -- your TypeScript is definitely improving."
+- "Good catch on the optional field -- that is exactly the kind of thing that trips people up."
+
+Keep it natural. One sentence is enough. Do not over-celebrate.
+
+---
+
+## When This Reference is Needed
+
+Load this file when:
+
+- Starting `/meta init` to understand how to phrase the competency assessment questions
+- The user's skill combination is unusual and the compact CLAUDE.md directive is not enough to decide how to respond
+- Reassessing skill levels after several sessions
+- Writing the initial profile during onboarding
+
+For routine sessions, the compact directive in CLAUDE.md plus the user's stored `skills.md` is sufficient.
+
+---
+
+**Last Updated:** 2026-02-26

package/reference/framework/agent.mdx

@@ -0,0 +1,175 @@
+---
+title: Agent System
+description: CLAUDE.md drives all agent behavior -- project instructions, slash commands, memory-based developer profile, and three-tier adaptive guidance
+loadWhen: "Configuring agent behavior or capabilities"
+---
+
+The agent system is the set of files that shape how Claude Code behaves in your SDK project. It consists of four parts: `CLAUDE.md` (the instruction file), slash commands (structured task entry points), the developer profile stored in `memory/profile/`, and the adaptive guidance rules that translate profile data into concrete agent behavior.
+
+Nothing here requires configuration. The agent reads these files at session start and adapts automatically.
+
+## CLAUDE.md
+
+`CLAUDE.md` is the project instruction file for Claude Code. It is read at the start of every session and governs all agent behavior. In an Elevasis SDK project, it is generated by `elevasis init` and lives at the project root.
+
+The file is instruction-driven by design. Non-technical developers should never need to edit it. When the agent learns a new rule worth preserving -- such as an error pattern that recurs three times -- it promotes that rule into `CLAUDE.md` automatically.
+
+### Sections
+
+The generated `CLAUDE.md` contains these sections:
+
+- **Session Initialization** -- Instructs the agent to read `memory/index.md` silently at session start, drill into `memory/profile/skills.md` for adaptive behavior, suggest `/meta init` if memory does not exist, and notify the user if the template version is outdated.
+- **What This Is** -- Project orientation: what an Elevasis SDK project is and how it deploys to the platform.
+- **Project Structure** -- Which files contain resources, documentation, and configuration.
+- **CLI Reference** -- All `elevasis` commands with flags, including deploy, exec, env, and execution inspection.
+- **SDK Patterns** -- Working code examples for resource definitions, Zod schemas, multi-step workflows, platform tools, and execution context.
+- **Rules** -- Project-specific constraints. Starts empty; grows as the agent promotes recurring error patterns.
+- **Maintaining Memory** -- Hierarchical scaling pattern, pruning rules, and promotion criteria for the `memory/` directory.
+- **SDK Reference Documentation** -- Paths to bundled SDK reference docs in `node_modules/@elevasis/sdk/reference/`.
+- **Adaptive Guidance** -- Behavior rules for Beginner, Intermediate, and Advanced tiers based on skill levels read from `memory/profile/skills.md`.
+
+### Session Initialization
+
+At the start of every session the agent runs these steps silently before responding:
+
+1. Read `.claude/memory/index.md` if it exists -- scan what project context has been recorded, including profile, error patterns, deployment state, and decisions. Drill into `memory/profile/skills.md` to personalize responses based on experience level.
+2. If `.claude/memory/` does not exist, suggest running `/meta init` to set up the project.
+3. Check the installed `@elevasis/sdk` template version against `templateVersion` in `elevasis.config.ts`. If the SDK has a newer version, notify the user and suggest running `/meta update`.
+
+## Slash Commands
+
+Slash commands are short Markdown instruction files in `.claude/commands/`. When you type `/command-name` in a Claude Code session, the agent reads the corresponding file and follows its instructions.
+
+All nine commands are scaffolded by `elevasis init` and committed to version control so collaborators get the same experience:
+
+| Command | File | Purpose |
+| --- | --- | --- |
+| `/meta` | `meta.md` | Project lifecycle management -- init, status, update, fix, deploy, health, develop |
+| `/docs` | `docs.md` | Documentation lifecycle -- create, checkpoint, cleanup, resume, verify |
+| `/database` | `database.md` | Database operations -- init, status, add, browse, schema, import |
+| `/resource` | `resource.md` | Scaffolds a new workflow or agent resource in `src/` |
+| `/templates` | `templates.md` | Workflow template discovery and scaffolding |
+| `/agent` | `agent.md` | Agent development (placeholder for future agent runtime) |
+| `/tutorial` | `tutorial.md` | Progressive learning path for new developers |
+| `/help` | `help.md` | Displays the full command tree and navigation map |
+| `/profile` | `profile.md` | Views and updates the developer profile in `memory/profile/` |
+
+### `/meta` Command
+
+The `/meta` command namespace manages the full project lifecycle. It has seven operations:
+
+- **`/meta init`** -- First-run guided setup. Runs after `elevasis init` to install dependencies, configure `.env`, run the 6-question onboarding flow, seed `memory/profile/`, verify the project, and optionally do a first deploy.
+- **`/meta`** (no arguments) -- Project health status. Shows current template version, SDK version, profile summary, and a quick drift check.
+- **`/meta update`** -- Upgrade the SDK and merge template changes. Runs `pnpm update @elevasis/sdk`, then `elevasis update`, then intelligently merges flagged files and reports what changed.
+- **`/meta fix`** -- Repair drift without a version upgrade. Checks for missing commands, missing gitignore entries, missing CLAUDE.md sections, broken memory links, and broken doc cross-references.
+- **`/meta deploy`** -- Full 9-step deploy pipeline: validate, type-check, verify docs, commit, deploy, bump version, verify platform, update deployment state, and optionally push.
+- **`/meta health`** -- Execution debugging and resource status; shows recent executions, analyzes failures, and checks environment connectivity.
+- **`/meta develop`** -- Development navigation hub that loads the resource map, SDK reference, and project state; replaces the old standalone `/workflow`, `/tools`, and `/examples` commands.
+
+### `/docs` Command
+
+The `/docs` command manages the full documentation lifecycle. It has six operations:
+
+- **`/docs`** (no arguments) -- Show current documentation status: pages in progress, recent changes, and any stale entries flagged for review.
+- **`/docs create`** -- Create a new documentation page. Prompts for title, description, and location, then scaffolds an MDX file with proper frontmatter.
+- **`/docs checkpoint`** -- Save current work progress for session resume. Creates or updates `docs/in-progress/<topic>.mdx` with current state, decisions made, remaining work, and blockers. Also updates `docs/priorities.mdx`.
+- **`/docs cleanup`** -- Move completed documents from `docs/in-progress/` to their final location. Reviews each in-progress doc, relocates complete ones, and rebuilds `docs/navigation.mdx`.
+- **`/docs resume`** -- Start-of-session review of in-progress docs, priorities, and recent deployment state. Offers to continue work on the highest-priority item.
+- **`/docs verify`** -- Cross-reference documentation with the codebase. Reads the specified doc (or all docs if no path provided) and reports discrepancies against actual resource IDs, schema fields, and platform tools.
+
+### `/database` Command
+
+The `/database` command handles all database operations for projects that connect a Supabase project. It has six operations:
+
+- **`/database init`** -- Connect a Supabase project. Prompts for project URL and anon key, writes connection config, and verifies connectivity.
+- **`/database`** (no arguments) -- Show database status: connection health, migration count, and a summary of tables.
+- **`/database add`** -- Create a migration script for a new table. Prompts for table name and columns, generates a typed migration, and updates schema documentation.
+- **`/database browse`** -- Query and display table contents in a readable format for quick inspection during development.
+- **`/database schema`** -- View or compare schema documentation against the live database. Highlights drift between documented schema and actual columns.
+- **`/database import`** -- Import CSV or JSON data into a table. Validates column mapping before writing.
+
+### `/help` Command
+
+The `/help` command displays the complete command tree with one-line descriptions for every command and subcommand, plus navigation pointers to key project files (`docs/navigation.mdx`, `docs/priorities.mdx`, `memory/index.md`). It is the "I'm lost, what can I do?" entry point for command discovery and navigation.
+
+### `/profile` Command
+
+The profile command reads from and writes to `memory/profile/`. It has three modes:
+
+- **No arguments** -- Displays the current profile in readable format (organization, industry, experience levels, goals, known integrations, preferences) and asks if anything needs updating.
+- **`/profile update`** -- Walks through each profile section, shows current values, and updates only the fields the user wants to change. Writes changes to the appropriate `memory/profile/` file.
+- **`/profile level`** -- Assesses the user's current skill level based on project history (resources created, successful deploys, error handling patterns) and suggests updating `memory/profile/skills.md` if the assessment differs from the stored level.
+
+## Developer Profile
+
+The developer profile is stored in `.claude/memory/profile/` as a set of markdown files. It is gitignored -- personal to each developer, not shared with collaborators. Profile data lives in the memory system alongside error patterns, deployment state, and decisions.
+
+### Onboarding Flow
+
+Profile data is created during `/meta init`. The command runs a 6-question onboarding conversation and writes the responses to `memory/profile/`:
+
+1. What kind of business or team is this for? (industry, size)
+2. What are the main goals for this project? (automation goals)
+3. Which external tools or services will workflows integrate with? (integrations)
+4. How would you describe your experience with TypeScript? (beginner / intermediate / advanced)
+5. How familiar are you with AI automation and workflow concepts? (new / some experience / experienced)
+6. Do you prefer detailed explanations or concise responses? (detailed / concise)
+
+### Profile Structure
+
+```
+.claude/memory/profile/
+├── index.md          # Profile summary with links to sub-files
+├── identity.md       # Organization, industry, goals, integrations
+├── skills.md         # TypeScript level, automation experience, growth history
+└── preferences.md    # Verbosity, guidance style, interaction patterns
+```
+
+`identity.md` records the organization name, industry, size, project goals, and known tool integrations. `skills.md` stores the TypeScript and automation skill levels as structured values (`beginner / intermediate / advanced`, `new / some-experience / experienced`) along with a growth history table. `preferences.md` stores verbosity (`detailed / concise`) and proactive guidance preference.
+
+### Auto-Update Triggers
+
+The agent updates `memory/profile/` files when it observes:
+
+- The user successfully completes an advanced task (level upgrade candidate in `skills.md`)
+- The user mentions new tools or integrations not in `identity.md`
+- The user explicitly asks to change preferences
+
+The agent does not prompt for confirmation on minor updates. Major changes (level upgrades) are surfaced to the user before writing.
+
+## Adaptive Guidance
+
+The `CLAUDE.md` Adaptive Guidance section translates the skill levels from `memory/profile/skills.md` into concrete behavior rules. The agent checks the TypeScript level and automation level and applies the matching tier.
+
+### Beginner
+
+Applies when TypeScript level is `beginner` or automation level is `new`:
+
+- Always show complete, working code -- never fragments
+- Explain every new concept the first time it appears (TypeScript types, Zod schemas, async/await)
+- After creating a resource, walk through deployment step by step
+- Proactively suggest next steps ("Now let's deploy this" or "Want to test it?")
+- When errors occur, explain both the fix and why it happened
+- Use `/help` to navigate to the relevant SDK reference before suggesting platform tools
+
+### Intermediate
+
+Applies when TypeScript level is `intermediate` and automation level is `some-experience`:
+
+- Show code with brief inline comments for non-obvious parts
+- Explain new concepts but not basics (Zod, async/await, TypeScript types)
+- Suggest deployment after resource creation but do not walk through it
+- When errors occur, provide the fix with a one-line explanation
+
+### Advanced
+
+Applies when TypeScript level is `advanced` and automation level is `experienced`:
+
+- Concise code, minimal explanation
+- Focus on edge cases and performance
+- Trust the user to deploy and test independently
+- When errors occur, provide the fix
+
+---
+
+**Last Updated:** 2026-02-26

package/reference/{documentation/index.mdx → framework/documentation.mdx}

@@ -1,6 +1,7 @@
 ---
 title: Resource Documentation
 description: Write and deploy MDX documentation alongside your Elevasis resources
+loadWhen: "Writing or updating project documentation"
 ---
 
 `elevasis deploy` ships your code and your documentation atomically -- one command, no version drift. Documentation files live in a `docs/` directory at your project root and render in the Elevasis platform UI for operators using your resources.

package/reference/framework/index.mdx

@@ -0,0 +1,95 @@
+---
+title: Development Framework
+description: The SDK scaffolds a complete development environment for Claude Code -- project instructions, slash commands, cross-session memory, and template versioning
+loadWhen: "Understanding the agent framework structure"
+---
+
+`elevasis init` scaffolds more than code. It builds a development environment designed around Claude Code as the primary interface. Most external SDK developers are non-technical -- they write workflows through conversation, not by reading API docs. The framework gives the agent everything it needs to guide those users effectively from the first session onward.
+
+The framework lives entirely in `.claude/`. It is never deployed and never touches the `docs/` directory, which ships to the platform.
+
+## What Gets Scaffolded
+
+Running `elevasis init my-project` produces the following agent infrastructure alongside your source files:
+
+```
+.claude/
+├── CLAUDE.md                   # Project instructions for Claude Code
+├── settings.json               # autoCompact: false
+└── commands/
+    ├── docs.md                 # Documentation assistant
+    ├── resource.md             # Resource scaffolding assistant
+    ├── profile.md              # View and update developer profile
+    ├── meta.md                 # Project lifecycle (init, status, update, fix)
+    ├── help.md                 # Contextual help and concept explanations
+    ├── database.md             # Database schema and query assistant
+    ├── agent.md                # Agent scaffolding and configuration
+    ├── templates.md            # Template browsing and generation
+    └── tutorial.md             # Progressive 7-lesson learning path
+```
+
+The `memory/` directory is gitignored -- it is personal to each developer and not shared with collaborators. Everything else in `.claude/` is committed.
+
+CLAUDE.md is scaffolded with an `<!-- initialized: false -->` HTML comment at the very top. When the agent reads this flag on session start and finds it false, it automatically runs the `/meta init` flow -- no slash command knowledge required from the user. After initialization completes the agent changes the flag to `<!-- initialized: true -->`, so subsequent sessions proceed normally.
+
+## Why It Works This Way
+
+The agent needs three things to guide a non-technical developer well:
+
+- **Who the user is** -- their TypeScript experience, automation background, and project goals, stored in `.claude/memory/profile/` as markdown files and created during `/meta init`
+- **What has happened in this project** -- deployment state, credentials, errors encountered, and architectural decisions, stored in `.claude/memory/` and loaded on demand
+- **How to behave** -- adaptive guidance rules in `CLAUDE.md` that translate experience levels into concrete behaviors: complete code examples for beginners, concise fixes for advanced users
+
+The agent reads `memory/index.md` at session start and drills into `memory/profile/skills.md` for adaptive behavior. It adjusts its tone, explanation depth, and proactivity based on what it finds. This happens silently -- the developer sees a helpful response, not a loading message.
+
+## The Framework Components
+
+### Agent System
+
+The `CLAUDE.md` file drives all agent behavior. It contains the session initialization instructions, adaptive guidance tiers, memory maintenance rules, and slash command definitions. No hooks, no code enforcement -- everything is instruction-driven so non-technical users never need to configure anything.
+
+The `/profile` slash command lets developers view and update their profile in `memory/profile/`. The `/meta` command manages the project lifecycle: `/meta init` for guided setup, `/meta update` for SDK upgrades, `/meta fix` for drift repair. Other commands give the agent structured entry points for common tasks: `/meta deploy` for deployments, `/resource` for scaffolding new resources, `/meta health` for debugging executions.
+
+See [Agent System](agent.mdx) for CLAUDE.md sections, slash command reference, developer profile, and adaptive guidance tiers.
+
+### Memory System
+
+The `memory/` directory follows a hierarchical index tree pattern: a root `index.md` maps to topic files and subdirectories, each subdirectory has its own index. The agent reads only the root index at session start and drills into detail files on demand. The `memory/profile/` subdirectory is seeded by `/meta init` during guided setup; other topics are created by the agent as needed.
+
+Topics include developer profile (identity, skills, preferences), deployment state, environment credentials, architectural decisions, and error patterns. Error tracking starts as a subdirectory because it naturally spans multiple categories. Other topics start as flat files and split when they outgrow a single document.
+
+See [Memory System](memory.mdx) for architecture, error tracking format, scaling rules, and maintenance guidelines.
+
+### Project Structure
+
+The scaffolded project separates concerns clearly: `src/` for resources, `docs/` for platform documentation, `.claude/` for agent infrastructure, and config files at the root. Understanding which files are gitignored, which are committed, and why matters for collaborating on projects.
+
+See [Project Structure](project-structure.mdx) for a file-by-file walkthrough of the scaffolded project.
+
+### Documentation
+
+Every SDK project ships its own MDX documentation alongside its resources. The `docs/` directory is bundled into each deployment and served from the platform. This is where you document what your resources do, how to use them, and what inputs they expect.
+
+See [Documentation](documentation.mdx) for writing MDX docs, file limits, and the deploy pipeline.
+
+## Adaptive Guidance
+
+The agent adapts its communication based on five independent skill dimensions stored in `memory/profile/skills.md`:
+
+- **Programming Fundamentals** -- none / minimal / comfortable / advanced
+- **TypeScript** -- none / exposure / proficient
+- **API & Integration** -- none / basic / proficient
+- **Automation Concepts** -- none / low-code / custom
+- **Data Management** -- none / spreadsheets / databases
+
+Each dimension is assessed separately during `/meta init` via 5-6 conditional questions. A user who has deep Zapier experience but no TypeScript knowledge will receive Zod explanations every time while getting automation concepts treated as familiar ground. The questions use conditional skipping to minimize friction: beginners answer 5 questions, developers answer 6.
+
+See [Agent System](agent.mdx) for the full assessment question set, dimensional interaction rules, and communication principles.
+
+### Skills Auto-Update
+
+The Growth Log in `memory/profile/skills.md` keeps approximately 20 recent entries. The agent adds an entry whenever it observes the user performing something they previously needed help with. When a consistent pattern of growth is observed -- typically after several independent successes -- the agent promotes the observation to a level change in the relevant dimension. The `/profile` command lets developers view their current levels and trigger a fresh assessment at any time.
+
+---
+
+**Last Updated:** 2026-02-25