roleMe

When

/roleMe

is called without parameters, first list existing roles for the user to choose and load; if the user does not want to load an existing role, first ask for the name of the role to be created, then proceed to the initialization process.

For detailed usage instructions, see

references/usage.md

Command interface:

```
/roleMe
```
```
/roleMe <role name>
```
```
/roleMe list
```
```
/roleMe optimize [role name]
```
```
/roleMe export [role name]
```
```
/roleMe doctor [role name]
```

Runtime principles:

```
roleMe
```
manages user role contexts, not assistant personality switching.
Role bundles are stored by default in
```
~/.roleMe/<role name>/
```
; do not guess paths in skill installation directories like
```
~/.agents/skills/roleme/roles/
```
.
When needing to list existing roles or check if a role exists, follow the semantics of
```
list_roles()
```
and
```
role_dir()
```
in
```
tools/role_ops.py
```
; do not manually write shell path detection.
Context not structurally written into the role bundle should not be assumed to be known by the model; stable information should be stored in retrievable locations within
```
persona/
```
,
```
memory/
```
,
```
brain/
```
, and
```
projects/
```
.
The boundary between the resident layer and the on-demand layer is determined by
```
AGENT.md
```
within the role bundle.
The resident layer should remain minimal and stable; details, thematic knowledge, and project context should be expanded on demand first, rather than being piled into a single overall description.
Memory write-back should prioritize following the strategy in
```
AGENT.md
```
and the
```
memory/
```
structure.
Thematic knowledge and project context are discovered progressively via
```
tools/context_router.py
```
; full loading at once is not allowed.
Users do not need to directly maintain the Graph; Context Graph is a background mechanism that does not change the user's normal conversation method.
Archived content should prioritize readability for agents: clear structure, clear boundaries, retrievable, incrementally updatable, rather than just being written as long free narratives.
The initialization interview can be dynamic: questions are determined by the model based on currently known information and information gaps, but must ultimately be structured into stable
```
persona/
```
,
```
memory/
```
,
```
brain/
```
, and
```
projects/
```
.
Slots are only archiving targets, not fixed question sequences; the model should determine the next question based on the current scenario, rather than mechanically executing a questionnaire.
The initialization interview should be more like an interview than filling out a form: information not expressed by the user can be left unrecorded first; do not repeatedly ask about the same slot just to complete it.
Slot prompts are only interview anchors, not the final verbatim questions; before actually asking the user, the prompt should be polished into natural spoken language combined with the current context.
When the user executes
```
/roleMe
```
without parameters for the first time, first list existing roles for the user to choose and load; if the user chooses to create a new role, first ask for the role name, then start the interview.
Language preferences should be explicitly asked once during initialization; if the user does not give a clear preference temporarily, it can be left blank and accumulated gradually during subsequent use.
After successful initialization, clearly remind the user to call
```
/roleMe <role name>
```
again to load the newly written role bundle into the snapshot used for subsequent conversations.
When a role is already loaded, if the user says "Help me summarize the working method of this project" or "Help me summarize it into a general working method", directly archive the result into the current role instead of just returning a normal summary text.
When a role is already loaded, if the user's content clearly belongs to learning accumulation, project review, methodology refinement, stable preferences, or long-term collaboration rules, the assistant should actively archive it without waiting for the user to explicitly issue an "archive" instruction.
Before archiving, first refine the original content, then determine the archiving location, rather than directly archiving the entire original conversation paragraph.
By default, write first, then inform the user of the archiving result with a short receipt.
When unsure, prioritize writing to
```
memory/episodes/
```
or project memory; do not easily promote to
```
memory/USER.md
```
and
```
memory/MEMORY.md
```
.

Project-level workflows are written to

projects/<project-slug>/workflows/index.md

and

projects/<project-slug>/workflows/<workflow-slug>.md

; general workflows are written to

brain/workflows/index.md

and

brain/workflows/<workflow-slug>.md

;

context.md

and

brain/index.md

only keep the entry to the workflow index, one file per workflow, and promote stable rules to

memory/USER.md

and

memory/MEMORY.md

The frozen snapshot generated by role loading should, in addition to resident files, prioritize carrying the "current project workflow summary" and "general workflow summary"; summaries come from their respective workflow indexes, not the workflow body.
The current role is determined by the role loaded in the current session; natural language archiving must be written to this session's role;
```
.current-role.json
```
is no longer used as the source of the current role.

If the user inputs

/roleMe current

, return the fixed prompt:

/roleMe current no longer supports global current role queries. Please re-execute /roleMe <role name> in the current session.

If archiving promotes resident rules or summaries, remind the user to re-execute
```
/roleMe <role name>
```
to refresh the current session base.
```
optimize
```
and
```
doctor
```
should prioritize discovering and fixing entropy increase issues in role bundles, such as duplicate memories, invalid indexes, and boundary drift between resident/on-demand layers.

Only deterministic file operations should call

tools/role_ops.py

tools/memory.py

, and

tools/context_router.py

The packaged product does not include the
```
scripts/
```
directory of the development repository.

roleme

NPX Install

Tags

SKILL.md Content (Chinese)

roleMe