@elevasis/sdk 1.44.2 → 1.45.0

package/reference/sdk/framework/agent.mdx

@@ -1,156 +1,86 @@
 ---
 title: Agent System
-description: CLAUDE.md drives all agent behavior -- project instructions, slash commands, memory-based developer profile, and three-tier adaptive guidance
+description: The template's skill layer, the always-on ambient vibe classifier, the rules layer, and how project continuity is tracked through the elevasis-sdk project CLI, not files
 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.
+The agent system is the set of files that shape how Claude Code behaves in your SDK project. It consists of three parts: the skill layer (`.claude/skills/`, slash-command entry points), the rules layer (path-scoped operating context, mostly bundled with the installed `@elevasis/sdk` package), and the ambient vibe layer (an always-on natural-language intent classifier). `CLAUDE.md` carries only project identity and preferences -- session bootstrap belongs to the rules layer, not to `CLAUDE.md`.
 
 Nothing here requires configuration. The agent reads these files at session start and adapts automatically.
 
-## CLAUDE.md
+## CLAUDE.md and Overview.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 lives at the project root.
+`CLAUDE.md` is project-owned and never overwritten by sync. It routes the agent to `agent-start-here.md` for session bootstrap, points to `.claude/Overview.md` for the full skill/rule/command surface, and carries two project-specific sections: **Client Context** and **User Preferences**. These are populated by `/setup` during first-time bootstrap and are not re-written on subsequent runs.
 
-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.
+`.claude/Overview.md` is template-owned and replaced on every `/git-sync`. It is the authoritative routing map: skill inventory, rule inventory, project structure, stack table, and command reference. When a user asks what skills or commands are available, the agent reads this file (or runs `elevasis-sdk cli` for live capability) rather than answering from memory.
 
-### Sections
+`OPERATIONS.md` and `CONNECTIONS.md` are also project-owned and never overwritten. `OPERATIONS.md` records tenant-specific operational quirks that override generic guidance -- for example, whether this tenant even has a working dev deploy target. `CONNECTIONS.md` records production wiring values (URLs, IDs, non-secret connection facts).
 
-The generated `CLAUDE.md` contains these sections:
+### Session Bootstrap
 
-- **Session Initialization** -- Checks the `<!-- initialized: false -->` auto-init flag; if false, runs `/meta init` automatically. Otherwise reads `memory/profile/skills.md` for adaptive behavior, reads `memory/index.md` for project context, checks if the template version is current, and suggests `/tutorial` for users with no Platform Navigation experience.
-- **Identity** -- Project orientation: what an Elevasis SDK project is, the developer's role, and how to adapt to non-technical users.
-- **Navigation** -- A table mapping concepts to file paths with load conditions (when to load each file). Includes SDK reference docs, credential model, error history, `docs/project-map.mdx`, and `docs/priorities.mdx`.
-- **Rules** -- Points to auto-loaded rule files in `.claude/rules/`. SDK patterns load automatically; project-specific patterns live in `workspace-patterns.md`. Includes error handling protocol.
-- **Interaction Guidance** -- Per-dimension behavior rules derived from `memory/profile/skills.md`. Covers vocabulary, code completeness, explanation depth, and growth logging.
-- **Commands** -- Table of the 4 slash commands (`/meta`, `/docs`, `/work`, `/tutorial`) with one-line purpose descriptions.
-- **Skills** -- Auto-trigger conditions for the `creds` skill.
-- **Maintaining Memory** -- Hierarchical structure, pruning rules, and what belongs in memory vs. `docs/` vs. `.claude/rules/`.
+`.claude/rules/agent-start-here.md` is a thin pointer to the canonical rule body bundled with the installed SDK: `operations/node_modules/@elevasis/sdk/reference/rules/agent-start-here.md`. It is always-loaded and owns session bootstrap. The invariants it establishes:
 
-### Session Initialization
+- **Project context is DB-canonical.** Milestones, tasks, and resume notes are read and written only through `elevasis-sdk project:*` -- never through files. A session opens with `project:list --status active --pretty`, then `--status blocked`, and resolves "continue" or "pick up" requests with `project:work <query>`.
+- **`OPERATIONS.md` outranks generic guidance.** Trust order: tenant `OPERATIONS.md`, then source and published package docs, then co-located boundary docs, then generated maps, then hand-authored template guidance.
+- **Never answer "what can you do" from memory.** Skill inventory is `.claude/Overview.md`; live CLI capability is `elevasis-sdk cli`.
+- **A missing `ui/` or `core/config/organization-model.ts` is not broken scaffolding.** Operations-only projects legitimately have neither.
 
-At the start of every session the agent runs these steps silently before responding:
+There is no `<!-- initialized: false -->` flag and no `/meta init` flow in the current template. First-time bootstrap is the `/setup` skill (see below), which hands off to `/om` for organization-model configuration.
 
-0. Check the `<!-- initialized: ... -->` flag at the top of `CLAUDE.md`. If `false`, run the `/meta init` flow automatically. If `true`, proceed with steps below.
-1. Read `.claude/memory/profile/skills.md` -- adapt all responses to the user's assessed skill levels (see Interaction Guidance below).
-2. Read `.claude/memory/index.md` if it exists -- drill into relevant topic files as needed, balancing context relevance against token usage.
-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 fix`.
-4. If `.claude/memory/` does not exist, suggest running `/meta init` to set up the project.
-5. If the user's Platform Navigation level is none (from skills.md) and `.claude/memory/tutorial-progress.md` does not exist, suggest `/tutorial`.
-
-## Slash Commands
+## The Skill Layer
 
 Skills are Markdown instruction files in `.claude/skills/`. When you type `/skill-name` in a Claude Code session, the agent reads the corresponding `SKILL.md` and follows its instructions.
 
-The following skills ship with every Elevasis SDK project and are committed to version control so collaborators get the same experience:
-
-| Skill       | File                       | Purpose                                                  |
-| ----------- | -------------------------- | -------------------------------------------------------- |
-| `/work`     | `skills/work/SKILL.md`     | Task tracking -- list, create, save, resume, complete    |
-| `/elevasis` | `skills/elevasis/SKILL.md` | SDK operations -- check, deploy, exec                    |
-| `/deploy`   | `skills/deploy/skill.md`   | Full deploy pipeline (test, build, commit, push)         |
-| `/setup`    | `skills/setup/SKILL.md`    | First-time project setup (placeholder replacement, deps) |
-| `/status`   | `skills/status/SKILL.md`   | Quick project health check                               |
-| `/continue` | `skills/continue/SKILL.md` | Resume in-progress work from docs                        |
-| `/project`  | `skills/project/SKILL.md`  | Route project management to `elevasis-sdk project:*`     |
-| `/sync`     | `skills/sync/SKILL.md`     | Pull latest, wipe caches, fresh reinstall                |
-| `/explore`  | `skills/explore/SKILL.md`  | Codebase exploration anchored to docs                    |
-| `/save`     | `skills/save/SKILL.md`     | Auto-manage docs from conversation context               |
-| `/dsp`      | `skills/dsp/SKILL.md`      | Parallel agent dispatch for implementation tasks         |
+The template ships these skills, all committed to version control:
+
+| Skill             | Purpose                                                                                          |
+| ----------------- | ------------------------------------------------------------------------------------------------ |
+| `/client`         | Client portfolio management -- list, resolve, inspect, and maintain client records               |
+| `/deploy`         | Test, build, fix issues, then commit and push                                                    |
+| `/dsp`            | Dispatch subagents in parallel for implementation tasks                                          |
+| `/elevasis`       | SDK operations -- check, deploy, execute, inspect, and debug resources                           |
+| `/explore`        | Codebase exploration anchored to project documentation                                           |
+| `/git-sync`       | Pull latest changes, install when the dependency baseline moved, run baseline verification       |
+| `/om`             | Organization Model ceremony -- read, codify, toggle, layered flow                                |
+| `/project`        | Portfolio- and project-level work management via `elevasis-sdk project:*`                        |
+| `/run-ui`         | Start the Vite UI dev server on port 4300 in the background                                      |
+| `/save`           | Auto-manage project documentation and persist task resume context from conversation              |
+| `/setup`          | First-time project setup -- placeholder replacement, deps, build verification, hand off to `/om` |
+| `/status`         | Quick project health check                                                                       |
+| `/submit-request` | Submit a structured request (bug, feature, support) to the platform                              |
+| `/sync`           | Fresh reinstall and cache reset after local dependency or cache drift                            |
+| `/tutorial`       | Persona-aware onboarding -- vibe-coder or technical track                                        |
+
+There is no `/meta`, `/docs`, or `/work` skill. The template's own boundary guidance splits overlapping responsibilities this way: `/project` updates or inspects shared project records, `/save` captures implementation progress and conversation-derived docs, and `/elevasis` (or the monorepo-side `/adev`) handles resource execution and debugging.
 
 ### Key Skills
 
-**`/setup`** -- First-time project setup. Replaces template placeholders, installs dependencies, configures `.env`, verifies the project, and optionally runs a first deploy.
-
-**`/deploy`** -- Full deploy pipeline: type-check, validate resources, commit, deploy (auto-regenerates `docs/index.md` and `docs/resources.md`), verify platform, and optionally push.
-
-**`/elevasis`** -- SDK operations entry point: `check` validates resource definitions, `deploy` bundles and uploads, `exec` runs a resource with input.
-
-**`/work`** -- File-based task lifecycle. Creates, resumes, saves, and completes task docs in `docs/in-progress/`. It tracks in-progress work state, not project records.
-
-**`/status`** -- Quick project health check: shows SDK version, deployed resources, last deploy date, and environment status.
-
-**`/save`** -- Auto-manages docs from conversation context: writes or updates docs based on what was discussed in the session.
-
-**`/explore`** -- Codebase exploration anchored to `docs/`. Reads the doc map first, then drills into source as needed.
-
-**`/continue`** -- Resumes in-progress work by reading `docs/in-progress/` and picking up where the last session left off.
-
-**`/project`** -- Project-management routing for milestones, tasks, notes, and status. It should call the canonical `elevasis-sdk project:*` CLI surface rather than inventing a parallel workflow.
-
-That routing is interface-first, not a separate semantic model. `/project` should treat the SDK CLI as the operational entrypoint for the Organization OS delivery/projects contract: `deliveryManifest` in the shared UI, `PROJECTS_SYSTEM_ID` (`platform.projects`) in the organization model, and `organizationModel.delivery` for project/milestone/task status semantics.
-
-When these command families overlap conceptually, use this boundary:
-
-- `/project` -- update or inspect project data in the shared Projects system
-- `/work` -- capture implementation progress and resume context in docs
-- `/adev` -- build, debug, test, or execute resources
-
-**`/dsp`** -- Dispatches subagents in parallel for implementation tasks that can run concurrently.
-
-**`/sync`** -- Pulls latest changes, wipes all `node_modules` and caches, and runs a fresh reinstall.
-
-## 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 assessment and writes the responses to `memory/profile/`:
-
-- **Identity & Goals (3 questions):** What the business does, what to automate, which tools are already in use.
-- **Competency (2 questions):** Command Center familiarity (maps to `platformNavigation`), automation tool familiarity (maps to `automation`). Two additional dimensions (`apiIntegration`, `domainExpertise`) are inferred from these answers.
-- **Communication (1 question):** Step-by-step explanations vs. concise answers.
-
-### Profile Structure
-
-```
-.claude/memory/profile/
-├── index.md          # Profile summary with links to sub-files
-├── identity.md       # Organization, industry, goals, integrations
-├── skills.md         # Skill dimensions (platformNavigation, apiIntegration, automation, domainExpertise)
-└── preferences.md    # Verbosity, guidance style, interaction patterns
-```
-
-`identity.md` records the organization name, industry, size, project goals, and known tool integrations. `skills.md` stores four skill dimensions as structured values (`platformNavigation`, `apiIntegration`, `automation`, `domainExpertise`) along with a Growth Log table. See [Interaction Guidance](interaction-guidance.mdx) for the full set of per-dimension adaptation rules. `preferences.md` stores verbosity (`detailed / concise`) and proactive guidance preference.
-
-### Auto-Update Triggers
-
-The agent updates `memory/profile/` files when it observes:
+**`/setup`** -- First-time project bootstrap. Detects whether the project still has template placeholders (`__PROJECT_NAME__`, `__PROJECT_SLUG__`, and similar), collects project and client identity conversationally, replaces placeholders (everything under `.claude/` is explicitly excluded from replacement), fills the `CLAUDE.md` **Client Context** and **User Preferences** sections, writes `identity.clientBrief` in the organization model, installs dependencies, verifies the build, then hands off to `/om` for full organization-model configuration. All of its writes are idempotent -- re-running `/setup` on an already-bootstrapped project skips replacement and offers to re-verify only.
 
-- 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
+**`/om`** -- The only path to edits in `core/config/organization-model.ts`. Runs a snapshot-propose-confirm-write-validate-rollback ceremony rather than a direct file edit, because a change that passes TypeScript can still fail the model's Zod cross-reference validation (`resolveOrganizationModel()`).
 
-The agent does not prompt for confirmation on minor updates. Major changes (level upgrades) are surfaced to the user before writing.
+**`/deploy`** -- Test, build, commit, push pipeline.
 
-## Rules System
+**`/elevasis`** -- SDK operations entry point: `check` validates resource definitions, `deploy` bundles and uploads, `exec` runs a resource with input, plus `describe`, `logs`, and `creds`.
 
-Ten 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.
+**`/project`** -- Primary work-tracking entry point: portfolio orientation, intent detection (resume vs. new), and project/milestone/task/note lifecycle, all routed through the `elevasis-sdk project:*` CLI rather than files.
 
-Rules injected for operations source files (`operations/src/`):
+**`/git-sync`** -- Pulls the latest template changes, checks the installed `@elevasis/sdk` version against the declared range, reinstalls if the dependency baseline changed, and runs baseline verification (`ui check-types`, `ui build`, `operations check`, `operations check-types`). It stops after verifying -- it never auto-reconciles template drift or overwrites project-owned files. Release guidance is not delivered here; it ships inside the `@elevasis/sdk` reference bundle, which is always current for your installed version.
 
-- **`platform.md`** -- SDK adapter patterns, typed adapters, platform tool usage.
-- **`error-handling.md`** -- Error types (`ExecutionError`, `PlatformToolError`), retry behavior.
-- **`execution.md`** -- Worker thread model, timeouts, concurrency, org isolation.
-- **`observability.md`** -- Logging with `context.logger`, step-level auto-logging, debugging.
-- **`deployment.md`** -- Deploy commands, dev vs prod, version bumping, common errors.
+**`/tutorial`** -- Persona-aware onboarding; see [Tutorial System](tutorial-system.mdx) for the full lesson breakdown.
 
-Rules injected for docs files (`docs/`):
+## The Ambient Vibe Layer
 
-- **`docs.md`** -- Documentation structure, frontmatter conventions, auto-generated files.
-- **`task-tracking.md`** -- Task doc conventions, injected for in-progress files.
+External projects run an always-on natural-language intent classifier -- there is no `/vibe` command and no activation phrase. Every message is silently classified into one of seven intents (Capture, Query, Describe, Transition, Navigate, Codify, Toggle) before the agent responds. Codify and Toggle detect intent and delegate immediately to `/om`; the classifier never runs the organization-model ceremony itself. The full classifier definition and fixture tables ship with the SDK at `operations/node_modules/@elevasis/sdk/reference/rules/vibe.md`. Vibe is explicitly off inside the monorepo, which uses the task-class routing in `agent-start-here.md` instead.
 
-Additional contextual rules:
+## The Rules Layer
 
-- **`frontend.md`** -- React/Mantine patterns, injected for UI source files.
-- **`shared-types.md`** -- Cross-runtime type conventions, injected for foundations files.
-- **`organization-os.md`** -- Organization model and feature shell conventions.
+`.claude/rules/` in the git-tracked template holds short pointer files with `paths:` frontmatter that Claude Code auto-loads for matching files. The authoritative rule bodies ship with the installed `@elevasis/sdk` package at `operations/node_modules/@elevasis/sdk/reference/rules/` and update whenever the SDK dependency is bumped. Rules include `agent-start-here.md` (always-loaded), `vibe.md` (always-loaded), `organization-os.md`, `deployment.md`, `error-handling.md`, `execution.md`, `frontend.md`, `observability.md`, `operations.md`, `organization-model.md`, `platform.md`, `shared-types.md`, `task-tracking.md`, `ui.md`, and `active-change-index.md` (which flags areas under active platform change).
 
-## Interaction Guidance
+## Template Version Tracking
 
-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).
+The scaffold's version marker is `templateVersion` in the project-root `.elevasis` file (a flat YAML-like marker file, not `elevasis.config.ts`). `elevasis.config.ts` (`operations/elevasis.config.ts`) only accepts `defaultStatus` and `dev.port` -- it has no version field. To pull a template update, run `/git-sync`, not `/meta fix` (which does not exist in this template).
 
 ---
 
-**Last Updated:** 2026-04-17
+**Last Updated:** 2026-08-06

package/reference/sdk/framework/index.mdx

@@ -1,12 +1,12 @@
 ---
 title: Development Framework
-description: The SDK scaffolds a complete development environment for Claude Code -- project instructions, slash commands, cross-session memory, template versioning, and resource documentation
+description: The template ships an agent operating environment alongside your code -- always-loaded rules, slash-command skills, a two-track tutorial, and a small gitignored memory surface
 loadWhen: "Understanding the agent framework structure"
 ---
 
-Your Elevasis SDK project ships with 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.
+Your Elevasis SDK project ships with more than code. It builds an agent operating environment 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.
+The framework lives entirely in `.claude/`. It is never deployed and never bundled into `operations/dist/`.
 
 ## What Ships With Your Project
 
@@ -14,98 +14,79 @@ Your Elevasis SDK project includes the following agent infrastructure alongside
 
 ```
 .claude/
-├── settings.json               # Hook registrations (PostToolUse, PostToolUseFailure)
+├── Overview.md          # Routing map: skills, rules, hooks, project structure, stack, commands
+├── settings.json         # Hook registrations (PostToolUse, PostToolUseFailure) + statusline command
 ├── hooks/
-│   ├── post-edit-validate.mjs    # Formatting/type-check hook (after Write/Edit/MultiEdit)
-│   └── tool-failure-recovery.mjs # Error recovery hook (after Bash failures)
+│   ├── post-edit-validate.mjs        # Formatting/type-check hook (after Write/Edit/MultiEdit)
+│   ├── scaffold-registry-reminder.mjs # Reminds about generated-file regeneration
+│   └── tool-failure-recovery.mjs     # Error recovery hook (after Bash failures)
 ├── skills/
-│   ├── work/SKILL.md           # Task tracking across sessions
-│   ├── elevasis/SKILL.md       # SDK operations (check, deploy, exec)
-│   ├── deploy/skill.md         # Deploy pipeline
-│   ├── setup/SKILL.md          # First-time project setup
-│   ├── status/SKILL.md         # Project health check
-│   └── ...                     # Additional skills (dsp, continue, project, sync, explore, save)
-├── scripts/
-│   └── statusline-command.js   # Status line command
+│   ├── client/SKILL.md         # Client portfolio management
+│   ├── deploy/SKILL.md         # Test, build, commit, push pipeline
+│   ├── dsp/SKILL.md            # Parallel agent dispatch
+│   ├── elevasis/SKILL.md       # SDK operations -- check, deploy, exec, describe, logs, creds
+│   ├── explore/SKILL.md        # Codebase exploration anchored to docs
+│   ├── git-sync/SKILL.md       # Pull latest, install when the baseline moved, baseline-verify
+│   ├── om/SKILL.md             # Organization Model read/codify/toggle ceremony
+│   ├── project/SKILL.md        # Project/milestone/task/note lifecycle via elevasis-sdk project:*
+│   ├── run-ui/SKILL.md         # Start the Vite dev server on port 4300
+│   ├── save/SKILL.md           # Conversation fanout -- docs, task resume context, notes
+│   ├── setup/SKILL.md          # First-time project bootstrap, then hands off to /om
+│   ├── status/SKILL.md         # Quick project health check
+│   ├── submit-request/SKILL.md # Submit a structured request to the Elevasis platform
+│   ├── sync/SKILL.md           # Fresh reinstall and cache reset
+│   └── tutorial/SKILL.md       # Two-track onboarding (vibe-coder / technical)
+├── registries/            # Scaffold, skill-coverage, and knowledge registry data
 └── rules/
-    ├── sdk-patterns.md         # SDK patterns (auto-loaded for src/ files)
-    ├── docs-authoring.md       # MDX conventions (auto-loaded for docs/ files)
-    ├── task-tracking.md        # Task tracking conventions (auto-loaded)
-    ├── platform.md             # Platform tool patterns
-    ├── error-handling.md       # Error handling patterns
-    └── workspace-patterns.md   # Project-specific patterns (grows over time)
+    ├── agent-start-here.md   # Session bootstrap pointer, task-class routing, boundary resolution
+    ├── vibe.md                # Ambient intent classifier (always on in external projects)
+    └── ...                    # Thin pointers to the bundled rule bodies (see below)
 ```
 
-The `memory/` directory is gitignored -- it is personal to each developer and not shared with collaborators. Everything else in `.claude/` is committed.
+`.claude/Overview.md` is the authoritative routing map for this directory -- read it first. It is template-owned and replaced on every sync; project-specific facts live in `CLAUDE.md` (never overwritten) and tenant operational quirks live in `OPERATIONS.md` (also never overwritten).
 
-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.
+The rule _bodies_ referenced by `.claude/rules/*.md` ship with the installed `@elevasis/sdk` package, not the git-tracked template: `operations/node_modules/@elevasis/sdk/reference/rules/`. The local `.claude/rules/` files are short pointers with `paths:` frontmatter that Claude Code auto-loads; the full content lives in the installed package and updates whenever you bump `@elevasis/sdk`.
+
+`.claude/memory/` is not part of the scaffold -- it does not ship with the template and is gitignored. It is created at runtime the first time a skill needs to persist state (for example, `/tutorial` creates `.claude/memory/profile.md` on first invocation). It is personal to each developer and not shared with collaborators.
 
 ## 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.
+- **Session orientation** -- `agent-start-here.md` is the canonical first-read: it establishes that project context (milestones, tasks, resume notes) is DB-canonical through `elevasis-sdk project:*`, not files, and that a tenant's own `OPERATIONS.md` outranks generic guidance.
+- **What has happened in this project** -- deployment state and architectural facts live in `OPERATIONS.md` and `CONNECTIONS.md` (both tenant-owned, never overwritten by sync), plus whatever the agent has written to the gitignored `.claude/memory/`.
+- **How to behave** -- the ambient vibe layer (see [Agent System](agent.mdx)) classifies every natural-language message into an intent before the agent responds, and the `/tutorial` track choice in `.claude/memory/profile.md` shapes vocabulary and tone project-wide once set.
 
 ## 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 `/meta` command manages the project lifecycle: `/meta init` for guided setup, `/meta fix` for SDK upgrades, drift repair, and documentation verification, `/meta deploy` for deployments, `/meta health` for debugging executions. `/docs` browses, creates, and verifies permanent documentation in `docs/`. `/work` tracks tasks across sessions, and `/tutorial` guides new developers through a menu-driven multi-track learning path. A `creds` skill auto-triggers when credential setup is needed.
-
-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.
+`CLAUDE.md` is project-owned and carries identity and preferences only -- it deliberately has no session-bootstrap procedure, because `.claude/rules/agent-start-here.md` owns that. `.claude/Overview.md` is the template-owned routing map for skills, rules, hooks, project structure, stack, and commands.
 
-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.
+The skill layer covers the full development loop: `/setup` for first-time bootstrap, `/om` for organization-model edits, `/project` for portfolio and task work, `/elevasis` for SDK operations, `/deploy` for the test-build-commit-push pipeline, `/git-sync` for pulling template updates, and more. There is no `/meta`, `/docs`, or `/work` skill in the current template.
 
-See [Memory System](memory.mdx) for architecture, error tracking format, scaling rules, and maintenance guidelines.
+See [Agent System](agent.mdx) for the full skill inventory, the ambient vibe layer, and the session-bootstrap sequence.
 
 ### Project Structure
 
-The scaffolded project separates concerns clearly: `operations/` for executable resources, `core/` for shared contracts and Organization Model configuration, `ui/` for the shell, `docs/` for platform documentation, and `.claude/` for agent infrastructure. 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.
-
-## Adaptive Guidance
-
-The agent adapts its communication based on four independent skill dimensions stored in `memory/profile/skills.md`:
-
-| Dimension           | Levels                        | Assessment                       |
-| ------------------- | ----------------------------- | -------------------------------- |
-| Platform Navigation | none / oriented / comfortable | Direct question                  |
-| API & Integration   | none / basic / proficient     | Inferred from automation + tools |
-| Automation Concepts | none / low-code / custom      | Direct question                  |
-| Domain Expertise    | high / low                    | Inferred from identity answers   |
-
-Each dimension has its own adaptation rules in the [Interaction Guidance](interaction-guidance.mdx) reference. A user who has deep Zapier experience (automation: low-code) but has never called an API directly (apiIntegration: none) will get credential walkthroughs every time while having automation concepts treated as familiar ground.
+The scaffolded project separates concerns clearly: `operations/` for executable resources, `core/` for shared contracts and Organization Model configuration, `ui/` for the shell, and `.claude/` for agent infrastructure. There is no top-level `docs/` directory in the current template -- documentation content is not part of the deploy path.
 
-`/tutorial` runs the assessment via a single gate question on first invocation: are you here to build automations by describing what you want, or are you a developer who edits code directly. The choice persists to `.claude/memory/profile.md` and shapes the agent's tone, vocabulary, and tool-call visibility for the entire project, not just inside `/tutorial`. Within the chosen track, lessons adapt further -- senior devs in the technical track can mark Section A items complete to skip them.
+See [Project Structure](project-structure.mdx) for a directory-by-directory walkthrough of the scaffolded project.
 
-See [Agent System](agent.mdx) for the full assessment question set, dimensional interaction rules, and communication principles.
+### Onboarding
 
-### Skills Auto-Update
+`/tutorial` forks into a vibe-coder track (8 lessons, zero technical vocabulary) or a technical track (19 lessons across 5 sections, code-first) on first invocation, asking a single gate question. The choice persists to `.claude/memory/profile.md` and shapes agent tone project-wide, not just inside `/tutorial`.
 
-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.
+See [Tutorial System](tutorial-system.mdx) for the full lesson breakdown, track persistence, and switching behavior.
 
 ---
 
 ## Documentation
 
-- [Project Structure](project-structure.mdx) - File-by-file walkthrough of every scaffolded file and its purpose
-- [Agent System](agent.mdx) - CLAUDE.md sections, slash commands, developer profile, and adaptive guidance tiers
-- [Memory System](memory.mdx) - Architecture, error tracking format, scaling rules, and maintenance guidelines
-- [Interaction Guidance](interaction-guidance.mdx) - Dimensional adaptation rules per skill axis with growth tracking protocol
-- [Tutorial System](tutorial-system.mdx) - Two-track onboarding (8 vibe-coder + 19 technical lessons), skill-adaptive lesson variants, and progress tracking
-- [Resource Documentation](resource-documentation.mdx) - Docs directory structure, frontmatter schema, size limits, deploy behavior, and /docs command reference
+- [Project Structure](project-structure.mdx) - Directory-by-directory walkthrough of the scaffolded project
+- [Agent System](agent.mdx) - Skill inventory, rules layer, ambient vibe classifier, and session bootstrap
+- [Tutorial System](tutorial-system.mdx) - Two-track onboarding (8 vibe-coder + 19 technical lessons), track persistence, and progress tracking
 
 ---
 
-**Last Updated:** 2026-03-06
+**Last Updated:** 2026-08-06