@elevasis/sdk 0.5.13 → 0.5.15

package/reference/deployment/command-center.mdx

@@ -58,10 +58,7 @@ Relationships are edges in the graph. Declare them in `OrganizationResources`:
 
 ```typescript
 const org: OrganizationResources = {
-  workflows: {
-    'score-lead': scoreLeadWorkflow,
-    'send-proposal': sendProposalWorkflow,
-  },
+  workflows: [scoreLeadWorkflow, sendProposalWorkflow],
   relationships: {
     'score-lead': {
       triggers: {
@@ -131,22 +128,22 @@ The Command Queue surfaces all pending Human-in-the-Loop (HITL) approval request
 - Approve or reject with an optional comment
 - See the history of past decisions
 
-**How it connects to your code:** Approval requests appear when a workflow step calls `approval.requestApproval()`. The workflow pauses at that step and waits for a decision.
+**How it connects to your code:** Approval requests appear when a workflow step calls `approval.create()`. The workflow pauses at that step and waits for a decision.
 
 ```typescript
 import { approval } from '@elevasis/sdk/worker'
 
-const result = await approval.requestApproval({
-  title: 'Approve proposal before sending',
+const task = await approval.create({
+  actions: [
+    { id: 'approve', label: 'Approve', type: 'primary' },
+    { id: 'reject', label: 'Reject', type: 'danger' },
+  ],
   context: { dealId, proposalUrl },
+  description: 'Approve proposal before sending',
 })
-
-if (result.approved) {
-  // continue
-}
 ```
 
-> **SDK takeaway:** Use `approval.requestApproval()` to create approval gates. Provide rich `context` so reviewers have what they need to decide.
+> **SDK takeaway:** Use `approval.create()` to create approval gates. Provide rich `context` so reviewers have what they need to decide.
 
 ---
 

package/reference/deployment/index.mdx

@@ -12,7 +12,7 @@ Deploying your resources makes them live on the Elevasis platform and immediatel
 
 When you run `elevasis-sdk deploy`, the CLI performs these steps in order:
 
-1. **Authenticate** -- calls the API with your `ELEVASIS_API_KEY` to verify credentials and resolve your organization name
+1. **Authenticate** -- calls the API with your `ELEVASIS_PLATFORM_KEY` to verify credentials and resolve your organization name
 2. **Validate** -- runs your `src/index.ts` through `ResourceRegistry`, catching the same errors as the platform
 3. **Bundle** -- uses esbuild to produce a single self-contained `dist/bundle.js` file (~50-200 KB) containing your code and all dependencies
 4. **Upload** -- sends the bundle and resource metadata to the platform via `POST /api/external/deploy`
@@ -88,10 +88,10 @@ The `ElevasConfig` type is exported from `@elevasis/sdk`. You can leave the conf
 
 ## Environment Variables
 
-| Variable           | Required | Description                                                                 |
-| ------------------ | -------- | --------------------------------------------------------------------------- |
-| `ELEVASIS_API_KEY` | Yes      | Your `sk_...` API key. Used for authentication and organization resolution. |
-| `ELEVASIS_API_URL` | No       | Override the API base URL. Useful for pointing at a staging environment.    |
+| Variable                | Required | Description                                                                 |
+| ----------------------- | -------- | --------------------------------------------------------------------------- |
+| `ELEVASIS_PLATFORM_KEY` | Yes      | Your `sk_...` API key. Used for authentication and organization resolution. |
+| `ELEVASIS_API_URL`      | No       | Override the API base URL. Useful for pointing at a staging environment.    |
 
 The CLI also accepts a `--api-url` flag on every command, which takes priority over `ELEVASIS_API_URL`.
 
@@ -101,10 +101,10 @@ The CLI also accepts a `--api-url` flag on every command, which takes priority o
 2. `ELEVASIS_API_URL` environment variable
 3. `NODE_ENV`-based default (production: `https://api.elevasis.io`, development: localhost)
 
-**Setting `ELEVASIS_API_KEY` via `.env` file:**
+**Setting `ELEVASIS_PLATFORM_KEY` via `.env` file:**
 
 ```
-ELEVASIS_API_KEY=sk_***
+ELEVASIS_PLATFORM_KEY=sk_***
 ```
 
 Place `.env` in your project root. The CLI reads it automatically. Never commit this file.

package/reference/framework/agent.mdx

@@ -140,28 +140,16 @@ The agent does not prompt for confirmation on minor updates. Major changes (leve
 
 Six rule files are scaffolded in `.claude/rules/`. Rule files are auto-injected by Claude Code when their path patterns match the current file being edited -- no manual loading needed.
 
-| File                    | Type      | When Injected                   | What It Covers                                                      |
-| ----------------------- | --------- | ------------------------------- | ------------------------------------------------------------------- |
-| `sdk-patterns.md`       | MANAGED   | Any file in `src/`              | SDK imports, source structure, runtime, typed adapter patterns      |
-| `docs-authoring.md`     | MANAGED   | Any `.mdx` file in `docs/`      | MDX escaping, frontmatter requirements, doc structure               |
-| `memory-conventions.md` | MANAGED   | Any file in `.claude/memory/`   | What belongs in memory, structure, pruning                          |
-| `project-map.md`        | MANAGED   | `docs/project-map.mdx`          | Auto-generated map conventions, do not edit manually                |
-| `task-tracking.md`      | MANAGED   | Any file in `docs/in-progress/` | `/work` command, task doc format, status values                     |
-| `workspace-patterns.md` | INIT_ONLY | Any file in the project         | Project-specific patterns (starts empty, grows via error promotion) |
+The two files you will interact with directly:
 
-MANAGED rules are updated by `elevasis-sdk update` when the SDK ships a new version. `workspace-patterns.md` is INIT_ONLY -- it belongs to the project and is never overwritten. When an error recurs 3+ times, the agent promotes a fix into this file so future sessions learn from past mistakes.
+- **`sdk-patterns.md`** (MANAGED) -- Injected when editing `src/`. Covers SDK imports, source structure, runtime, and typed adapter patterns. Updated by `elevasis-sdk update`.
+- **`workspace-patterns.md`** (INIT_ONLY) -- Injected project-wide. Starts empty; grows via error promotion (3+ recurrences of the same error become a rule). Never overwritten by updates.
 
-## Interaction Guidance
-
-The `CLAUDE.md` Interaction Guidance section translates skill dimensions from `memory/profile/skills.md` into concrete behavior rules. Rather than fixed tiers, the agent adapts per dimension:
+Four additional MANAGED rules (`docs-authoring.md`, `memory-conventions.md`, `project-map.md`, `task-tracking.md`) are injected contextually for docs, memory, and task files. These are maintained by the SDK and require no user action.
 
-- **Match vocabulary to level.** Avoid jargon for beginners; be precise for experts. Define technical terms in parentheses the first time they appear.
-- **Show complete code for lower-programming users.** Users below intermediate programming level get full working files, never fragments they can't place.
-- **Explain "why" before "how" for users new to automation.** Users comfortable with code get SDK-specific pattern focus instead.
-- **Leverage domain expertise.** If the user knows sales but not code, ask for business process descriptions and translate.
-- **Log observed growth.** When the agent observes the user doing something they previously needed help with, add an entry to `skills.md` Growth Log.
+## Interaction Guidance
 
-For detailed per-dimension adaptation rules, read `reference/developer/interaction-guidance.mdx`.
+The `CLAUDE.md` Interaction Guidance section translates skill dimensions from `memory/profile/skills.md` into concrete behavior rules -- adapting vocabulary, code completeness, explanation depth, and growth logging per dimension. For the full set of per-dimension adaptation rules, see [Interaction Guidance](interaction-guidance.mdx).
 
 ---
 

package/reference/framework/interaction-guidance.mdx

@@ -1,182 +1,182 @@
----
-title: "Interaction Guidance"
-description: "Full dimensional adaptation rules per skill axis -- platform navigation, 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 four independent skill dimensions. Each dimension has its own adaptation rules. Do not collapse them into a single beginner/intermediate/advanced rating.
-
-### Platform Navigation (none / oriented / comfortable)
-
-**none** -- Never used the Command Center. Does not know where pages are.
-
-- Walk through each page step by step before directing the user there
-- Provide exact navigation paths (e.g., "Open the Command Center, then click Execution Runner in the left sidebar")
-- Explain what each page does before asking them to use it
-- Do not assume they can find a page by name alone
-
-**oriented** -- Has explored the Command Center, knows the main sections.
-
-- Reference pages by name (Execution Runner, Command Queue, Task Scheduler)
-- Briefly remind the user what a page does on first mention in a session
-- Trust them to navigate once you name the destination
-
-**comfortable** -- Regularly uses the Command Center without guidance.
-
-- Reference pages by name only, no reminders needed
-- Focus on advanced filtering, schedule types, and log detail navigation
-- Trust them to explore and navigate independently
-
----
-
-### 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 suggested using StepType.CONDITIONAL without prompting
-- User asked a question that shows they now understand the execution model
-- User navigated to the correct Command Center page without being directed
-- User filtered Execution Logs by resource independently to diagnose a failure
-- User created a Task Scheduler entry unassisted
-
-### 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 | Dimension | Change |
-| 2026-03-01 | Navigated to Execution Logs and filtered by resource without direction | platformNavigation | none -> oriented |
-```
-
-Also update the dimension's Level and Since fields in the Dimensions table.
-
-### Celebration
-
-When growth is observed, acknowledge it briefly:
-
-- "You found that on your own -- looks like you've got the Command Center navigation down."
-- "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
+---
+title: "Interaction Guidance"
+description: "Full dimensional adaptation rules per skill axis -- platform navigation, 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 four independent skill dimensions. Each dimension has its own adaptation rules. Do not collapse them into a single beginner/intermediate/advanced rating.
+
+### Platform Navigation (none / oriented / comfortable)
+
+**none** -- Never used the Command Center. Does not know where pages are.
+
+- Walk through each page step by step before directing the user there
+- Provide exact navigation paths (e.g., "Open the Command Center, then click Execution Runner in the left sidebar")
+- Explain what each page does before asking them to use it
+- Do not assume they can find a page by name alone
+
+**oriented** -- Has explored the Command Center, knows the main sections.
+
+- Reference pages by name (Execution Runner, Command Queue, Task Scheduler)
+- Briefly remind the user what a page does on first mention in a session
+- Trust them to navigate once you name the destination
+
+**comfortable** -- Regularly uses the Command Center without guidance.
+
+- Reference pages by name only, no reminders needed
+- Focus on advanced filtering, schedule types, and log detail navigation
+- Trust them to explore and navigate independently
+
+---
+
+### 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_PLATFORM_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 suggested using StepType.CONDITIONAL without prompting
+- User asked a question that shows they now understand the execution model
+- User navigated to the correct Command Center page without being directed
+- User filtered Execution Logs by resource independently to diagnose a failure
+- User created a Task Scheduler entry unassisted
+
+### 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 | Dimension | Change |
+| 2026-03-01 | Navigated to Execution Logs and filtered by resource without direction | platformNavigation | none -> oriented |
+```
+
+Also update the dimension's Level and Since fields in the Dimensions table.
+
+### Celebration
+
+When growth is observed, acknowledge it briefly:
+
+- "You found that on your own -- looks like you've got the Command Center navigation down."
+- "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/memory.mdx

@@ -150,15 +150,6 @@ Valid levels per dimension:
 | Proactive guidance | yes |
 ```
 
-#### What Profile-as-Memory Eliminates
-
-Storing profile data in the memory system instead of a separate JSON file removes:
-
-- The `.claude/profile.json` file entirely
-- A separate JSON schema to maintain
-- A separate read path at session start -- profile and memory index are unified under `memory/index.md`
-- Onboarding questions baked into `CLAUDE.md` that write JSON -- `/meta init` writes markdown instead
-
 ### Root Index
 
 `memory/index.md` is the only file read at session start. It lists all topics with their last-updated dates, giving the agent enough context to know what has been recorded without loading any detail.
@@ -198,7 +189,7 @@ Subdirectory entries link to their `index.md` rather than the directory itself.
 ## Resources
 
 - `echo` (workflow, dev) -- echoes input, starter resource
-- `lead-scorer` (workflow, production) -- scores leads from Attio
+- `lead-scorer` (workflow, prod) -- scores leads from Attio
 
 ## Deploy History
 
@@ -249,7 +240,7 @@ Each category file is a table of known error patterns with resolutions:
 
 | Last Seen | Error | Resolution | Occurrences |
 | --- | --- | --- | --- |
-| 2026-02-25 | `ELEVASIS_API_KEY not set` | Added key to `.env` | 2 |
+| 2026-02-25 | `ELEVASIS_PLATFORM_KEY not set` | Added key to `.env` | 2 |
 | 2026-02-26 | `Schema validation: missing outputSchema` | Added Zod output schema to workflow | 1 |
 ```
 
@@ -328,19 +319,7 @@ If an error pattern recurs 3 or more times, promote it to a rule in the `CLAUDE.
 
 ## Relationship to Claude Code Auto-Memory
 
-Claude Code maintains its own auto-memory at `~/.claude/projects/{hash}/memory/MEMORY.md`. Project memory is complementary, not a replacement.
-
-| Aspect            | Auto-Memory (`MEMORY.md`)          | Project Memory (`.claude/memory/`)               |
-| ----------------- | ---------------------------------- | ------------------------------------------------ |
-| Maintained by     | Claude Code platform               | CLAUDE.md instructions                           |
-| Scope             | Organic discoveries                | Explicit project state                           |
-| Portability       | Machine-specific                   | Gitignored (personal to each developer)          |
-| Content           | General patterns                   | Deployment state, resources, credentials, errors |
-| User control      | Implicit                           | Explicit (can read, edit, delete)                |
-| Session load cost | Full file (truncated at 200 lines) | Root index only (~5 lines); detail on-demand     |
-| Scaling           | Single file, truncated             | Hierarchical tree, unlimited depth               |
-
-Both should be active. Auto-memory captures things the agent notices organically. Project memory captures structured project state that `CLAUDE.md` explicitly instructs the agent to record.
+Claude Code's auto-memory (`MEMORY.md`) and project memory (`.claude/memory/`) are complementary -- both should be active. Auto-memory captures organic discoveries; project memory captures structured project state that `CLAUDE.md` explicitly instructs the agent to record.
 
 ---