bots-garden/mini-me · e72e039

modified .tickets/issues/0213-mm-acp-create-a-skillcreate-command-mm-skillcrea.yaml +89 -9 Viewed

@@ -1,12 +1,12 @@
1	1	# Managed by IssueSpec. Hand edits are welcome; keep the schema valid.
2	2	id: 213
3	3	title: "mm acp-create: a /skillcreate command (mm skillcreate from the editor)"
4		-state: open
	4	+state: closed
5	5	author:
6	6	name: k33g
7	7	email: ph.charriere@gmail.com
8	8	createdAt: 2026-11-14T07:25:21.000Z
9		-updatedAt: 2026-11-14T07:25:21.000Z
	9	+updatedAt: 2026-11-15T03:49:13.000Z
10	10	labels:
11	11	- enhancement
12	12	- kind::feature
@@ -91,50 +91,130 @@ body: \|
91	91	tasks:
92	92	- id: 1
93	93	title: Locate the skills directory for a given project directory, without loading the config into the global settings
94		- state: open
	94	+ state: closed
95	95	priority: high
96	96	author:
97	97	name: k33g
98	98	email: ph.charriere@gmail.com
99	99	createdAt: 2026-11-14T07:25:21.000Z
	100	+ updatedAt: 2026-11-15T03:02:04.000Z
	101	+ closedAt: 2026-11-15T03:02:04.000Z
100	102	- id: 2
101	103	title: Let the acp-create session drive either flow (agent or skill) - one interface over agentinit.Flow and skillcreate.Flow
102		- state: open
	104	+ state: closed
103	105	priority: high
104	106	author:
105	107	name: k33g
106	108	email: ph.charriere@gmail.com
107	109	createdAt: 2026-11-14T07:25:21.000Z
	110	+ updatedAt: 2026-11-15T03:02:04.000Z
	111	+ closedAt: 2026-11-15T03:02:04.000Z
108	112	- id: 3
109	113	title: /skillcreate command - flags as given answers, conversation mode and forms, multi-line text
110		- state: open
	114	+ state: closed
111	115	priority: medium
112	116	author:
113	117	name: k33g
114	118	email: ph.charriere@gmail.com
115	119	createdAt: 2026-11-14T07:25:21.000Z
	120	+ updatedAt: 2026-11-15T03:02:04.000Z
	121	+ closedAt: 2026-11-15T03:02:04.000Z
116	122	- id: 4
117	123	title: End message - written path, mm reads it back, the skillsDir note, reload the agent to see the skill
118		- state: open
	124	+ state: closed
119	125	priority: medium
120	126	author:
121	127	name: k33g
122	128	email: ph.charriere@gmail.com
123	129	createdAt: 2026-11-14T07:25:21.000Z
	130	+ updatedAt: 2026-11-15T03:02:04.000Z
	131	+ closedAt: 2026-11-15T03:02:04.000Z
124	132	- id: 5
125	133	title: Tests with the fake client - same SKILL.md as mm skillcreate with the same answers, both modes
126		- state: open
	134	+ state: closed
127	135	priority: medium
128	136	author:
129	137	name: k33g
130	138	email: ph.charriere@gmail.com
131	139	createdAt: 2026-11-14T07:25:21.000Z
	140	+ updatedAt: 2026-11-15T03:02:04.000Z
	141	+ closedAt: 2026-11-15T03:02:04.000Z
132	142	- id: 6
133	143	title: Docs EN+FR - how-to create-an-agent-from-an-editor, cli.md acp-create section
134		- state: open
	144	+ state: closed
135	145	priority: medium
136	146	author:
137	147	name: k33g
138	148	email: ph.charriere@gmail.com
139	149	createdAt: 2026-11-14T07:25:21.000Z
140		-comments: []
	150	+ updatedAt: 2026-11-15T03:02:04.000Z
	151	+ closedAt: 2026-11-15T03:02:04.000Z
	152	+comments:
	153	+ - id: 1
	154	+ author:
	155	+ name: k33g
	156	+ email: ph.charriere@gmail.com
	157	+ createdAt: 2026-11-15T03:02:04.000Z
	158	+ body: \|
	159	+ Implemented on `feature/acp-skillcreate` (uncommitted).
	160	+
	161	+ - `skillcreate.LocateIn(dir)`: the skills directory of the project in
	162	+ dir (agent.yaml, then .mm/agent.yaml; skillsDir read with yaml, not
	163	+ `config.Load`; mm's default `skills` kept as a const, a test checks
	164	+ it equals internal/config's). `skillcreate.WriteSkill` (shared with
	165	+ mm skillcreate's `finish`), `Flow.SetGiven` exported.
	166	+ - acp-create: a `wizard` interface (both flows satisfy it) and a
	167	+ `run` per wizard (asked, answered, deps, finish, preview); the
	168	+ session asks the skill run while one exists, else the agent's.
	169	+ `/skillcreate [--name] [--description] [--keywords] [--body]`
	170	+ (quoted values), `/cancel`; `/preview`, `/back`, `/write`,
	171	+ `/restart`, `/start` act on the current run.
	172	+ - Open decision taken as proposed: during the agent's questions, the
	173	+ skill runs beside them, the answers are kept, and the agent's current
	174	+ question comes back once the skill is written or cancelled.
	175	+ - The text (`body`) is asked as a message even in form mode (no known
	176	+ multi-line field in forms); the one-line answers go in forms. An
	177	+ optional answer says "`.` for none".
	178	+
	179	+ Tests: SKILL.md byte for byte what `mm skillcreate --yes --line`
	180	+ writes with the same answers, line breaks kept, read back by mm; back
	181	+ to the agent with its answers; `/cancel`; an existing skill asks
	182	+ before it is replaced (`no` → name again); forms (name, description,
	183	+ keywords in one form, text as a message); global `config.Cfg.SkillsDir`
	184	+ unchanged; `splitArgs`. End to end with the real binary over stdio in
	185	+ a `.mm` project: `.mm/skills/vulcan-salute/SKILL.md` written,
	186	+ `✅ mm reads it`.
	187	+
	188	+ Limit: before the agent file is written, `.mm/` does not exist yet, so
	189	+ a skill made half way through a Project-layout agent goes to
	190	+ `skills/` (with the note) — documented: create the agent first.
	191	+ Not tried in Zed.
	192	+ - id: 2
	193	+ author:
	194	+ name: k33g
	195	+ email: ph.charriere@gmail.com
	196	+ createdAt: 2026-11-15T03:32:10.000Z
	197	+ body: \|
	198	+ User (2026-11-15): `/skillcreate` did not check whether the agent uses
	199	+ a `.mm` folder. Reproduced with the real binary: with the agent file
	200	+ written (skills on or off), the skill went to `.mm/skills`; with the
	201	+ agent still being created in the session and the `.mm` layout
	202	+ answered, it went to `skills/` (`.mm/` only exists once the agent file
	203	+ is written — the limit noted in comment 1).
	204	+
	205	+ Fixed: with no agent file on disk, `/skillcreate` reads the answers
	206	+ of the session's agent wizard (`agentinit.Flow.Choices`, no server
	207	+ call): layout answered → that agent's `skillsDir` (`.mm/skills` with
	208	+ the `.mm` layout, `skills` otherwise), with a note when "Use skills?"
	209	+ is not answered yet or answered no. Layout not answered → LocateIn as
	210	+ before. Checked again on the four cases (written with/without skills,
	211	+ in progress, in progress with `--skills yes`): all in `.mm/skills`.
	212	+ Test `TestPendingAgentPlace`; docs EN+FR updated (the limit is gone).
	213	+ - id: 3
	214	+ author:
	215	+ name: k33g
	216	+ email: ph.charriere@gmail.com
	217	+ createdAt: 2026-11-15T03:36:45.000Z
	218	+ body: \|
	219	+ Tried by the user (2026-11-15): works.
	220	+

  # Managed by IssueSpec. Hand edits are welcome; keep the schema valid.
  id: 213
  title: "mm acp-create: a /skillcreate command (mm skillcreate from the editor)"
--state: open
++state: closed
  author:
    name: k33g
    email: ph.charriere@gmail.com
  createdAt: 2026-11-14T07:25:21.000Z
--updatedAt: 2026-11-14T07:25:21.000Z
++updatedAt: 2026-11-15T03:49:13.000Z
  labels:
    - enhancement
    - kind::feature
  tasks:
    - id: 1
      title: Locate the skills directory for a given project directory, without loading the config into the global settings
--    state: open
++    state: closed
      priority: high
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
    - id: 2
      title: Let the acp-create session drive either flow (agent or skill) - one interface over agentinit.Flow and skillcreate.Flow
--    state: open
++    state: closed
      priority: high
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
    - id: 3
      title: /skillcreate command - flags as given answers, conversation mode and forms, multi-line text
--    state: open
++    state: closed
      priority: medium
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
    - id: 4
      title: End message - written path, mm reads it back, the skillsDir note, reload the agent to see the skill
--    state: open
++    state: closed
      priority: medium
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
    - id: 5
      title: Tests with the fake client - same SKILL.md as mm skillcreate with the same answers, both modes
--    state: open
++    state: closed
      priority: medium
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
    - id: 6
      title: Docs EN+FR - how-to create-an-agent-from-an-editor, cli.md acp-create section
--    state: open
++    state: closed
      priority: medium
      author:
        name: k33g
        email: ph.charriere@gmail.com
      createdAt: 2026-11-14T07:25:21.000Z
--comments: []
++    updatedAt: 2026-11-15T03:02:04.000Z
++    closedAt: 2026-11-15T03:02:04.000Z
++comments:
++  - id: 1
++    author:
++      name: k33g
++      email: ph.charriere@gmail.com
++    createdAt: 2026-11-15T03:02:04.000Z
++    body: |
++      Implemented on `feature/acp-skillcreate` (uncommitted).
++
++      - `skillcreate.LocateIn(dir)`: the skills directory of the project in
++        dir (agent.yaml, then .mm/agent.yaml; skillsDir read with yaml, not
++        `config.Load`; mm's default `skills` kept as a const, a test checks
++        it equals internal/config's). `skillcreate.WriteSkill` (shared with
++        mm skillcreate's `finish`), `Flow.SetGiven` exported.
++      - acp-create: a `wizard` interface (both flows satisfy it) and a
++        `run` per wizard (asked, answered, deps, finish, preview); the
++        session asks the skill run while one exists, else the agent's.
++        `/skillcreate [--name] [--description] [--keywords] [--body]`
++        (quoted values), `/cancel`; `/preview`, `/back`, `/write`,
++        `/restart`, `/start` act on the current run.
++      - Open decision taken as proposed: during the agent's questions, the
++        skill runs beside them, the answers are kept, and the agent's current
++        question comes back once the skill is written or cancelled.
++      - The text (`body`) is asked as a message even in form mode (no known
++        multi-line field in forms); the one-line answers go in forms. An
++        optional answer says "`.` for none".
++
++      Tests: SKILL.md byte for byte what `mm skillcreate --yes --line`
++      writes with the same answers, line breaks kept, read back by mm; back
++      to the agent with its answers; `/cancel`; an existing skill asks
++      before it is replaced (`no` → name again); forms (name, description,
++      keywords in one form, text as a message); global `config.Cfg.SkillsDir`
++      unchanged; `splitArgs`. End to end with the real binary over stdio in
++      a `.mm` project: `.mm/skills/vulcan-salute/SKILL.md` written,
++      `✅ mm reads it`.
++
++      Limit: before the agent file is written, `.mm/` does not exist yet, so
++      a skill made half way through a Project-layout agent goes to
++      `skills/` (with the note) — documented: create the agent first.
++      Not tried in Zed.
++  - id: 2
++    author:
++      name: k33g
++      email: ph.charriere@gmail.com
++    createdAt: 2026-11-15T03:32:10.000Z
++    body: |
++      User (2026-11-15): `/skillcreate` did not check whether the agent uses
++      a `.mm` folder. Reproduced with the real binary: with the agent file
++      written (skills on or off), the skill went to `.mm/skills`; with the
++      agent **still being created** in the session and the `.mm` layout
++      answered, it went to `skills/` (`.mm/` only exists once the agent file
++      is written — the limit noted in comment 1).
++
++      Fixed: with no agent file on disk, `/skillcreate` reads the answers
++      of the session's agent wizard (`agentinit.Flow.Choices`, no server
++      call): layout answered → that agent's `skillsDir` (`.mm/skills` with
++      the `.mm` layout, `skills` otherwise), with a note when "Use skills?"
++      is not answered yet or answered no. Layout not answered → LocateIn as
++      before. Checked again on the four cases (written with/without skills,
++      in progress, in progress with `--skills yes`): all in `.mm/skills`.
++      Test `TestPendingAgentPlace`; docs EN+FR updated (the limit is gone).
++  - id: 3
++    author:
++      name: k33g
++      email: ph.charriere@gmail.com
++    createdAt: 2026-11-15T03:36:45.000Z
++    body: |
++      Tried by the user (2026-11-15): works.
++

modified docs/en/how-to/create-an-agent-from-an-editor.md +12 -0 Viewed

@@ -45,8 +45,20 @@ This guide shows how to create an agent.yaml without a terminal, from any editor
45	45	\| `/dockerinit` \| Writes a `Dockerfile` and a `compose.yaml` in the project to run the agent in a container — `mm dockerinit` for this project. Takes its flags (`--name`, `--agent`); existing files are kept unless you add `--overwrite`. \|
46	46	\| `/zedconfig` \| Shows Zed's `agent_servers` entries for this project's agent, from what the project holds: `mm acp <agent file>` always; with a `compose.yaml`, `docker exec -i <container> mm -acp -config <agent file>`; with a `sbxenv.yaml`, `sbx exec -i <sandbox> mm -acp -config <agent file>` — each with what to start first. \|
47	47	\| `/sbxinit` \| Writes a `sbxenv.yaml` in the project to run the agent in a Docker Sandbox — `mm sbxinit` for this project. Takes its flags (`--name`, `--workspace`, `--agent`); an existing `sbxenv.yaml` is kept unless you add `--overwrite`. Works at any time; after the agent is written, the sandbox is named after it. \|
	48	+\| `/skillcreate` \| Creates a skill for the project's agent — `mm skillcreate` for this project: see [Create a skill from the same thread](#create-a-skill-from-the-same-thread). \|
	49	+\| `/cancel` \| Gives up the skill being created; the agent's questions come back. \|
48	50	\| `/help` \| Lists these commands. \|
49	51
	52	+## Create a skill from the same thread
	53	+
	54	+Send `/skillcreate`. It asks what `mm skillcreate` asks in a terminal — the skill's name, a one-line description, keywords (`.` for none) and the text — and writes `<skillsDir>/<name>/SKILL.md` where the project's agent reads its skills: the `skillsDir` of its `agent.yaml` or `.mm/agent.yaml`. Without an agent file, or with `skillsDir: no-skills`, the skill goes to `.mm/skills` when the project has a `.mm` folder — or when the agent being created in this thread uses one —, else to `skills`, and mm says which `skillsDir` to set.
	55	+
	56	+- The flags answer in advance: `/skillcreate --name "Vulcan Salute" --description "Greets the Vulcan way" --keywords "vulcan, greeting"`. Quote a value with spaces.
	57	+- The text is one message: several lines are fine. With a client that shows forms, the other questions come in a form and the text is still asked as a message.
	58	+- An existing skill is replaced only if you answer `yes`; `no` asks for another name.
	59	+- In the middle of the agent's questions, the answers given so far are kept: once the skill is written — or given up with `/cancel` — the agent's current question comes back. Before its file is written, the skill goes where that agent will read its skills: `.mm/skills` once you answered `yes` to Keep everything in a .mm folder?, and mm reminds you to answer `yes` to Use skills?.
	60	+- After writing, mm reads the skill back (`✅ mm reads it: …`). An agent already running sees it once it restarts (Reload Agent).
	61	+
50	62	## Variations
51	63
52	64	- Fix answers in advance. The flags of `mm init` work here (`--provider`, `--base-url`, `--model`, `--usage`, `--project yes`…): a question whose flag is given is not asked. For example `"args": ["acp-create", "--provider", "llmman", "--project", "yes"]`.

  | `/dockerinit` | Writes a `Dockerfile` and a `compose.yaml` in the project to run the agent in a container — `mm dockerinit` for this project. Takes its flags (`--name`, `--agent`); existing files are kept unless you add `--overwrite`. |
  | `/zedconfig` | Shows Zed's `agent_servers` entries for this project's agent, from what the project holds: `mm acp <agent file>` always; with a `compose.yaml`, `docker exec -i <container> mm -acp -config <agent file>`; with a `sbxenv.yaml`, `sbx exec -i <sandbox> mm -acp -config <agent file>` — each with what to start first. |
  | `/sbxinit` | Writes a `sbxenv.yaml` in the project to run the agent in a Docker Sandbox — `mm sbxinit` for this project. Takes its flags (`--name`, `--workspace`, `--agent`); an existing `sbxenv.yaml` is kept unless you add `--overwrite`. Works at any time; after the agent is written, the sandbox is named after it. |
++| `/skillcreate` | Creates a skill for the project's agent — `mm skillcreate` for this project: see [Create a skill from the same thread](#create-a-skill-from-the-same-thread). |
++| `/cancel` | Gives up the skill being created; the agent's questions come back. |
  | `/help` | Lists these commands. |
++## Create a skill from the same thread
++
++Send `/skillcreate`. It asks what `mm skillcreate` asks in a terminal — the skill's name, a one-line description, keywords (`.` for none) and the text — and writes `<skillsDir>/<name>/SKILL.md` where the project's agent reads its skills: the `skillsDir` of its `agent.yaml` or `.mm/agent.yaml`. Without an agent file, or with `skillsDir: no-skills`, the skill goes to `.mm/skills` when the project has a `.mm` folder — or when the agent being created in this thread uses one —, else to `skills`, and mm says which `skillsDir` to set.
++
++- **The flags answer in advance:** `/skillcreate --name "Vulcan Salute" --description "Greets the Vulcan way" --keywords "vulcan, greeting"`. Quote a value with spaces.
++- **The text** is one message: several lines are fine. With a client that shows forms, the other questions come in a form and the text is still asked as a message.
++- **An existing skill** is replaced only if you answer `yes`; `no` asks for another name.
++- **In the middle of the agent's questions,** the answers given so far are kept: once the skill is written — or given up with `/cancel` — the agent's current question comes back. Before its file is written, the skill goes where that agent will read its skills: `.mm/skills` once you answered `yes` to *Keep everything in a .mm folder?*, and mm reminds you to answer `yes` to *Use skills?*.
++- After writing, mm reads the skill back (`✅ mm reads it: …`). An agent already running sees it once it restarts (*Reload Agent*).
++
  ## Variations
  - **Fix answers in advance.** The flags of `mm init` work here (`--provider`, `--base-url`, `--model`, `--usage`, `--project yes`…): a question whose flag is given is not asked. For example `"args": ["acp-create", "--provider", "llmman", "--project", "yes"]`.

modified docs/en/reference/cli.md +1 -1 Viewed

@@ -280,7 +280,7 @@ An agent file outside the workspace only gives a warning: see [when the agent fi
280	280	\| Sessions \| One wizard per `session/new`. Relative files are written in the session's `cwd`. After the `session/new` response, an `agent_message_chunk` says to send `/start`. `/start` or the first prompt, whatever its text, starts the wizard. \|
281	281	\| Questions \| Chosen from the client's capabilities only. `clientCapabilities.elicitation.form` present: `elicitation/create` forms (session-scoped), as many questions per form as possible — a form never holds a question together with one its choices or default depend on (model after server, family after model, ask-first and name after usage, skills and file after layout, overwrite after file). Absent: one `agent_message_chunk` per question, numbered choices; the next prompt answers it — a number, a value, or `.` / `default` / `/skip` for the default. \|
282	282	\| Form outcomes \| Declined or cancelled: nothing written, the next prompt asks again. Three forms in a row with no usable answer: the wizard stops. \|
283		-\| Commands (`available_commands_update`) \| `start`, `preview`, `back`, `write`, `restart`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig`: one `agent_servers` JSON block for the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`) — an entry `mm-<project>` running `mm acp <absolute path>`; with `compose.yaml`, `mm-<project> (container)` running `docker exec -i <container_name> mm -acp -config <path>`; with `sbxenv.yaml`, `mm-<project> (sandbox)` running `sbx exec -i <name> mm -acp -config <path>` — then one line per entry saying what to start first. No agent file: a pointer to `/start`. `dockerinit` and `sbxinit` (input hint: their flags) run [`mm dockerinit`](#mm-dockerinit--the-container-files) and [`mm sbxinit`](#mm-sbxinit--the-sandbox-file) with the session's `cwd` as current directory, their output in one message; `--overwrite` replaces existing files, which are otherwise kept (nothing can be asked). \|
	283	+\| Commands (`available_commands_update`) \| `start`, `preview`, `back`, `write`, `restart`, `skillcreate`, `cancel`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig`: one `agent_servers` JSON block for the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`) — an entry `mm-<project>` running `mm acp <absolute path>`; with `compose.yaml`, `mm-<project> (container)` running `docker exec -i <container_name> mm -acp -config <path>`; with `sbxenv.yaml`, `mm-<project> (sandbox)` running `sbx exec -i <name> mm -acp -config <path>` — then one line per entry saying what to start first. No agent file: a pointer to `/start`. `skillcreate` (input hint: `--name`, `--description`, `--keywords`, quoted values allowed) asks the questions of [`mm skillcreate`](#mm-skillcreate--the-skill-wizard) — forms for the one-line answers when the client shows them, the text always as a message — and writes the skill in the `skillsDir` of the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`, read without loading it into the process's settings), else — no agent file yet — the `skillsDir` the agent being created in this session will have (`.mm/skills` with the `.mm` layout), else `.mm/skills` or `skills`, with a note; the agent's answers are kept and its current question comes back after the skill, or after `cancel`. `dockerinit` and `sbxinit` (input hint: their flags) run [`mm dockerinit`](#mm-dockerinit--the-container-files) and [`mm sbxinit`](#mm-sbxinit--the-sandbox-file) with the session's `cwd` as current directory, their output in one message; `--overwrite` replaces existing files, which are otherwise kept (nothing can be asked). \|
284	284	\| After writing \| The messages of `mm init` (`✅ wrote <file>`, `✅ mm loads it`), then `mm acp <absolute path>`, a pointer to `/zedconfig`, and one to `/dockerinit` and `/sbxinit`; for a client whose `clientInfo.name` contains `zed`, an `agent_servers` snippet too. Later prompts answer that the file is written. \|
285	285	\| Exit codes \| 0 the client closed the connection, or `-h`; 1 a refused flag value or presets that do not load; 2 a bad flag. \|
286	286

  | Sessions | One wizard per `session/new`. Relative files are written in the session's `cwd`. After the `session/new` response, an `agent_message_chunk` says to send `/start`. `/start` or the first prompt, whatever its text, starts the wizard. |
  | Questions | Chosen from the client's capabilities only. `clientCapabilities.elicitation.form` present: `elicitation/create` forms (session-scoped), as many questions per form as possible — a form never holds a question together with one its choices or default depend on (model after server, family after model, ask-first and name after usage, skills and file after layout, overwrite after file). Absent: one `agent_message_chunk` per question, numbered choices; the next prompt answers it — a number, a value, or `.` / `default` / `/skip` for the default. |
  | Form outcomes | Declined or cancelled: nothing written, the next prompt asks again. Three forms in a row with no usable answer: the wizard stops. |
--| Commands (`available_commands_update`) | `start`, `preview`, `back`, `write`, `restart`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig`: one `agent_servers` JSON block for the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`) — an entry `mm-<project>` running `mm acp <absolute path>`; with `compose.yaml`, `mm-<project> (container)` running `docker exec -i <container_name> mm -acp -config <path>`; with `sbxenv.yaml`, `mm-<project> (sandbox)` running `sbx exec -i <name> mm -acp -config <path>` — then one line per entry saying what to start first. No agent file: a pointer to `/start`. `dockerinit` and `sbxinit` (input hint: their flags) run [`mm dockerinit`](#mm-dockerinit--the-container-files) and [`mm sbxinit`](#mm-sbxinit--the-sandbox-file) with the session's `cwd` as current directory, their output in one message; `--overwrite` replaces existing files, which are otherwise kept (nothing can be asked). |
++| Commands (`available_commands_update`) | `start`, `preview`, `back`, `write`, `restart`, `skillcreate`, `cancel`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig`: one `agent_servers` JSON block for the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`) — an entry `mm-<project>` running `mm acp <absolute path>`; with `compose.yaml`, `mm-<project> (container)` running `docker exec -i <container_name> mm -acp -config <path>`; with `sbxenv.yaml`, `mm-<project> (sandbox)` running `sbx exec -i <name> mm -acp -config <path>` — then one line per entry saying what to start first. No agent file: a pointer to `/start`. `skillcreate` (input hint: `--name`, `--description`, `--keywords`, quoted values allowed) asks the questions of [`mm skillcreate`](#mm-skillcreate--the-skill-wizard) — forms for the one-line answers when the client shows them, the text always as a message — and writes the skill in the `skillsDir` of the agent file found in the session's `cwd` (`agent.yaml`, then `.mm/agent.yaml`, read without loading it into the process's settings), else — no agent file yet — the `skillsDir` the agent being created in this session will have (`.mm/skills` with the `.mm` layout), else `.mm/skills` or `skills`, with a note; the agent's answers are kept and its current question comes back after the skill, or after `cancel`. `dockerinit` and `sbxinit` (input hint: their flags) run [`mm dockerinit`](#mm-dockerinit--the-container-files) and [`mm sbxinit`](#mm-sbxinit--the-sandbox-file) with the session's `cwd` as current directory, their output in one message; `--overwrite` replaces existing files, which are otherwise kept (nothing can be asked). |
  | After writing | The messages of `mm init` (`✅ wrote <file>`, `✅ mm loads it`), then `mm acp <absolute path>`, a pointer to `/zedconfig`, and one to `/dockerinit` and `/sbxinit`; for a client whose `clientInfo.name` contains `zed`, an `agent_servers` snippet too. Later prompts answer that the file is written. |
  | Exit codes | 0 the client closed the connection, or `-h`; 1 a refused flag value or presets that do not load; 2 a bad flag. |

modified docs/fr/how-to/create-an-agent-from-an-editor.md +12 -0 Viewed

@@ -45,8 +45,20 @@ Ce guide montre comment créer un agent.yaml sans terminal, depuis n'importe que
45	45	\| `/dockerinit` \| Écrit un `Dockerfile` et un `compose.yaml` dans le projet pour faire tourner l'agent dans un conteneur — `mm dockerinit` pour ce projet. Accepte ses options (`--name`, `--agent`) ; les fichiers existants sont gardés sauf si vous ajoutez `--overwrite`. \|
46	46	\| `/zedconfig` \| Affiche les entrées `agent_servers` de Zed pour l'agent de ce projet, d'après ce que contient le projet : `mm acp <fichier d'agent>` toujours ; avec un `compose.yaml`, `docker exec -i <conteneur> mm -acp -config <fichier d'agent>` ; avec un `sbxenv.yaml`, `sbx exec -i <sandbox> mm -acp -config <fichier d'agent>` — chacune avec ce qu'il faut lancer avant. \|
47	47	\| `/sbxinit` \| Écrit un `sbxenv.yaml` dans le projet pour faire tourner l'agent dans un Docker Sandbox — `mm sbxinit` pour ce projet. Accepte ses options (`--name`, `--workspace`, `--agent`) ; un `sbxenv.yaml` existant est gardé sauf si vous ajoutez `--overwrite`. Marche à tout moment ; une fois l'agent écrit, le sandbox porte son nom. \|
	48	+\| `/skillcreate` \| Crée une skill pour l'agent du projet — `mm skillcreate` pour ce projet : voir [Créer une skill dans la même conversation](#créer-une-skill-dans-la-même-conversation). \|
	49	+\| `/cancel` \| Abandonne la skill en cours ; les questions de l'agent reviennent. \|
48	50	\| `/help` \| Liste ces commandes. \|
49	51
	52	+## Créer une skill dans la même conversation
	53	+
	54	+Envoyez `/skillcreate`. Il pose les questions de `mm skillcreate` dans un terminal — le nom de la skill, une description sur une ligne, des mots-clés (`.` pour aucun) et le texte — et écrit `<skillsDir>/<nom>/SKILL.md` là où l'agent du projet lit ses skills : le `skillsDir` de son `agent.yaml` ou de son `.mm/agent.yaml`. Sans fichier d'agent, ou avec `skillsDir: no-skills`, la skill va dans `.mm/skills` quand le projet a un dossier `.mm` — ou quand l'agent en cours de création dans cette conversation en utilise un —, sinon dans `skills`, et mm dit quel `skillsDir` définir.
	55	+
	56	+- Les options répondent à l'avance : `/skillcreate --name "Vulcan Salute" --description "Greets the Vulcan way" --keywords "vulcan, greeting"`. Mettez entre guillemets une valeur qui contient des espaces.
	57	+- Le texte tient en un message : plusieurs lignes sont possibles. Avec un client qui affiche des formulaires, les autres questions arrivent dans un formulaire et le texte est quand même demandé en message.
	58	+- Une skill existante n'est remplacée que si vous répondez `yes` ; `no` redemande un nom.
	59	+- Au milieu des questions de l'agent, les réponses déjà données sont gardées : une fois la skill écrite — ou abandonnée avec `/cancel` — la question de l'agent en cours revient. Tant que son fichier n'est pas écrit, la skill va là où cet agent lira ses skills : `.mm/skills` dès que vous avez répondu `yes` à Keep everything in a .mm folder?, et mm vous rappelle de répondre `yes` à Use skills?.
	60	+- Après l'écriture, mm relit la skill (`✅ mm reads it: …`). Un agent déjà lancé la voit une fois redémarré (Reload Agent).
	61	+
50	62	## Variantes
51	63
52	64	- Fixer des réponses à l'avance. Les options de `mm init` marchent ici (`--provider`, `--base-url`, `--model`, `--usage`, `--project yes`…) : une question dont l'option est donnée n'est pas posée. Par exemple `"args": ["acp-create", "--provider", "llmman", "--project", "yes"]`.

  | `/dockerinit` | Écrit un `Dockerfile` et un `compose.yaml` dans le projet pour faire tourner l'agent dans un conteneur — `mm dockerinit` pour ce projet. Accepte ses options (`--name`, `--agent`) ; les fichiers existants sont gardés sauf si vous ajoutez `--overwrite`. |
  | `/zedconfig` | Affiche les entrées `agent_servers` de Zed pour l'agent de ce projet, d'après ce que contient le projet : `mm acp <fichier d'agent>` toujours ; avec un `compose.yaml`, `docker exec -i <conteneur> mm -acp -config <fichier d'agent>` ; avec un `sbxenv.yaml`, `sbx exec -i <sandbox> mm -acp -config <fichier d'agent>` — chacune avec ce qu'il faut lancer avant. |
  | `/sbxinit` | Écrit un `sbxenv.yaml` dans le projet pour faire tourner l'agent dans un Docker Sandbox — `mm sbxinit` pour ce projet. Accepte ses options (`--name`, `--workspace`, `--agent`) ; un `sbxenv.yaml` existant est gardé sauf si vous ajoutez `--overwrite`. Marche à tout moment ; une fois l'agent écrit, le sandbox porte son nom. |
++| `/skillcreate` | Crée une skill pour l'agent du projet — `mm skillcreate` pour ce projet : voir [Créer une skill dans la même conversation](#créer-une-skill-dans-la-même-conversation). |
++| `/cancel` | Abandonne la skill en cours ; les questions de l'agent reviennent. |
  | `/help` | Liste ces commandes. |
++## Créer une skill dans la même conversation
++
++Envoyez `/skillcreate`. Il pose les questions de `mm skillcreate` dans un terminal — le nom de la skill, une description sur une ligne, des mots-clés (`.` pour aucun) et le texte — et écrit `<skillsDir>/<nom>/SKILL.md` là où l'agent du projet lit ses skills : le `skillsDir` de son `agent.yaml` ou de son `.mm/agent.yaml`. Sans fichier d'agent, ou avec `skillsDir: no-skills`, la skill va dans `.mm/skills` quand le projet a un dossier `.mm` — ou quand l'agent en cours de création dans cette conversation en utilise un —, sinon dans `skills`, et mm dit quel `skillsDir` définir.
++
++- **Les options répondent à l'avance :** `/skillcreate --name "Vulcan Salute" --description "Greets the Vulcan way" --keywords "vulcan, greeting"`. Mettez entre guillemets une valeur qui contient des espaces.
++- **Le texte** tient en un message : plusieurs lignes sont possibles. Avec un client qui affiche des formulaires, les autres questions arrivent dans un formulaire et le texte est quand même demandé en message.
++- **Une skill existante** n'est remplacée que si vous répondez `yes` ; `no` redemande un nom.
++- **Au milieu des questions de l'agent,** les réponses déjà données sont gardées : une fois la skill écrite — ou abandonnée avec `/cancel` — la question de l'agent en cours revient. Tant que son fichier n'est pas écrit, la skill va là où cet agent lira ses skills : `.mm/skills` dès que vous avez répondu `yes` à *Keep everything in a .mm folder?*, et mm vous rappelle de répondre `yes` à *Use skills?*.
++- Après l'écriture, mm relit la skill (`✅ mm reads it: …`). Un agent déjà lancé la voit une fois redémarré (*Reload Agent*).
++
  ## Variantes
  - **Fixer des réponses à l'avance.** Les options de `mm init` marchent ici (`--provider`, `--base-url`, `--model`, `--usage`, `--project yes`…) : une question dont l'option est donnée n'est pas posée. Par exemple `"args": ["acp-create", "--provider", "llmman", "--project", "yes"]`.

modified docs/fr/reference/cli.md +1 -1 Viewed

@@ -280,7 +280,7 @@ Un fichier d'agent hors du workspace ne donne qu'un avertissement : voir [quand
280	280	\| Sessions \| Un assistant par `session/new`. Les fichiers relatifs sont écrits dans le `cwd` de la session. Après la réponse à `session/new`, un `agent_message_chunk` invite à envoyer `/start`. `/start` ou le premier prompt, quel que soit son texte, démarre l'assistant. \|
281	281	\| Questions \| Choisies d'après les seules capacités du client. `clientCapabilities.elicitation.form` présent : formulaires `elicitation/create` (liés à la session), autant de questions par formulaire que possible — un formulaire ne contient jamais une question avec celle dont ses choix ou sa valeur par défaut dépendent (modèle après serveur, famille après modèle, confirmation et nom après usage, skills et fichier après disposition, remplacement après fichier). Absent : un `agent_message_chunk` par question, choix numérotés ; le prompt suivant y répond — un numéro, une valeur, ou `.` / `default` / `/skip` pour la valeur par défaut. \|
282	282	\| Issues d'un formulaire \| Refusé ou annulé : rien n'est écrit, le prompt suivant redemande. Trois formulaires de suite sans réponse utilisable : l'assistant s'arrête. \|
283		-\| Commandes (`available_commands_update`) \| `start`, `preview`, `back`, `write`, `restart`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig` : un bloc JSON `agent_servers` pour le fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`) — une entrée `mm-<projet>` qui lance `mm acp <chemin absolu>` ; avec `compose.yaml`, `mm-<projet> (container)` qui lance `docker exec -i <container_name> mm -acp -config <chemin>` ; avec `sbxenv.yaml`, `mm-<projet> (sandbox)` qui lance `sbx exec -i <name> mm -acp -config <chemin>` — puis une ligne par entrée disant ce qu'il faut lancer avant. Sans fichier d'agent : un renvoi vers `/start`. `dockerinit` et `sbxinit` (indication de saisie : leurs options) lancent [`mm dockerinit`](#mm-dockerinit--les-fichiers-du-conteneur) et [`mm sbxinit`](#mm-sbxinit--le-fichier-de-la-sandbox) avec le `cwd` de la session comme répertoire courant, leur sortie dans un message ; `--overwrite` remplace les fichiers existants, gardés sinon (rien ne peut être demandé). \|
	283	+\| Commandes (`available_commands_update`) \| `start`, `preview`, `back`, `write`, `restart`, `skillcreate`, `cancel`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig` : un bloc JSON `agent_servers` pour le fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`) — une entrée `mm-<projet>` qui lance `mm acp <chemin absolu>` ; avec `compose.yaml`, `mm-<projet> (container)` qui lance `docker exec -i <container_name> mm -acp -config <chemin>` ; avec `sbxenv.yaml`, `mm-<projet> (sandbox)` qui lance `sbx exec -i <name> mm -acp -config <chemin>` — puis une ligne par entrée disant ce qu'il faut lancer avant. Sans fichier d'agent : un renvoi vers `/start`. `skillcreate` (indication de saisie : `--name`, `--description`, `--keywords`, valeurs entre guillemets acceptées) pose les questions de [`mm skillcreate`](#mm-skillcreate--lassistant-de-skill) — formulaires pour les réponses d'une ligne quand le client sait les afficher, le texte toujours en message — et écrit la skill dans le `skillsDir` du fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`, lu sans être chargé dans les réglages du processus), sinon — pas encore de fichier d'agent — le `skillsDir` qu'aura l'agent en cours de création dans la session (`.mm/skills` avec la disposition `.mm`), sinon `.mm/skills` ou `skills`, avec une note ; les réponses de l'agent sont gardées et sa question en cours revient après la skill, ou après `cancel`. `dockerinit` et `sbxinit` (indication de saisie : leurs options) lancent [`mm dockerinit`](#mm-dockerinit--les-fichiers-du-conteneur) et [`mm sbxinit`](#mm-sbxinit--le-fichier-de-la-sandbox) avec le `cwd` de la session comme répertoire courant, leur sortie dans un message ; `--overwrite` remplace les fichiers existants, gardés sinon (rien ne peut être demandé). \|
284	284	\| Après l'écriture \| Les messages de `mm init` (`✅ wrote <fichier>`, `✅ mm loads it`), puis `mm acp <chemin absolu>`, un renvoi vers `/zedconfig`, et un vers `/dockerinit` et `/sbxinit` ; pour un client dont `clientInfo.name` contient `zed`, une entrée `agent_servers` en plus. Les prompts suivants répondent que le fichier est écrit. \|
285	285	\| Codes de sortie \| 0 le client a fermé la connexion, ou `-h` ; 1 une valeur d'option refusée ou des presets illisibles ; 2 une option inconnue. \|
286	286

  | Sessions | Un assistant par `session/new`. Les fichiers relatifs sont écrits dans le `cwd` de la session. Après la réponse à `session/new`, un `agent_message_chunk` invite à envoyer `/start`. `/start` ou le premier prompt, quel que soit son texte, démarre l'assistant. |
  | Questions | Choisies d'après les seules capacités du client. `clientCapabilities.elicitation.form` présent : formulaires `elicitation/create` (liés à la session), autant de questions par formulaire que possible — un formulaire ne contient jamais une question avec celle dont ses choix ou sa valeur par défaut dépendent (modèle après serveur, famille après modèle, confirmation et nom après usage, skills et fichier après disposition, remplacement après fichier). Absent : un `agent_message_chunk` par question, choix numérotés ; le prompt suivant y répond — un numéro, une valeur, ou `.` / `default` / `/skip` pour la valeur par défaut. |
  | Issues d'un formulaire | Refusé ou annulé : rien n'est écrit, le prompt suivant redemande. Trois formulaires de suite sans réponse utilisable : l'assistant s'arrête. |
--| Commandes (`available_commands_update`) | `start`, `preview`, `back`, `write`, `restart`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig` : un bloc JSON `agent_servers` pour le fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`) — une entrée `mm-<projet>` qui lance `mm acp <chemin absolu>` ; avec `compose.yaml`, `mm-<projet> (container)` qui lance `docker exec -i <container_name> mm -acp -config <chemin>` ; avec `sbxenv.yaml`, `mm-<projet> (sandbox)` qui lance `sbx exec -i <name> mm -acp -config <chemin>` — puis une ligne par entrée disant ce qu'il faut lancer avant. Sans fichier d'agent : un renvoi vers `/start`. `dockerinit` et `sbxinit` (indication de saisie : leurs options) lancent [`mm dockerinit`](#mm-dockerinit--les-fichiers-du-conteneur) et [`mm sbxinit`](#mm-sbxinit--le-fichier-de-la-sandbox) avec le `cwd` de la session comme répertoire courant, leur sortie dans un message ; `--overwrite` remplace les fichiers existants, gardés sinon (rien ne peut être demandé). |
++| Commandes (`available_commands_update`) | `start`, `preview`, `back`, `write`, `restart`, `skillcreate`, `cancel`, `dockerinit`, `zedconfig`, `sbxinit`, `help`. `zedconfig` : un bloc JSON `agent_servers` pour le fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`) — une entrée `mm-<projet>` qui lance `mm acp <chemin absolu>` ; avec `compose.yaml`, `mm-<projet> (container)` qui lance `docker exec -i <container_name> mm -acp -config <chemin>` ; avec `sbxenv.yaml`, `mm-<projet> (sandbox)` qui lance `sbx exec -i <name> mm -acp -config <chemin>` — puis une ligne par entrée disant ce qu'il faut lancer avant. Sans fichier d'agent : un renvoi vers `/start`. `skillcreate` (indication de saisie : `--name`, `--description`, `--keywords`, valeurs entre guillemets acceptées) pose les questions de [`mm skillcreate`](#mm-skillcreate--lassistant-de-skill) — formulaires pour les réponses d'une ligne quand le client sait les afficher, le texte toujours en message — et écrit la skill dans le `skillsDir` du fichier d'agent trouvé dans le `cwd` de la session (`agent.yaml`, puis `.mm/agent.yaml`, lu sans être chargé dans les réglages du processus), sinon — pas encore de fichier d'agent — le `skillsDir` qu'aura l'agent en cours de création dans la session (`.mm/skills` avec la disposition `.mm`), sinon `.mm/skills` ou `skills`, avec une note ; les réponses de l'agent sont gardées et sa question en cours revient après la skill, ou après `cancel`. `dockerinit` et `sbxinit` (indication de saisie : leurs options) lancent [`mm dockerinit`](#mm-dockerinit--les-fichiers-du-conteneur) et [`mm sbxinit`](#mm-sbxinit--le-fichier-de-la-sandbox) avec le `cwd` de la session comme répertoire courant, leur sortie dans un message ; `--overwrite` remplace les fichiers existants, gardés sinon (rien ne peut être demandé). |
  | Après l'écriture | Les messages de `mm init` (`✅ wrote <fichier>`, `✅ mm loads it`), puis `mm acp <chemin absolu>`, un renvoi vers `/zedconfig`, et un vers `/dockerinit` et `/sbxinit` ; pour un client dont `clientInfo.name` contient `zed`, une entrée `agent_servers` en plus. Les prompts suivants répondent que le fichier est écrit. |
  | Codes de sortie | 0 le client a fermé la connexion, ou `-h` ; 1 une valeur d'option refusée ou des presets illisibles ; 2 une option inconnue. |

modified internal/acpcreate/acpcreate.go +1 -1 Viewed

@@ -149,7 +149,7 @@ func (ag agent) newSession(cwd string) (session, error) {
149	149	return nil, err
150	150	}
151	151	flow.SetDir(cwd)
152		- return &session{cwd: cwd, flow: flow}, nil
	152	+ return &session{cwd: cwd, flow: flow, agent: agentRun(flow)}, nil
153	153	}
154	154
155	155	// Prompt is one message from the user: an answer, a command, or — the

  		return nil, err
  	}
  	flow.SetDir(cwd)
--	return &session{cwd: cwd, flow: flow}, nil
++	return &session{cwd: cwd, flow: flow, agent: agentRun(flow)}, nil
  }
  // Prompt is one message from the user: an answer, a command, or — the

modified internal/acpcreate/acpcreate_test.go +1 -1 Viewed

@@ -563,7 +563,7 @@ func TestBatchStopsAtADependency(t *testing.T) {
563	563	"file,overwrite": "file",
564	564	"project,skills": "project",
565	565	} {
566		- if got := keys(batch(steps(strings.Split(in, ",")...))); got != want {
	566	+ if got := keys(batch(steps(strings.Split(in, ",")...), agentDeps)); got != want {
567	567	t.Errorf("batch(%s) = %s, want %s", in, got, want)
568	568	}
569	569	}

  		"file,overwrite":                 "file",
  		"project,skills":                 "project",
  	} {
--		if got := keys(batch(steps(strings.Split(in, ",")...))); got != want {
++		if got := keys(batch(steps(strings.Split(in, ",")...), agentDeps)); got != want {
  			t.Errorf("batch(%s) = %s, want %s", in, got, want)
  		}
  	}

modified internal/acpcreate/ask.go +40 -17 Viewed

@@ -37,10 +37,18 @@ func question(st agentinit.Step, position string) string {
37	37	b.WriteString("\n")
38	38	}
39	39	how := "Type your answer"
40		- if len(st.Options) > 0 {
	40	+ switch {
	41	+ case len(st.Options) > 0:
41	42	how = "Reply with a number or a value"
	43	+ case st.Multiline:
	44	+ how = "Type it in one message — several lines are fine"
42	45	}
43		- if st.Default != "" {
	46	+ switch {
	47	+ case st.Optional:
	48	+ // An optional answer's default stands for "none" (mm skillcreate's
	49	+ // keywords: "-"): say what it means, not what it is.
	50	+ how += " · `.` for none"
	51	+ case st.Default != "":
44	52	how += fmt.Sprintf(" · `.` for the default (`%s`)", st.Default)
45	53	}
46	54	b.WriteString(how + ".")
@@ -99,7 +107,7 @@ func parseConfirm(q elicit.Question, text string) (string, error) {
99	107	// dependsOn says which answers a question's options or default are built
100	108	// from (agentinit.Flow.Step). A form never holds a question with the one it
101	109	// depends on: its options would be stale by the time the form is answered.
102		-var dependsOn = map[string][]string{
	110	+var agentDeps = map[string][]string{
103	111	"endpoint": {"provider"},
104	112	"keyenv": {"provider"},
105	113	"model": {"provider", "endpoint", "keyenv"},
@@ -111,13 +119,23 @@ var dependsOn = map[string][]string{
111	119	"overwrite": {"file"},
112	120	}
113	121
	122	+// skillDeps is the same for mm skillcreate's questions: replacing a skill
	123	+// is asked about the name just given.
	124	+var skillDeps = map[string][]string{
	125	+ "overwrite": {"name"},
	126	+}
	127	+
114	128	// batch is the next form: the pending questions in order, up to the first
115		-// one that depends on a question already in the form.
116		-func batch(pending []agentinit.Step) []agentinit.Step {
	129	+// one that depends on a question already in the form (deps), and never a
	130	+// multi-line text — those are asked as a message (askByForms).
	131	+func batch(pending []agentinit.Step, deps map[string][]string) []agentinit.Step {
117	132	in := map[string]bool{}
118	133	var out []agentinit.Step
119	134	for _, st := range pending {
120		- for _, dep := range dependsOn[st.Key] {
	135	+ if st.Multiline {
	136	+ return out
	137	+ }
	138	+ for _, dep := range deps[st.Key] {
121	139	if in[dep] {
122	140	return out
123	141	}
@@ -133,17 +151,23 @@ func batch(pending []agentinit.Step) []agentinit.Step {
133	151	// not loop forever.
134	152	const maxIdleForms = 3
135	153
136		-// askByForms asks the pending questions form after form, then writes.
137		-func (t *turn) askByForms() {
138		- s := t.s
	154	+// askByForms asks the pending questions form after form, then writes. A
	155	+// multi-line text (the skill's) is asked as a message even here: whether a
	156	+// client offers several lines in a form's text field is unknown, and the
	157	+// reply box of the chat always does.
	158	+func (t turn) askByForms(r run) {
139	159	idle := 0
140	160	for {
141		- pending := s.flow.Pending()
	161	+ pending := r.w.Pending()
142	162	if len(pending) == 0 {
143		- t.write()
	163	+ r.finish(t)
	164	+ return
	165	+ }
	166	+ if pending[0].Multiline {
	167	+ t.ask(r, pending[0])
144	168	return
145	169	}
146		- steps := batch(pending)
	170	+ steps := batch(pending, r.deps)
147	171	answers, status := t.form(steps)
148	172	switch status {
149	173	case elicit.Declined:
@@ -153,7 +177,7 @@ func (t *turn) askByForms() {
153	177	t.say("The form was closed: nothing written. Send any message to go on.")
154	178	return
155	179	}
156		- if t.apply(steps, answers) == 0 {
	180	+ if t.apply(r, steps, answers) == 0 {
157	181	idle++
158	182	if idle >= maxIdleForms {
159	183	t.say("No answer could be used: stopping here. Send any message to try again.")
@@ -167,8 +191,7 @@ func (t *turn) askByForms() {
167	191
168	192	// apply answers the questions of a form; it reports what was refused and
169	193	// returns how many answers were taken.
170		-func (t *turn) apply(steps []agentinit.Step, answers []elicit.Answer) int {
171		- s := t.s
	194	+func (t turn) apply(r run, steps []agentinit.Step, answers []elicit.Answer) int {
172	195	taken := 0
173	196	var refused []string
174	197	for i, st := range steps {
@@ -179,11 +202,11 @@ func (t *turn) apply(steps []agentinit.Step, answers []elicit.Answer) int {
179	202	if strings.TrimSpace(value) == "" {
180	203	value = st.Default
181	204	}
182		- if err := s.flow.Set(st.Key, value); err != nil {
	205	+ if err := r.w.Set(st.Key, value); err != nil {
183	206	refused = append(refused, "⚠️ "+err.Error())
184	207	continue
185	208	}
186		- s.answered = append(s.answered, st.Key)
	209	+ r.answered = append(r.answered, st.Key)
187	210	taken++
188	211	}
189	212	if len(refused) > 0 {

  		b.WriteString("\n")
  	}
  	how := "Type your answer"
--	if len(st.Options) > 0 {
++	switch {
++	case len(st.Options) > 0:
  		how = "Reply with a number or a value"
++	case st.Multiline:
++		how = "Type it in one message — several lines are fine"
  	}
--	if st.Default != "" {
++	switch {
++	case st.Optional:
++		// An optional answer's default stands for "none" (mm skillcreate's
++		// keywords: "-"): say what it means, not what it is.
++		how += " · `.` for none"
++	case st.Default != "":
  		how += fmt.Sprintf(" · `.` for the default (`%s`)", st.Default)
  	}
  	b.WriteString(how + ".")
  // dependsOn says which answers a question's options or default are built
  // from (agentinit.Flow.Step). A form never holds a question with the one it
  // depends on: its options would be stale by the time the form is answered.
--var dependsOn = map[string][]string{
++var agentDeps = map[string][]string{
  	"endpoint":  {"provider"},
  	"keyenv":    {"provider"},
  	"model":     {"provider", "endpoint", "keyenv"},
  	"overwrite": {"file"},
  }
++// skillDeps is the same for mm skillcreate's questions: replacing a skill
++// is asked about the name just given.
++var skillDeps = map[string][]string{
++	"overwrite": {"name"},
++}
++
  // batch is the next form: the pending questions in order, up to the first
--// one that depends on a question already in the form.
++// one that depends on a question already in the form (deps), and never a
--func batch(pending []agentinit.Step) []agentinit.Step {
++// multi-line text — those are asked as a message (askByForms).
++func batch(pending []agentinit.Step, deps map[string][]string) []agentinit.Step {
  	in := map[string]bool{}
  	var out []agentinit.Step
  	for _, st := range pending {
--		for _, dep := range dependsOn[st.Key] {
++		if st.Multiline {
++			return out
++		}
++		for _, dep := range deps[st.Key] {
  			if in[dep] {
  				return out
  			}
  // not loop forever.
  const maxIdleForms = 3
--// askByForms asks the pending questions form after form, then writes.
++// askByForms asks the pending questions form after form, then writes. A
--func (t *turn) askByForms() {
++// multi-line text (the skill's) is asked as a message even here: whether a
--	s := t.s
++// client offers several lines in a form's text field is unknown, and the
++// reply box of the chat always does.
++func (t *turn) askByForms(r *run) {
  	idle := 0
  	for {
--		pending := s.flow.Pending()
++		pending := r.w.Pending()
  		if len(pending) == 0 {
--			t.write()
++			r.finish(t)
++			return
++		}
++		if pending[0].Multiline {
++			t.ask(r, pending[0])
  			return
  		}
--		steps := batch(pending)
++		steps := batch(pending, r.deps)
  		answers, status := t.form(steps)
  		switch status {
  		case elicit.Declined:
  			t.say("The form was closed: nothing written. Send any message to go on.")
  			return
  		}
--		if t.apply(steps, answers) == 0 {
++		if t.apply(r, steps, answers) == 0 {
  			idle++
  			if idle >= maxIdleForms {
  				t.say("No answer could be used: stopping here. Send any message to try again.")
  // apply answers the questions of a form; it reports what was refused and
  // returns how many answers were taken.
--func (t *turn) apply(steps []agentinit.Step, answers []elicit.Answer) int {
++func (t *turn) apply(r *run, steps []agentinit.Step, answers []elicit.Answer) int {
--	s := t.s
  	taken := 0
  	var refused []string
  	for i, st := range steps {
  		if strings.TrimSpace(value) == "" {
  			value = st.Default
  		}
--		if err := s.flow.Set(st.Key, value); err != nil {
++		if err := r.w.Set(st.Key, value); err != nil {
  			refused = append(refused, "⚠️ "+err.Error())
  			continue
  		}
--		s.answered = append(s.answered, st.Key)
++		r.answered = append(r.answered, st.Key)
  		taken++
  	}
  	if len(refused) > 0 {

modified internal/acpcreate/session.go +87 -43 Viewed

@@ -13,6 +13,7 @@ import (
13	13	"mm/internal/agentinit"
14	14	"mm/internal/dockerinit"
15	15	"mm/internal/sbxinit"
	16	+ "mm/internal/skillcreate"
16	17
17	18	sdk "github.com/coder/acp-go-sdk"
18	19	)
@@ -25,13 +26,15 @@ type session struct {
25	26	flow *agentinit.Flow
26	27
27	28	started bool
28		- // asked is the question shown in the chat and waiting for the next
29		- // prompt (conversation mode); "" when none.
30		- asked string
31		- // answered is the keys answered in this session, in order — what /back
32		- // takes back.
33		- answered []string
34		- // written is the file written, absolute; "" while not written.
	29	+ // agent is the run of mm init's questions on flow; skill the run of
	30	+ // /skillcreate's while one is being created (ticket 213), nil otherwise.
	31	+ agent run
	32	+ skill *run
	33	+ // skillFlow is the skill run's flow, skillArgs the flags it was given
	34	+ // (/restart starts it again with them).
	35	+ skillFlow *skillcreate.Flow
	36	+ skillArgs string
	37	+ // written is the agent file written, absolute; "" while not written.
35	38	written string
36	39
37	40	cancelMu sync.Mutex
@@ -60,6 +63,8 @@ var commands = []struct{ name, description, hint string }{
60	63	{"back", "Take back the last answer", ""},
61	64	{"write", "Take the default for every question left, then write the file", ""},
62	65	{"restart", "Forget every answer and start again", ""},
	66	+ {"skillcreate", "Create a skill for the project's agent (mm skillcreate); the agent's answers are kept", "[--name <name>] [--description <text>] [--keywords <words>]"},
	67	+ {"cancel", "Give up the skill being created; back to the agent's questions", ""},
63	68	{"dockerinit", "Write a Dockerfile and a compose.yaml to run the agent in a container (mm dockerinit)", "[--name <name>] [--agent <file>] [--overwrite]"},
64	69	{"zedconfig", "Show the Zed settings that start this project's agent: here, in its container, in its Docker Sandbox", ""},
65	70	{"sbxinit", "Write a sbxenv.yaml to run the agent in a Docker Sandbox (mm sbxinit)", "[--name <name>] [--workspace <dir>] [--agent <file>] [--overwrite]"},
@@ -90,19 +95,27 @@ func (t *turn) say(markdown string) { t.ag.say(t.ctx, t.sid, markdown) }
90	95
91	96	// handle answers one prompt.
92	97	func (t *turn) handle(text string) {
93		- if name, args, ok := slashCommand(text); ok {
94		- t.command(name, args)
	98	+ if name, args, rest, ok := slashCommand(text); ok {
	99	+ t.command(name, args, rest)
95	100	return
96	101	}
97	102	s := t.s
	103	+ if s.skill != nil {
	104	+ // A skill is being created: the message answers its question.
	105	+ if s.skill.asked != "" && !t.answer(text) {
	106	+ return
	107	+ }
	108	+ t.next()
	109	+ return
	110	+ }
98	111	switch {
99	112	case s.written != "":
100		- t.say(fmt.Sprintf("`%s` is written. `/restart` creates another one.", s.written))
	113	+ t.say(fmt.Sprintf("`%s` is written. `/restart` creates another one, `/skillcreate` a skill for it.", s.written))
101	114	return
102	115	case !s.started:
103	116	t.start()
104	117	return
105		- case s.asked != "":
	118	+ case s.agent.asked != "":
106	119	if !t.answer(text) {
107	120	return
108	121	}
@@ -110,28 +123,39 @@ func (t *turn) handle(text string) {
110	123	t.next()
111	124	}
112	125
113		-// slashCommand recognises one of this mode's commands, and the words
114		-// typed after it.
115		-func slashCommand(text string) (string, []string, bool) {
	126	+// slashCommand recognises one of this mode's commands, the words typed
	127	+// after it, and the same as typed (rest: /skillcreate reads quoted values
	128	+// from it).
	129	+func slashCommand(text string) (name string, args []string, rest string, ok bool) {
116	130	text = strings.TrimSpace(text)
117	131	if !strings.HasPrefix(text, "/") {
118		- return "", nil, false
	132	+ return "", nil, "", false
119	133	}
120	134	words := strings.Fields(text[1:])
121	135	if len(words) == 0 {
122		- return "", nil, false
	136	+ return "", nil, "", false
123	137	}
124	138	for _, c := range commands {
125	139	if c.name == words[0] {
126		- return c.name, words[1:], true
	140	+ return c.name, words[1:], strings.TrimSpace(strings.TrimPrefix(text[1:], words[0])), true
127	141	}
128	142	}
129		- return "", nil, false
	143	+ return "", nil, "", false
130	144	}
131	145
132		-func (t *turn) command(name string, args []string) {
	146	+func (t *turn) command(name string, args []string, rest string) {
133	147	s := t.s
134	148	switch name {
	149	+ case "skillcreate":
	150	+ t.skillcreate(rest)
	151	+ case "cancel":
	152	+ if s.skill == nil {
	153	+ t.say("No skill is being created.")
	154	+ return
	155	+ }
	156	+ s.skill, s.skillFlow = nil, nil
	157	+ t.say("Skill given up: nothing written.")
	158	+ t.resumeAgent()
135	159	case "sbxinit":
136	160	t.sbxinit(args)
137	161	case "dockerinit":
@@ -139,23 +163,36 @@ func (t *turn) command(name string, args []string) {
139	163	case "zedconfig":
140	164	t.say(zedConfig(s.cwd))
141	165	case "start":
	166	+ if s.skill != nil {
	167	+ t.next() // the skill's current question, again
	168	+ return
	169	+ }
142	170	t.start()
143	171	case "help":
144	172	t.say(help())
145	173	case "preview":
146		- t.say("```yaml\n" + s.flow.Preview("", "") + "```")
	174	+ t.say(s.cur().preview())
147	175	case "restart":
	176	+ if s.skill != nil {
	177	+ t.skillcreate(s.skillArgs)
	178	+ return
	179	+ }
148	180	fresh, err := t.ag.newSession(s.cwd)
149	181	if err != nil {
150	182	t.say("⚠️ " + err.Error())
151	183	return
152	184	}
153		- s.flow, s.asked, s.answered, s.written, s.started = fresh.flow, "", nil, "", true
	185	+ s.flow, s.agent, s.written, s.started = fresh.flow, fresh.agent, "", true
154	186	t.say("Starting again.")
155	187	t.next()
156	188	case "back":
157	189	t.back()
158	190	case "write":
	191	+ if s.skill != nil {
	192	+ t.takeDefaults()
	193	+ t.next()
	194	+ return
	195	+ }
159	196	if s.written != "" {
160	197	t.say(fmt.Sprintf("`%s` is already written.", s.written))
161	198	return
@@ -253,23 +290,26 @@ func welcome(cwd string) string {
253	290	// back takes back the last answer given here and asks it again.
254	291	func (t *turn) back() {
255	292	s := t.s
256		- if len(s.answered) == 0 {
	293	+ r := s.cur()
	294	+ if len(r.answered) == 0 {
257	295	t.say("Nothing to take back.")
258	296	return
259	297	}
260		- key := s.answered[len(s.answered)-1]
261		- s.answered = s.answered[:len(s.answered)-1]
262		- s.flow.Unset(key)
263		- s.written = ""
	298	+ key := r.answered[len(r.answered)-1]
	299	+ r.answered = r.answered[:len(r.answered)-1]
	300	+ r.w.Unset(key)
	301	+ if r == &s.agent {
	302	+ s.written = ""
	303	+ }
264	304	t.next()
265	305	}
266	306
267	307	// takeDefaults answers every pending question that has a default, as mm
268	308	// init --yes does, but stops at an existing file: replacing it is asked.
269	309	func (t *turn) takeDefaults() {
270		- s := t.s
	310	+ r := t.s.cur()
271	311	for {
272		- pending := s.flow.Pending()
	312	+ pending := r.w.Pending()
273	313	if len(pending) == 0 {
274	314	return
275	315	}
@@ -277,35 +317,39 @@ func (t *turn) takeDefaults() {
277	317	if st.Key == "overwrite" \|\| st.Default == "" {
278	318	return
279	319	}
280		- if err := s.flow.Set(st.Key, st.Default); err != nil {
	320	+ if err := r.w.Set(st.Key, st.Default); err != nil {
281	321	t.say("⚠️ " + err.Error())
282	322	return
283	323	}
284		- s.answered = append(s.answered, st.Key)
	324	+ r.answered = append(r.answered, st.Key)
285	325	}
286	326	}
287	327
288	328	// next asks what is still to ask, or writes the file when nothing is.
289	329	func (t *turn) next() {
290		- s := t.s
291		- s.asked = ""
	330	+ r := t.s.cur()
	331	+ r.asked = ""
292	332	if t.ag.elicitForm {
293		- t.askByForms()
	333	+ t.askByForms(r)
294	334	return
295	335	}
296		- pending := s.flow.Pending()
	336	+ pending := r.w.Pending()
297	337	if len(pending) == 0 {
298		- t.write()
	338	+ r.finish(t)
299	339	return
300	340	}
301		- st := pending[0]
302		- s.asked = st.Key
	341	+ t.ask(r, pending[0])
	342	+}
	343	+
	344	+// ask shows one question in the chat; the next prompt answers it.
	345	+func (t turn) ask(r run, st agentinit.Step) {
	346	+ r.asked = st.Key
303	347	t.say(question(st, t.position(st.Key)))
304	348	}
305	349
306	350	// position is "n of N", the question's place among all of them.
307	351	func (t *turn) position(key string) string {
308		- steps := t.s.flow.Steps()
	352	+ steps := t.s.cur().w.Steps()
309	353	for i, st := range steps {
310	354	if st.Key == key {
311	355	return fmt.Sprintf("%d of %d", i+1, len(steps))
@@ -317,17 +361,17 @@ func (t *turn) position(key string) string {
317	361	// answer reads the prompt as the answer to the question asked; false when
318	362	// it does not answer it (the question is shown again).
319	363	func (t *turn) answer(text string) bool {
320		- s := t.s
321		- st := s.flow.Step(s.asked)
	364	+ r := t.s.cur()
	365	+ st := r.w.Step(r.asked)
322	366	value, err := parseAnswer(st, text)
323	367	if err == nil {
324		- err = s.flow.Set(st.Key, value)
	368	+ err = r.w.Set(st.Key, value)
325	369	}
326	370	if err != nil {
327	371	t.say("⚠️ " + err.Error() + "\n\n" + question(st, t.position(st.Key)))
328	372	return false
329	373	}
330		- s.answered = append(s.answered, st.Key)
	374	+ r.answered = append(r.answered, st.Key)
331	375	return true
332	376	}
333	377
@@ -345,7 +389,7 @@ func (t *turn) write() {
345	389	return
346	390	}
347	391	s.written = s.flow.Path(output)
348		- t.say(report.String() + "\n" + howToUse(s.written, t.ag.client) + "\n`/dockerinit` writes a Dockerfile and a compose.yaml to run this agent in a container, `/sbxinit` a sbxenv.yaml for a Docker Sandbox.")
	392	+ t.say(report.String() + "\n" + howToUse(s.written, t.ag.client) + "\n`/dockerinit` writes a Dockerfile and a compose.yaml to run this agent in a container, `/sbxinit` a sbxenv.yaml for a Docker Sandbox, `/skillcreate` a skill for it.")
349	393	}
350	394
351	395	func intro(cwd string, forms bool) string {

  	"mm/internal/agentinit"
  	"mm/internal/dockerinit"
  	"mm/internal/sbxinit"
++	"mm/internal/skillcreate"
  	sdk "github.com/coder/acp-go-sdk"
  )
  	flow *agentinit.Flow
  	started bool
--	// asked is the question shown in the chat and waiting for the next
++	// agent is the run of mm init's questions on flow; skill the run of
--	// prompt (conversation mode); "" when none.
++	// /skillcreate's while one is being created (ticket 213), nil otherwise.
--	asked string
++	agent run
--	// answered is the keys answered in this session, in order — what /back
++	skill *run
--	// takes back.
++	// skillFlow is the skill run's flow, skillArgs the flags it was given
--	answered []string
++	// (/restart starts it again with them).
--	// written is the file written, absolute; "" while not written.
++	skillFlow *skillcreate.Flow
++	skillArgs string
++	// written is the agent file written, absolute; "" while not written.
  	written string
  	cancelMu sync.Mutex
  	{"back", "Take back the last answer", ""},
  	{"write", "Take the default for every question left, then write the file", ""},
  	{"restart", "Forget every answer and start again", ""},
++	{"skillcreate", "Create a skill for the project's agent (mm skillcreate); the agent's answers are kept", "[--name <name>] [--description <text>] [--keywords <words>]"},
++	{"cancel", "Give up the skill being created; back to the agent's questions", ""},
  	{"dockerinit", "Write a Dockerfile and a compose.yaml to run the agent in a container (mm dockerinit)", "[--name <name>] [--agent <file>] [--overwrite]"},
  	{"zedconfig", "Show the Zed settings that start this project's agent: here, in its container, in its Docker Sandbox", ""},
  	{"sbxinit", "Write a sbxenv.yaml to run the agent in a Docker Sandbox (mm sbxinit)", "[--name <name>] [--workspace <dir>] [--agent <file>] [--overwrite]"},
  // handle answers one prompt.
  func (t *turn) handle(text string) {
--	if name, args, ok := slashCommand(text); ok {
++	if name, args, rest, ok := slashCommand(text); ok {
--		t.command(name, args)
++		t.command(name, args, rest)
  		return
  	}
  	s := t.s
++	if s.skill != nil {
++		// A skill is being created: the message answers its question.
++		if s.skill.asked != "" && !t.answer(text) {
++			return
++		}
++		t.next()
++		return
++	}
  	switch {
  	case s.written != "":
--		t.say(fmt.Sprintf("`%s` is written. `/restart` creates another one.", s.written))
++		t.say(fmt.Sprintf("`%s` is written. `/restart` creates another one, `/skillcreate` a skill for it.", s.written))
  		return
  	case !s.started:
  		t.start()
  		return
--	case s.asked != "":
++	case s.agent.asked != "":
  		if !t.answer(text) {
  			return
  		}
  	t.next()
  }
--// slashCommand recognises one of this mode's commands, and the words
++// slashCommand recognises one of this mode's commands, the words typed
--// typed after it.
++// after it, and the same as typed (rest: /skillcreate reads quoted values
--func slashCommand(text string) (string, []string, bool) {
++// from it).
++func slashCommand(text string) (name string, args []string, rest string, ok bool) {
  	text = strings.TrimSpace(text)
  	if !strings.HasPrefix(text, "/") {
--		return "", nil, false
++		return "", nil, "", false
  	}
  	words := strings.Fields(text[1:])
  	if len(words) == 0 {
--		return "", nil, false
++		return "", nil, "", false
  	}
  	for _, c := range commands {
  		if c.name == words[0] {
--			return c.name, words[1:], true
++			return c.name, words[1:], strings.TrimSpace(strings.TrimPrefix(text[1:], words[0])), true
  		}
  	}
--	return "", nil, false
++	return "", nil, "", false
  }
--func (t *turn) command(name string, args []string) {
++func (t *turn) command(name string, args []string, rest string) {
  	s := t.s
  	switch name {
++	case "skillcreate":
++		t.skillcreate(rest)
++	case "cancel":
++		if s.skill == nil {
++			t.say("No skill is being created.")
++			return
++		}
++		s.skill, s.skillFlow = nil, nil
++		t.say("Skill given up: nothing written.")
++		t.resumeAgent()
  	case "sbxinit":
  		t.sbxinit(args)
  	case "dockerinit":
  	case "zedconfig":
  		t.say(zedConfig(s.cwd))
  	case "start":
++		if s.skill != nil {
++			t.next() // the skill's current question, again
++			return
++		}
  		t.start()
  	case "help":
  		t.say(help())
  	case "preview":
--		t.say("```yaml\n" + s.flow.Preview("", "") + "```")
++		t.say(s.cur().preview())
  	case "restart":
++		if s.skill != nil {
++			t.skillcreate(s.skillArgs)
++			return
++		}
  		fresh, err := t.ag.newSession(s.cwd)
  		if err != nil {
  			t.say("⚠️ " + err.Error())
  			return
  		}
--		s.flow, s.asked, s.answered, s.written, s.started = fresh.flow, "", nil, "", true
++		s.flow, s.agent, s.written, s.started = fresh.flow, fresh.agent, "", true
  		t.say("Starting again.")
  		t.next()
  	case "back":
  		t.back()
  	case "write":
++		if s.skill != nil {
++			t.takeDefaults()
++			t.next()
++			return
++		}
  		if s.written != "" {
  			t.say(fmt.Sprintf("`%s` is already written.", s.written))
  			return
  // back takes back the last answer given here and asks it again.
  func (t *turn) back() {
  	s := t.s
--	if len(s.answered) == 0 {
++	r := s.cur()
++	if len(r.answered) == 0 {
  		t.say("Nothing to take back.")
  		return
  	}
--	key := s.answered[len(s.answered)-1]
++	key := r.answered[len(r.answered)-1]
--	s.answered = s.answered[:len(s.answered)-1]
++	r.answered = r.answered[:len(r.answered)-1]
--	s.flow.Unset(key)
++	r.w.Unset(key)
--	s.written = ""
++	if r == &s.agent {
++		s.written = ""
++	}
  	t.next()
  }
  // takeDefaults answers every pending question that has a default, as mm
  // init --yes does, but stops at an existing file: replacing it is asked.
  func (t *turn) takeDefaults() {
--	s := t.s
++	r := t.s.cur()
  	for {
--		pending := s.flow.Pending()
++		pending := r.w.Pending()
  		if len(pending) == 0 {
  			return
  		}
  		if st.Key == "overwrite" || st.Default == "" {
  			return
  		}
--		if err := s.flow.Set(st.Key, st.Default); err != nil {
++		if err := r.w.Set(st.Key, st.Default); err != nil {
  			t.say("⚠️ " + err.Error())
  			return
  		}
--		s.answered = append(s.answered, st.Key)
++		r.answered = append(r.answered, st.Key)
  	}
  }
  // next asks what is still to ask, or writes the file when nothing is.
  func (t *turn) next() {
--	s := t.s
++	r := t.s.cur()
--	s.asked = ""
++	r.asked = ""
  	if t.ag.elicitForm {
--		t.askByForms()
++		t.askByForms(r)
  		return
  	}
--	pending := s.flow.Pending()
++	pending := r.w.Pending()
  	if len(pending) == 0 {
--		t.write()
++		r.finish(t)
  		return
  	}
--	st := pending[0]
++	t.ask(r, pending[0])
--	s.asked = st.Key
++}
++
++// ask shows one question in the chat; the next prompt answers it.
++func (t *turn) ask(r *run, st agentinit.Step) {
++	r.asked = st.Key
  	t.say(question(st, t.position(st.Key)))
  }
  // position is "n of N", the question's place among all of them.
  func (t *turn) position(key string) string {
--	steps := t.s.flow.Steps()
++	steps := t.s.cur().w.Steps()
  	for i, st := range steps {
  		if st.Key == key {
  			return fmt.Sprintf("%d of %d", i+1, len(steps))
  // answer reads the prompt as the answer to the question asked; false when
  // it does not answer it (the question is shown again).
  func (t *turn) answer(text string) bool {
--	s := t.s
++	r := t.s.cur()
--	st := s.flow.Step(s.asked)
++	st := r.w.Step(r.asked)
  	value, err := parseAnswer(st, text)
  	if err == nil {
--		err = s.flow.Set(st.Key, value)
++		err = r.w.Set(st.Key, value)
  	}
  	if err != nil {
  		t.say("⚠️ " + err.Error() + "\n\n" + question(st, t.position(st.Key)))
  		return false
  	}
--	s.answered = append(s.answered, st.Key)
++	r.answered = append(r.answered, st.Key)
  	return true
  }
  		return
  	}
  	s.written = s.flow.Path(output)
--	t.say(report.String() + "\n" + howToUse(s.written, t.ag.client) + "\n`/dockerinit` writes a Dockerfile and a compose.yaml to run this agent in a container, `/sbxinit` a sbxenv.yaml for a Docker Sandbox.")
++	t.say(report.String() + "\n" + howToUse(s.written, t.ag.client) + "\n`/dockerinit` writes a Dockerfile and a compose.yaml to run this agent in a container, `/sbxinit` a sbxenv.yaml for a Docker Sandbox, `/skillcreate` a skill for it.")
  }
  func intro(cwd string, forms bool) string {

added internal/acpcreate/skill.go +175 -0 Viewed

new file mode 100644
@@ -0,0 +1,175 @@
	1	+package acpcreate
	2	+
	3	+import (
	4	+ "bytes"
	5	+ "errors"
	6	+ "flag"
	7	+ "fmt"
	8	+ "io"
	9	+ "path/filepath"
	10	+ "strings"
	11	+
	12	+ "mm/internal/agentinit"
	13	+ "mm/internal/skillcreate"
	14	+)
	15	+
	16	+// /skillcreate (ticket 213): mm skillcreate for the session's project. The
	17	+// skill goes where the project's agent reads its skills (skillcreate.
	18	+// LocateIn: the session's cwd, never the process's settings). It runs beside
	19	+// the agent's questions, which keep their answers: once the skill is written
	20	+// — or given up with /cancel — the agent's current question comes back.
	21	+
	22	+var _ wizard = (*skillcreate.Flow)(nil)
	23	+
	24	+// skillUsage is said when /skillcreate's flags cannot be read.
	25	+const skillUsage = "`/skillcreate [--name <name>] [--description <text>] [--keywords <words>]` — quote a value with spaces: `--name \"Vulcan Salute\"`."
	26	+
	27	+// skillcreate starts the skill wizard with the flags typed after the command
	28	+// (rest) as given answers, never asked.
	29	+func (t *turn) skillcreate(rest string) {
	30	+ s := t.s
	31	+ spec, err := parseSkillFlags(rest)
	32	+ if err != nil {
	33	+ t.say("⚠️ " + err.Error() + "\n\n" + skillUsage)
	34	+ return
	35	+ }
	36	+ place, err := skillcreate.LocateIn(s.cwd)
	37	+ if err != nil {
	38	+ t.say("⚠️ " + err.Error())
	39	+ return
	40	+ }
	41	+ if place.Config == "" {
	42	+ // No agent file on disk yet: the agent being created here may
	43	+ // already have its layout — .mm/ only exists once its file is.
	44	+ if p, ok := pendingAgentPlace(s.cwd, s.flow.Choices()); ok {
	45	+ place = p
	46	+ }
	47	+ }
	48	+ flow := skillcreate.NewFlow(place, skillcreate.Spec{}, "")
	49	+ if err := flow.SetGiven(spec); err != nil {
	50	+ t.say("⚠️ " + err.Error() + "\n\n" + skillUsage)
	51	+ return
	52	+ }
	53	+ s.skillFlow, s.skillArgs = flow, rest
	54	+ s.skill = &run{
	55	+ w: flow,
	56	+ deps: skillDeps,
	57	+ finish: func(t *turn) { t.writeSkill() },
	58	+ preview: func() string { return "```markdown\n" + flow.Preview("", "") + "\n```" },
	59	+ }
	60	+ msg := fmt.Sprintf("mm skillcreate — a new skill in `%s`.", place.Dir)
	61	+ if place.Note != "" {
	62	+ msg += "\n\n⚠️ " + place.Note
	63	+ }
	64	+ msg += "\n\n`/preview` shows the SKILL.md as it stands, `/back` takes back an answer, `/cancel` gives the skill up."
	65	+ if s.started && s.written == "" {
	66	+ msg += " The agent's answers are kept: its questions come back once the skill is written."
	67	+ }
	68	+ t.say(msg)
	69	+ t.next()
	70	+}
	71	+
	72	+// pendingAgentPlace is where the agent being created will read its skills,
	73	+// from the answers given so far: .mm/skills with the .mm layout, skills
	74	+// otherwise (agentinit.Choices.SkillsDir) — and what is still missing for
	75	+// it to read them. ok is false while the layout question is unanswered:
	76	+// skillcreate.LocateIn's choice stands then.
	77	+func pendingAgentPlace(cwd string, c agentinit.Choices) (skillcreate.Place, bool) {
	78	+ if c.Project == nil {
	79	+ return skillcreate.Place{}, false
	80	+ }
	81	+ dir := c.SkillsDir()
	82	+ place := skillcreate.Place{Dir: filepath.Join(cwd, dir)}
	83	+ switch {
	84	+ case c.Skills == nil:
	85	+ place.Note = fmt.Sprintf("the agent being created reads its skills from %s if you answer yes to \"Use skills?\"", dir)
	86	+ case !*c.Skills:
	87	+ place.Note = fmt.Sprintf("the agent being created has no skills (skillsDir: no-skills): set skillsDir: %s in its file, or /back to \"Use skills?\" and answer yes", dir)
	88	+ }
	89	+ return place, true
	90	+}
	91	+
	92	+// writeSkill writes the answered skill, reads it back, and goes back to the
	93	+// agent's questions.
	94	+func (t *turn) writeSkill() {
	95	+ s := t.s
	96	+ var report bytes.Buffer
	97	+ if _, ok := skillcreate.WriteSkill(s.skillFlow, &report); !ok {
	98	+ t.say(report.String() + "\nNothing more was done: `/back` changes an answer, `/cancel` gives the skill up.")
	99	+ return
	100	+ }
	101	+ s.skill, s.skillFlow = nil, nil
	102	+ t.say(report.String() + "\nA running agent sees the new skill once it restarts (Reload Agent): its catalogue of skills is read at start-up.")
	103	+ t.resumeAgent()
	104	+}
	105	+
	106	+// resumeAgent brings the agent's questions back after a skill, when the
	107	+// wizard was half way through.
	108	+func (t *turn) resumeAgent() {
	109	+ s := t.s
	110	+ if !s.started \|\| s.written != "" {
	111	+ return
	112	+ }
	113	+ t.say("Back to the agent.")
	114	+ t.next()
	115	+}
	116	+
	117	+// parseSkillFlags reads /skillcreate's flags: those of mm skillcreate that
	118	+// answer a question. --yes, --line, -config and -o have no use here: the
	119	+// agent file is the project's, the skill goes to its skills directory.
	120	+func parseSkillFlags(rest string) (skillcreate.Spec, error) {
	121	+ var spec skillcreate.Spec
	122	+ args, err := splitArgs(rest)
	123	+ if err != nil {
	124	+ return spec, err
	125	+ }
	126	+ fs := flag.NewFlagSet("/skillcreate", flag.ContinueOnError)
	127	+ fs.SetOutput(io.Discard)
	128	+ fs.StringVar(&spec.Name, "name", "", "")
	129	+ fs.StringVar(&spec.Description, "description", "", "")
	130	+ fs.StringVar(&spec.Keywords, "keywords", "", "")
	131	+ fs.StringVar(&spec.Body, "body", "", "")
	132	+ if err := fs.Parse(args); err != nil {
	133	+ return spec, err
	134	+ }
	135	+ if fs.NArg() > 0 {
	136	+ return spec, fmt.Errorf("unexpected %q", fs.Arg(0))
	137	+ }
	138	+ return spec, nil
	139	+}
	140	+
	141	+// splitArgs splits a command line on spaces, keeping what is between double
	142	+// or single quotes together: `--name "Vulcan Salute"` is two arguments.
	143	+func splitArgs(s string) ([]string, error) {
	144	+ var out []string
	145	+ var cur strings.Builder
	146	+ inWord, quote := false, rune(0)
	147	+ for _, r := range s {
	148	+ switch {
	149	+ case quote != 0:
	150	+ if r == quote {
	151	+ quote = 0
	152	+ continue
	153	+ }
	154	+ cur.WriteRune(r)
	155	+ case r == '"' \|\| r == '\'':
	156	+ quote, inWord = r, true
	157	+ case r == ' ' \|\| r == '\t' \|\| r == '\n':
	158	+ if inWord {
	159	+ out = append(out, cur.String())
	160	+ cur.Reset()
	161	+ inWord = false
	162	+ }
	163	+ default:
	164	+ cur.WriteRune(r)
	165	+ inWord = true
	166	+ }
	167	+ }
	168	+ if quote != 0 {
	169	+ return nil, errors.New("a quote is not closed")
	170	+ }
	171	+ if inWord {
	172	+ out = append(out, cur.String())
	173	+ }
	174	+ return out, nil
	175	+}

++package acpcreate
++
++import (
++	"bytes"
++	"errors"
++	"flag"
++	"fmt"
++	"io"
++	"path/filepath"
++	"strings"
++
++	"mm/internal/agentinit"
++	"mm/internal/skillcreate"
++)
++
++// /skillcreate (ticket 213): mm skillcreate for the session's project. The
++// skill goes where the project's agent reads its skills (skillcreate.
++// LocateIn: the session's cwd, never the process's settings). It runs beside
++// the agent's questions, which keep their answers: once the skill is written
++// — or given up with /cancel — the agent's current question comes back.
++
++var _ wizard = (*skillcreate.Flow)(nil)
++
++// skillUsage is said when /skillcreate's flags cannot be read.
++const skillUsage = "`/skillcreate [--name <name>] [--description <text>] [--keywords <words>]` — quote a value with spaces: `--name \"Vulcan Salute\"`."
++
++// skillcreate starts the skill wizard with the flags typed after the command
++// (rest) as given answers, never asked.
++func (t *turn) skillcreate(rest string) {
++	s := t.s
++	spec, err := parseSkillFlags(rest)
++	if err != nil {
++		t.say("⚠️ " + err.Error() + "\n\n" + skillUsage)
++		return
++	}
++	place, err := skillcreate.LocateIn(s.cwd)
++	if err != nil {
++		t.say("⚠️ " + err.Error())
++		return
++	}
++	if place.Config == "" {
++		// No agent file on disk yet: the agent being created here may
++		// already have its layout — .mm/ only exists once its file is.
++		if p, ok := pendingAgentPlace(s.cwd, s.flow.Choices()); ok {
++			place = p
++		}
++	}
++	flow := skillcreate.NewFlow(place, skillcreate.Spec{}, "")
++	if err := flow.SetGiven(spec); err != nil {
++		t.say("⚠️ " + err.Error() + "\n\n" + skillUsage)
++		return
++	}
++	s.skillFlow, s.skillArgs = flow, rest
++	s.skill = &run{
++		w:       flow,
++		deps:    skillDeps,
++		finish:  func(t *turn) { t.writeSkill() },
++		preview: func() string { return "```markdown\n" + flow.Preview("", "") + "\n```" },
++	}
++	msg := fmt.Sprintf("**mm skillcreate** — a new skill in `%s`.", place.Dir)
++	if place.Note != "" {
++		msg += "\n\n⚠️ " + place.Note
++	}
++	msg += "\n\n`/preview` shows the SKILL.md as it stands, `/back` takes back an answer, `/cancel` gives the skill up."
++	if s.started && s.written == "" {
++		msg += " The agent's answers are kept: its questions come back once the skill is written."
++	}
++	t.say(msg)
++	t.next()
++}
++
++// pendingAgentPlace is where the agent being created will read its skills,
++// from the answers given so far: .mm/skills with the .mm layout, skills
++// otherwise (agentinit.Choices.SkillsDir) — and what is still missing for
++// it to read them. ok is false while the layout question is unanswered:
++// skillcreate.LocateIn's choice stands then.
++func pendingAgentPlace(cwd string, c agentinit.Choices) (skillcreate.Place, bool) {
++	if c.Project == nil {
++		return skillcreate.Place{}, false
++	}
++	dir := c.SkillsDir()
++	place := skillcreate.Place{Dir: filepath.Join(cwd, dir)}
++	switch {
++	case c.Skills == nil:
++		place.Note = fmt.Sprintf("the agent being created reads its skills from %s if you answer yes to \"Use skills?\"", dir)
++	case !*c.Skills:
++		place.Note = fmt.Sprintf("the agent being created has no skills (skillsDir: no-skills): set skillsDir: %s in its file, or /back to \"Use skills?\" and answer yes", dir)
++	}
++	return place, true
++}
++
++// writeSkill writes the answered skill, reads it back, and goes back to the
++// agent's questions.
++func (t *turn) writeSkill() {
++	s := t.s
++	var report bytes.Buffer
++	if _, ok := skillcreate.WriteSkill(s.skillFlow, &report); !ok {
++		t.say(report.String() + "\nNothing more was done: `/back` changes an answer, `/cancel` gives the skill up.")
++		return
++	}
++	s.skill, s.skillFlow = nil, nil
++	t.say(report.String() + "\nA running agent sees the new skill once it restarts (*Reload Agent*): its catalogue of skills is read at start-up.")
++	t.resumeAgent()
++}
++
++// resumeAgent brings the agent's questions back after a skill, when the
++// wizard was half way through.
++func (t *turn) resumeAgent() {
++	s := t.s
++	if !s.started || s.written != "" {
++		return
++	}
++	t.say("Back to the agent.")
++	t.next()
++}
++
++// parseSkillFlags reads /skillcreate's flags: those of mm skillcreate that
++// answer a question. --yes, --line, -config and -o have no use here: the
++// agent file is the project's, the skill goes to its skills directory.
++func parseSkillFlags(rest string) (skillcreate.Spec, error) {
++	var spec skillcreate.Spec
++	args, err := splitArgs(rest)
++	if err != nil {
++		return spec, err
++	}
++	fs := flag.NewFlagSet("/skillcreate", flag.ContinueOnError)
++	fs.SetOutput(io.Discard)
++	fs.StringVar(&spec.Name, "name", "", "")
++	fs.StringVar(&spec.Description, "description", "", "")
++	fs.StringVar(&spec.Keywords, "keywords", "", "")
++	fs.StringVar(&spec.Body, "body", "", "")
++	if err := fs.Parse(args); err != nil {
++		return spec, err
++	}
++	if fs.NArg() > 0 {
++		return spec, fmt.Errorf("unexpected %q", fs.Arg(0))
++	}
++	return spec, nil
++}
++
++// splitArgs splits a command line on spaces, keeping what is between double
++// or single quotes together: `--name "Vulcan Salute"` is two arguments.
++func splitArgs(s string) ([]string, error) {
++	var out []string
++	var cur strings.Builder
++	inWord, quote := false, rune(0)
++	for _, r := range s {
++		switch {
++		case quote != 0:
++			if r == quote {
++				quote = 0
++				continue
++			}
++			cur.WriteRune(r)
++		case r == '"' || r == '\'':
++			quote, inWord = r, true
++		case r == ' ' || r == '\t' || r == '\n':
++			if inWord {
++				out = append(out, cur.String())
++				cur.Reset()
++				inWord = false
++			}
++		default:
++			cur.WriteRune(r)
++			inWord = true
++		}
++	}
++	if quote != 0 {
++		return nil, errors.New("a quote is not closed")
++	}
++	if inWord {
++		out = append(out, cur.String())
++	}
++	return out, nil
++}

added internal/acpcreate/skill_test.go +210 -0 Viewed

new file mode 100644
@@ -0,0 +1,210 @@
	1	+package acpcreate
	2	+
	3	+import (
	4	+ "bytes"
	5	+ "os"
	6	+ "path/filepath"
	7	+ "strings"
	8	+ "testing"
	9	+
	10	+ "mm/internal/agentinit"
	11	+ "mm/internal/config"
	12	+ "mm/internal/skillcreate"
	13	+)
	14	+
	15	+const skillBody = "Raise your right hand, fingers parted.\nSay: live long and prosper."
	16	+
	17	+// mmSkillcreate is the SKILL.md `mm skillcreate` writes with these answers,
	18	+// in a project laid out the same way (.mm/agent.yaml, skillsDir .mm/skills).
	19	+func mmSkillcreate(t *testing.T, args ...string) string {
	20	+ t.Helper()
	21	+ keepConfig(t)
	22	+ dir := t.TempDir()
	23	+ if err := os.MkdirAll(filepath.Join(dir, ".mm"), 0o755); err != nil {
	24	+ t.Fatal(err)
	25	+ }
	26	+ if err := os.WriteFile(filepath.Join(dir, ".mm", "agent.yaml"), []byte("skillsDir: .mm/skills\n"), 0o644); err != nil {
	27	+ t.Fatal(err)
	28	+ }
	29	+ t.Chdir(dir)
	30	+ var out bytes.Buffer
	31	+ if code := skillcreate.Main(append(args, "--yes", "--line"), strings.NewReader(""), &out); code != 0 {
	32	+ t.Fatalf("mm skillcreate: exit %d\n%s", code, out.String())
	33	+ }
	34	+ return read(t, filepath.Join(dir, ".mm", "skills", "vulcan-salute", "SKILL.md"))
	35	+}
	36	+
	37	+// /skillcreate in the middle of the agent's questions (ticket 213): the
	38	+// skill's questions, a multi-line text, the SKILL.md mm skillcreate writes,
	39	+// read back by mm — then the agent's next question, its answers kept. The
	40	+// global settings are left alone.
	41	+func TestSkillcreateConversation(t *testing.T) {
	42	+ want := mmSkillcreate(t, "--name", "Vulcan Salute", "--description", "Greets the Vulcan way", "--keywords", "vulcan, greeting", "--body", skillBody)
	43	+ client := &fakeClient{}
	44	+ h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t), "--project", "yes", "--skills", "yes"}, client, "zed", false)
	45	+ // The agent file first, so that the skill has a skills directory.
	46	+ h.say("/start")
	47	+ h.say("/write")
	48	+ agentFile := filepath.Join(h.cwd, ".mm", "agent.yaml")
	49	+ if _, err := os.Stat(agentFile); err != nil {
	50	+ t.Fatal("no agent file")
	51	+ }
	52	+
	53	+ before := config.Cfg.SkillsDir
	54	+ if got := h.say(`/skillcreate --name "Vulcan Salute"`); !strings.Contains(got, "Description (one line)?") {
	55	+ t.Fatalf("the name flag was not taken as given: %q\n%s", got, client.all())
	56	+ }
	57	+ if !strings.Contains(client.all(), filepath.Join(h.cwd, ".mm", "skills")) {
	58	+ t.Errorf("the skills directory is not named:\n%s", client.all())
	59	+ }
	60	+ h.say("Greets the Vulcan way")
	61	+ if got := h.say("vulcan, greeting"); !strings.Contains(got, "What to do") \|\| !strings.Contains(got, "several lines are fine") {
	62	+ t.Fatalf("the text question: %q", got)
	63	+ }
	64	+ if got := h.say("/preview"); !strings.Contains(got, "```markdown") \|\| !strings.Contains(got, "name: vulcan-salute") {
	65	+ t.Errorf("/preview during a skill: %q", got)
	66	+ }
	67	+ end := strings.Join([]string{h.say(skillBody), client.all()}, "\n")
	68	+ got := read(t, filepath.Join(h.cwd, ".mm", "skills", "vulcan-salute", "SKILL.md"))
	69	+ if got != want {
	70	+ t.Errorf("SKILL.md differs from mm skillcreate's:\n--- acp-create\n%s\n--- mm skillcreate\n%s", got, want)
	71	+ }
	72	+ if !strings.Contains(got, "fingers parted.\nSay:") {
	73	+ t.Errorf("the text lost its line break:\n%s", got)
	74	+ }
	75	+ for _, s := range []string{"✅ wrote", "✅ mm reads it: vulcan-salute", "Reload Agent"} {
	76	+ if !strings.Contains(end, s) {
	77	+ t.Errorf("closing messages lack %q:\n%s", s, end)
	78	+ }
	79	+ }
	80	+ if config.Cfg.SkillsDir != before {
	81	+ t.Errorf("the global settings changed: skillsDir %q → %q", before, config.Cfg.SkillsDir)
	82	+ }
	83	+}
	84	+
	85	+// Half way through the agent: the skill, then back to the agent's question,
	86	+// with the answers given before still there.
	87	+func TestSkillcreateComesBackToTheAgent(t *testing.T) {
	88	+ client := &fakeClient{}
	89	+ h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", false)
	90	+ h.say("/start")
	91	+ if got := h.say("yes"); !strings.Contains(got, "Model?") { // project: yes
	92	+ t.Fatalf("after the layout: %q", got)
	93	+ }
	94	+ h.say(`/skillcreate --name hello --description "Says hello" --keywords hi`)
	95	+ if got := h.say("Say hello."); !strings.Contains(got, "Model?") \|\| !strings.Contains(client.all(), "Back to the agent") {
	96	+ t.Fatalf("the agent's question did not come back: %q", got)
	97	+ }
	98	+ // No agent file yet — nor .mm/, created with it —, but the agent being
	99	+ // created has the .mm layout: the skill goes to .mm/skills, where it
	100	+ // will read its skills, and the note says "Use skills?" is still to come.
	101	+ if _, err := os.Stat(filepath.Join(h.cwd, ".mm", "skills", "hello", "SKILL.md")); err != nil {
	102	+ t.Errorf("the skill is not in .mm/skills: %v", err)
	103	+ }
	104	+ if !strings.Contains(client.all(), `answer yes to "Use skills?"`) {
	105	+ t.Errorf("no note about the skills question:\n%s", client.all())
	106	+ }
	107	+ if got := h.say("/preview"); !strings.Contains(got, ".mm/skills") {
	108	+ t.Errorf("the agent's answer to the layout was lost: %q", got)
	109	+ }
	110	+}
	111	+
	112	+// /cancel gives the skill up: nothing written, the agent's question back.
	113	+// An existing skill asks before it is replaced; "no" asks the name again.
	114	+func TestSkillcreateCancelAndExisting(t *testing.T) {
	115	+ client := &fakeClient{}
	116	+ h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", false)
	117	+ h.say("/start")
	118	+ h.say(`/skillcreate --name hello`)
	119	+ if got := h.say("/cancel"); !strings.Contains(got, ".mm folder?") \|\| !strings.Contains(client.all(), "nothing written") {
	120	+ t.Errorf("/cancel: %q", got)
	121	+ }
	122	+ if _, err := os.Stat(filepath.Join(h.cwd, "skills")); err == nil {
	123	+ t.Error("/cancel wrote something")
	124	+ }
	125	+ if got := h.say("/cancel"); !strings.Contains(got, "No skill") {
	126	+ t.Errorf("/cancel with no skill: %q", got)
	127	+ }
	128	+ h.say(`/skillcreate --name hello --description d --keywords k --body b`)
	129	+ if _, err := os.Stat(filepath.Join(h.cwd, "skills", "hello", "SKILL.md")); err != nil {
	130	+ t.Fatalf("the skill was not written in skills/: %v", err)
	131	+ }
	132	+ if got := h.say(`/skillcreate --name hello`); !strings.Contains(got, "Replace hello?") {
	133	+ t.Fatalf("an existing skill was not asked about: %q", got)
	134	+ }
	135	+ if got := h.say("no"); !strings.Contains(got, "Skill name?") {
	136	+ t.Errorf("no: the name is not asked again: %q", got)
	137	+ }
	138	+}
	139	+
	140	+// With forms: the name, the description and the keywords in one form (no
	141	+// skill of that name: no question about replacing it); the text is asked
	142	+// as a message even then.
	143	+func TestSkillcreateForms(t *testing.T) {
	144	+ given := map[string]any{"name": "Vulcan Salute", "description": "Greets the Vulcan way", "keywords": "vulcan, greeting"}
	145	+ client := &fakeClient{answer: func(key string, _ map[string]any) any { return given[key] }}
	146	+ h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", true)
	147	+ got := h.say("/skillcreate")
	148	+ if !strings.Contains(got, "What to do") {
	149	+ t.Fatalf("the text is not asked as a message: %q", got)
	150	+ }
	151	+ if len(client.forms) != 1 \|\| strings.Join(client.forms[0], ",") != "description,keywords,name" {
	152	+ t.Errorf("forms = %v, want one with description, keywords and name", client.forms)
	153	+ }
	154	+ h.say(skillBody)
	155	+ text := read(t, filepath.Join(h.cwd, "skills", "vulcan-salute", "SKILL.md"))
	156	+ if !strings.Contains(text, "description: Greets the Vulcan way") \|\| !strings.Contains(text, "fingers parted.\nSay:") {
	157	+ t.Errorf("SKILL.md:\n%s", text)
	158	+ }
	159	+}
	160	+
	161	+// The agent being created decides where a skill made before its file goes
	162	+// (pendingAgentPlace): its layout and its skills answer, once given.
	163	+func TestPendingAgentPlace(t *testing.T) {
	164	+ yes, no := true, false
	165	+ cases := []struct {
	166	+ name string
	167	+ c agentinit.Choices
	168	+ ok bool
	169	+ dir string
	170	+ wantNote string
	171	+ }{
	172	+ {"layout not answered: LocateIn decides", agentinit.Choices{}, false, "", ""},
	173	+ {".mm layout, skills on", agentinit.Choices{Project: &yes, Skills: &yes}, true, ".mm/skills", ""},
	174	+ {".mm layout, skills not asked yet", agentinit.Choices{Project: &yes}, true, ".mm/skills", "Use skills?"},
	175	+ {".mm layout, no skills", agentinit.Choices{Project: &yes, Skills: &no}, true, ".mm/skills", "no-skills"},
	176	+ {"one agent.yaml, skills on", agentinit.Choices{Project: &no, Skills: &yes}, true, "skills", ""},
	177	+ }
	178	+ for _, c := range cases {
	179	+ place, ok := pendingAgentPlace("/p", c.c)
	180	+ if ok != c.ok {
	181	+ t.Errorf("%s: ok = %v", c.name, ok)
	182	+ continue
	183	+ }
	184	+ if !ok {
	185	+ continue
	186	+ }
	187	+ if place.Dir != filepath.Join("/p", c.dir) \|\| (c.wantNote == "") != (place.Note == "") \|\| !strings.Contains(place.Note, c.wantNote) {
	188	+ t.Errorf("%s: %+v", c.name, place)
	189	+ }
	190	+ }
	191	+}
	192	+
	193	+func TestSplitArgs(t *testing.T) {
	194	+ for in, want := range map[string]string{
	195	+ `--name "Vulcan Salute" --keywords 'a, b'`: `--name\|Vulcan Salute\|--keywords\|a, b`,
	196	+ ` --name hello `: `--name\|hello`,
	197	+ ``: ``,
	198	+ } {
	199	+ got, err := splitArgs(in)
	200	+ if err != nil \|\| strings.Join(got, "\|") != want {
	201	+ t.Errorf("splitArgs(%q) = %q, %v; want %q", in, got, err, want)
	202	+ }
	203	+ }
	204	+ if _, err := splitArgs(`--name "open`); err == nil {
	205	+ t.Error("an unclosed quote is accepted")
	206	+ }
	207	+ if _, err := parseSkillFlags("--nope x"); err == nil {
	208	+ t.Error("an unknown flag is accepted")
	209	+ }
	210	+}

++package acpcreate
++
++import (
++	"bytes"
++	"os"
++	"path/filepath"
++	"strings"
++	"testing"
++
++	"mm/internal/agentinit"
++	"mm/internal/config"
++	"mm/internal/skillcreate"
++)
++
++const skillBody = "Raise your right hand, fingers parted.\nSay: live long and prosper."
++
++// mmSkillcreate is the SKILL.md `mm skillcreate` writes with these answers,
++// in a project laid out the same way (.mm/agent.yaml, skillsDir .mm/skills).
++func mmSkillcreate(t *testing.T, args ...string) string {
++	t.Helper()
++	keepConfig(t)
++	dir := t.TempDir()
++	if err := os.MkdirAll(filepath.Join(dir, ".mm"), 0o755); err != nil {
++		t.Fatal(err)
++	}
++	if err := os.WriteFile(filepath.Join(dir, ".mm", "agent.yaml"), []byte("skillsDir: .mm/skills\n"), 0o644); err != nil {
++		t.Fatal(err)
++	}
++	t.Chdir(dir)
++	var out bytes.Buffer
++	if code := skillcreate.Main(append(args, "--yes", "--line"), strings.NewReader(""), &out); code != 0 {
++		t.Fatalf("mm skillcreate: exit %d\n%s", code, out.String())
++	}
++	return read(t, filepath.Join(dir, ".mm", "skills", "vulcan-salute", "SKILL.md"))
++}
++
++// /skillcreate in the middle of the agent's questions (ticket 213): the
++// skill's questions, a multi-line text, the SKILL.md mm skillcreate writes,
++// read back by mm — then the agent's next question, its answers kept. The
++// global settings are left alone.
++func TestSkillcreateConversation(t *testing.T) {
++	want := mmSkillcreate(t, "--name", "Vulcan Salute", "--description", "Greets the Vulcan way", "--keywords", "vulcan, greeting", "--body", skillBody)
++	client := &fakeClient{}
++	h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t), "--project", "yes", "--skills", "yes"}, client, "zed", false)
++	// The agent file first, so that the skill has a skills directory.
++	h.say("/start")
++	h.say("/write")
++	agentFile := filepath.Join(h.cwd, ".mm", "agent.yaml")
++	if _, err := os.Stat(agentFile); err != nil {
++		t.Fatal("no agent file")
++	}
++
++	before := config.Cfg.SkillsDir
++	if got := h.say(`/skillcreate --name "Vulcan Salute"`); !strings.Contains(got, "Description (one line)?") {
++		t.Fatalf("the name flag was not taken as given: %q\n%s", got, client.all())
++	}
++	if !strings.Contains(client.all(), filepath.Join(h.cwd, ".mm", "skills")) {
++		t.Errorf("the skills directory is not named:\n%s", client.all())
++	}
++	h.say("Greets the Vulcan way")
++	if got := h.say("vulcan, greeting"); !strings.Contains(got, "What to do") || !strings.Contains(got, "several lines are fine") {
++		t.Fatalf("the text question: %q", got)
++	}
++	if got := h.say("/preview"); !strings.Contains(got, "```markdown") || !strings.Contains(got, "name: vulcan-salute") {
++		t.Errorf("/preview during a skill: %q", got)
++	}
++	end := strings.Join([]string{h.say(skillBody), client.all()}, "\n")
++	got := read(t, filepath.Join(h.cwd, ".mm", "skills", "vulcan-salute", "SKILL.md"))
++	if got != want {
++		t.Errorf("SKILL.md differs from mm skillcreate's:\n--- acp-create\n%s\n--- mm skillcreate\n%s", got, want)
++	}
++	if !strings.Contains(got, "fingers parted.\nSay:") {
++		t.Errorf("the text lost its line break:\n%s", got)
++	}
++	for _, s := range []string{"✅ wrote", "✅ mm reads it: vulcan-salute", "Reload Agent"} {
++		if !strings.Contains(end, s) {
++			t.Errorf("closing messages lack %q:\n%s", s, end)
++		}
++	}
++	if config.Cfg.SkillsDir != before {
++		t.Errorf("the global settings changed: skillsDir %q → %q", before, config.Cfg.SkillsDir)
++	}
++}
++
++// Half way through the agent: the skill, then back to the agent's question,
++// with the answers given before still there.
++func TestSkillcreateComesBackToTheAgent(t *testing.T) {
++	client := &fakeClient{}
++	h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", false)
++	h.say("/start")
++	if got := h.say("yes"); !strings.Contains(got, "Model?") { // project: yes
++		t.Fatalf("after the layout: %q", got)
++	}
++	h.say(`/skillcreate --name hello --description "Says hello" --keywords hi`)
++	if got := h.say("Say hello."); !strings.Contains(got, "Model?") || !strings.Contains(client.all(), "Back to the agent") {
++		t.Fatalf("the agent's question did not come back: %q", got)
++	}
++	// No agent file yet — nor .mm/, created with it —, but the agent being
++	// created has the .mm layout: the skill goes to .mm/skills, where it
++	// will read its skills, and the note says "Use skills?" is still to come.
++	if _, err := os.Stat(filepath.Join(h.cwd, ".mm", "skills", "hello", "SKILL.md")); err != nil {
++		t.Errorf("the skill is not in .mm/skills: %v", err)
++	}
++	if !strings.Contains(client.all(), `answer yes to "Use skills?"`) {
++		t.Errorf("no note about the skills question:\n%s", client.all())
++	}
++	if got := h.say("/preview"); !strings.Contains(got, ".mm/skills") {
++		t.Errorf("the agent's answer to the layout was lost: %q", got)
++	}
++}
++
++// /cancel gives the skill up: nothing written, the agent's question back.
++// An existing skill asks before it is replaced; "no" asks the name again.
++func TestSkillcreateCancelAndExisting(t *testing.T) {
++	client := &fakeClient{}
++	h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", false)
++	h.say("/start")
++	h.say(`/skillcreate --name hello`)
++	if got := h.say("/cancel"); !strings.Contains(got, ".mm folder?") || !strings.Contains(client.all(), "nothing written") {
++		t.Errorf("/cancel: %q", got)
++	}
++	if _, err := os.Stat(filepath.Join(h.cwd, "skills")); err == nil {
++		t.Error("/cancel wrote something")
++	}
++	if got := h.say("/cancel"); !strings.Contains(got, "No skill") {
++		t.Errorf("/cancel with no skill: %q", got)
++	}
++	h.say(`/skillcreate --name hello --description d --keywords k --body b`)
++	if _, err := os.Stat(filepath.Join(h.cwd, "skills", "hello", "SKILL.md")); err != nil {
++		t.Fatalf("the skill was not written in skills/: %v", err)
++	}
++	if got := h.say(`/skillcreate --name hello`); !strings.Contains(got, "Replace hello?") {
++		t.Fatalf("an existing skill was not asked about: %q", got)
++	}
++	if got := h.say("no"); !strings.Contains(got, "Skill name?") {
++		t.Errorf("no: the name is not asked again: %q", got)
++	}
++}
++
++// With forms: the name, the description and the keywords in one form (no
++// skill of that name: no question about replacing it); the text is asked
++// as a message even then.
++func TestSkillcreateForms(t *testing.T) {
++	given := map[string]any{"name": "Vulcan Salute", "description": "Greets the Vulcan way", "keywords": "vulcan, greeting"}
++	client := &fakeClient{answer: func(key string, _ map[string]any) any { return given[key] }}
++	h := start(t, []string{"--provider", "llmman", "--base-url", llmmanStub(t)}, client, "x", true)
++	got := h.say("/skillcreate")
++	if !strings.Contains(got, "What to do") {
++		t.Fatalf("the text is not asked as a message: %q", got)
++	}
++	if len(client.forms) != 1 || strings.Join(client.forms[0], ",") != "description,keywords,name" {
++		t.Errorf("forms = %v, want one with description, keywords and name", client.forms)
++	}
++	h.say(skillBody)
++	text := read(t, filepath.Join(h.cwd, "skills", "vulcan-salute", "SKILL.md"))
++	if !strings.Contains(text, "description: Greets the Vulcan way") || !strings.Contains(text, "fingers parted.\nSay:") {
++		t.Errorf("SKILL.md:\n%s", text)
++	}
++}
++
++// The agent being created decides where a skill made before its file goes
++// (pendingAgentPlace): its layout and its skills answer, once given.
++func TestPendingAgentPlace(t *testing.T) {
++	yes, no := true, false
++	cases := []struct {
++		name     string
++		c        agentinit.Choices
++		ok       bool
++		dir      string
++		wantNote string
++	}{
++		{"layout not answered: LocateIn decides", agentinit.Choices{}, false, "", ""},
++		{".mm layout, skills on", agentinit.Choices{Project: &yes, Skills: &yes}, true, ".mm/skills", ""},
++		{".mm layout, skills not asked yet", agentinit.Choices{Project: &yes}, true, ".mm/skills", "Use skills?"},
++		{".mm layout, no skills", agentinit.Choices{Project: &yes, Skills: &no}, true, ".mm/skills", "no-skills"},
++		{"one agent.yaml, skills on", agentinit.Choices{Project: &no, Skills: &yes}, true, "skills", ""},
++	}
++	for _, c := range cases {
++		place, ok := pendingAgentPlace("/p", c.c)
++		if ok != c.ok {
++			t.Errorf("%s: ok = %v", c.name, ok)
++			continue
++		}
++		if !ok {
++			continue
++		}
++		if place.Dir != filepath.Join("/p", c.dir) || (c.wantNote == "") != (place.Note == "") || !strings.Contains(place.Note, c.wantNote) {
++			t.Errorf("%s: %+v", c.name, place)
++		}
++	}
++}
++
++func TestSplitArgs(t *testing.T) {
++	for in, want := range map[string]string{
++		`--name "Vulcan Salute" --keywords 'a, b'`: `--name|Vulcan Salute|--keywords|a, b`,
++		`  --name   hello  `:                       `--name|hello`,
++		``:                                         ``,
++	} {
++		got, err := splitArgs(in)
++		if err != nil || strings.Join(got, "|") != want {
++			t.Errorf("splitArgs(%q) = %q, %v; want %q", in, got, err, want)
++		}
++	}
++	if _, err := splitArgs(`--name "open`); err == nil {
++		t.Error("an unclosed quote is accepted")
++	}
++	if _, err := parseSkillFlags("--nope x"); err == nil {
++		t.Error("an unknown flag is accepted")
++	}
++}

added internal/acpcreate/wizard.go +58 -0 Viewed

new file mode 100644
@@ -0,0 +1,58 @@
	1	+package acpcreate
	2	+
	3	+import (
	4	+ "mm/internal/agentinit"
	5	+)
	6	+
	7	+// wizard is the questions a session asks: mm init's (agentinit.Flow) or mm
	8	+// skillcreate's (skillcreate.Flow, ticket 213). Both expose them the same
	9	+// way, as agentinit.Steps, so that the conversation, the forms, /back and
	10	+// /write work for either.
	11	+type wizard interface {
	12	+ Steps() []agentinit.Step
	13	+ Pending() []agentinit.Step
	14	+ Step(key string) agentinit.Step
	15	+ Set(key, value string) error
	16	+ Unset(key string)
	17	+}
	18	+
	19	+var (
	20	+ _ wizard = (*agentinit.Flow)(nil)
	21	+)
	22	+
	23	+// run is one wizard being asked in a session: its questions, where the
	24	+// conversation stands, and what to do once nothing is left to ask.
	25	+type run struct {
	26	+ w wizard
	27	+ // asked is the question shown in the chat and waiting for the next
	28	+ // prompt (conversation mode, or a multi-line text in form mode); ""
	29	+ // when none.
	30	+ asked string
	31	+ // answered is the keys answered here, in order — what /back takes back.
	32	+ answered []string
	33	+ // deps says which answers each question is built from (batch).
	34	+ deps map[string][]string
	35	+ // finish writes the file once every question is answered.
	36	+ finish func(t *turn)
	37	+ // preview is the file as it stands, ready to show (/preview).
	38	+ preview func() string
	39	+}
	40	+
	41	+// agentRun is the run of mm init's questions on flow.
	42	+func agentRun(flow *agentinit.Flow) run {
	43	+ return run{
	44	+ w: flow,
	45	+ deps: agentDeps,
	46	+ finish: func(t *turn) { t.write() },
	47	+ preview: func() string { return "```yaml\n" + flow.Preview("", "") + "```" },
	48	+ }
	49	+}
	50	+
	51	+// cur is the run the session asks now: the skill being created, if any,
	52	+// else the agent's.
	53	+func (s session) cur() run {
	54	+ if s.skill != nil {
	55	+ return s.skill
	56	+ }
	57	+ return &s.agent
	58	+}

++package acpcreate
++
++import (
++	"mm/internal/agentinit"
++)
++
++// wizard is the questions a session asks: mm init's (agentinit.Flow) or mm
++// skillcreate's (skillcreate.Flow, ticket 213). Both expose them the same
++// way, as agentinit.Steps, so that the conversation, the forms, /back and
++// /write work for either.
++type wizard interface {
++	Steps() []agentinit.Step
++	Pending() []agentinit.Step
++	Step(key string) agentinit.Step
++	Set(key, value string) error
++	Unset(key string)
++}
++
++var (
++	_ wizard = (*agentinit.Flow)(nil)
++)
++
++// run is one wizard being asked in a session: its questions, where the
++// conversation stands, and what to do once nothing is left to ask.
++type run struct {
++	w wizard
++	// asked is the question shown in the chat and waiting for the next
++	// prompt (conversation mode, or a multi-line text in form mode); ""
++	// when none.
++	asked string
++	// answered is the keys answered here, in order — what /back takes back.
++	answered []string
++	// deps says which answers each question is built from (batch).
++	deps map[string][]string
++	// finish writes the file once every question is answered.
++	finish func(t *turn)
++	// preview is the file as it stands, ready to show (/preview).
++	preview func() string
++}
++
++// agentRun is the run of mm init's questions on flow.
++func agentRun(flow *agentinit.Flow) run {
++	return run{
++		w:       flow,
++		deps:    agentDeps,
++		finish:  func(t *turn) { t.write() },
++		preview: func() string { return "```yaml\n" + flow.Preview("", "") + "```" },
++	}
++}
++
++// cur is the run the session asks now: the skill being created, if any,
++// else the agent's.
++func (s *session) cur() *run {
++	if s.skill != nil {
++		return s.skill
++	}
++	return &s.agent
++}

modified internal/agentinit/flow.go +5 -0 Viewed

@@ -572,6 +572,11 @@ func (f *Flow) Preview(key, candidate string) string {
572	572	return Render(Decide(f.presets, c, f.modelFacts()))
573	573	}
574	574
	575	+// Choices is the answers so far, as they stand — unlike Result, it asks
	576	+// the server nothing. mm acp-create's /skillcreate reads the layout and the
	577	+// skills answer of an agent not written yet from it (ticket 213).
	578	+func (f *Flow) Choices() Choices { return f.c }
	579	+
575	580	// Result is the answers, the facts and the file to write, once every
576	581	// question is answered.
577	582	func (f *Flow) Result() (Choices, Facts, string) {

  	return Render(Decide(f.presets, c, f.modelFacts()))
  }
++// Choices is the answers so far, as they stand — unlike Result, it asks
++// the server nothing. mm acp-create's /skillcreate reads the layout and the
++// skills answer of an agent not written yet from it (ticket 213).
++func (f *Flow) Choices() Choices { return f.c }
++
  // Result is the answers, the facts and the file to write, once every
  // question is answered.
  func (f *Flow) Result() (Choices, Facts, string) {

added internal/skillcreate/locatein_test.go +78 -0 Viewed

new file mode 100644
@@ -0,0 +1,78 @@
	1	+package skillcreate
	2	+
	3	+import (
	4	+ "os"
	5	+ "path/filepath"
	6	+ "strings"
	7	+ "testing"
	8	+
	9	+ "mm/internal/config"
	10	+)
	11	+
	12	+// LocateIn (ticket 213) finds the skills directory of the project in dir as
	13	+// mm reads it there — agent.yaml, then .mm/agent.yaml, its skillsDir from
	14	+// the project root — and never loads the file into the global settings.
	15	+func TestLocateIn(t *testing.T) {
	16	+ write := func(t *testing.T, dir, path, text string) {
	17	+ t.Helper()
	18	+ full := filepath.Join(dir, path)
	19	+ if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
	20	+ t.Fatal(err)
	21	+ }
	22	+ if err := os.WriteFile(full, []byte(text), 0o644); err != nil {
	23	+ t.Fatal(err)
	24	+ }
	25	+ }
	26	+ cases := []struct {
	27	+ name string
	28	+ files map[string]string
	29	+ mkdir string
	30	+ wantDir string
	31	+ wantNote string
	32	+ }{
	33	+ {"a .mm project with skills", map[string]string{".mm/agent.yaml": "skillsDir: .mm/skills\n"}, "", ".mm/skills", ""},
	34	+ {"agent.yaml wins over .mm/agent.yaml", map[string]string{"agent.yaml": "skillsDir: mine\n", ".mm/agent.yaml": "skillsDir: .mm/skills\n"}, "", "mine", ""},
	35	+ {"no skillsDir key: mm's default", map[string]string{"agent.yaml": "model: m\n"}, "", "skills", ""},
	36	+ {"skillsDir: no-skills in a .mm project", map[string]string{".mm/agent.yaml": "skillsDir: no-skills\n"}, "", ".mm/skills", "set skillsDir: .mm/skills"},
	37	+ {"no agent file, a .mm folder", nil, ".mm", ".mm/skills", "no agent file in this project"},
	38	+ {"no agent file, nothing", nil, "", "skills", "no agent file in this project"},
	39	+ }
	40	+ for _, c := range cases {
	41	+ t.Run(c.name, func(t *testing.T) {
	42	+ before := config.Cfg.SkillsDir
	43	+ dir := t.TempDir()
	44	+ for p, text := range c.files {
	45	+ write(t, dir, p, text)
	46	+ }
	47	+ if c.mkdir != "" {
	48	+ if err := os.MkdirAll(filepath.Join(dir, c.mkdir), 0o755); err != nil {
	49	+ t.Fatal(err)
	50	+ }
	51	+ }
	52	+ place, err := LocateIn(dir)
	53	+ if err != nil {
	54	+ t.Fatal(err)
	55	+ }
	56	+ if place.Dir != filepath.Join(dir, c.wantDir) {
	57	+ t.Errorf("Dir = %s, want %s", place.Dir, filepath.Join(dir, c.wantDir))
	58	+ }
	59	+ if (c.wantNote == "") != (place.Note == "") \|\| !strings.Contains(place.Note, c.wantNote) {
	60	+ t.Errorf("Note = %q, want one with %q", place.Note, c.wantNote)
	61	+ }
	62	+ if config.Cfg.SkillsDir != before {
	63	+ t.Errorf("the global settings changed: skillsDir %q → %q", before, config.Cfg.SkillsDir)
	64	+ }
	65	+ })
	66	+ }
	67	+}
	68	+
	69	+// configDefaultSkillsDir is read when the test binary starts, before any
	70	+// test loads a file into config.Cfg: it is the package default.
	71	+var configDefaultSkillsDir = config.Cfg.SkillsDir
	72	+
	73	+// LocateIn's default is mm's: the package default of internal/config.
	74	+func TestDefaultSkillsDirIsConfigs(t *testing.T) {
	75	+ if configDefaultSkillsDir != defaultSkillsDir {
	76	+ t.Errorf("config's default skillsDir is %q, LocateIn's %q", configDefaultSkillsDir, defaultSkillsDir)
	77	+ }
	78	+}

++package skillcreate
++
++import (
++	"os"
++	"path/filepath"
++	"strings"
++	"testing"
++
++	"mm/internal/config"
++)
++
++// LocateIn (ticket 213) finds the skills directory of the project in dir as
++// mm reads it there — agent.yaml, then .mm/agent.yaml, its skillsDir from
++// the project root — and never loads the file into the global settings.
++func TestLocateIn(t *testing.T) {
++	write := func(t *testing.T, dir, path, text string) {
++		t.Helper()
++		full := filepath.Join(dir, path)
++		if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
++			t.Fatal(err)
++		}
++		if err := os.WriteFile(full, []byte(text), 0o644); err != nil {
++			t.Fatal(err)
++		}
++	}
++	cases := []struct {
++		name     string
++		files    map[string]string
++		mkdir    string
++		wantDir  string
++		wantNote string
++	}{
++		{"a .mm project with skills", map[string]string{".mm/agent.yaml": "skillsDir: .mm/skills\n"}, "", ".mm/skills", ""},
++		{"agent.yaml wins over .mm/agent.yaml", map[string]string{"agent.yaml": "skillsDir: mine\n", ".mm/agent.yaml": "skillsDir: .mm/skills\n"}, "", "mine", ""},
++		{"no skillsDir key: mm's default", map[string]string{"agent.yaml": "model: m\n"}, "", "skills", ""},
++		{"skillsDir: no-skills in a .mm project", map[string]string{".mm/agent.yaml": "skillsDir: no-skills\n"}, "", ".mm/skills", "set skillsDir: .mm/skills"},
++		{"no agent file, a .mm folder", nil, ".mm", ".mm/skills", "no agent file in this project"},
++		{"no agent file, nothing", nil, "", "skills", "no agent file in this project"},
++	}
++	for _, c := range cases {
++		t.Run(c.name, func(t *testing.T) {
++			before := config.Cfg.SkillsDir
++			dir := t.TempDir()
++			for p, text := range c.files {
++				write(t, dir, p, text)
++			}
++			if c.mkdir != "" {
++				if err := os.MkdirAll(filepath.Join(dir, c.mkdir), 0o755); err != nil {
++					t.Fatal(err)
++				}
++			}
++			place, err := LocateIn(dir)
++			if err != nil {
++				t.Fatal(err)
++			}
++			if place.Dir != filepath.Join(dir, c.wantDir) {
++				t.Errorf("Dir = %s, want %s", place.Dir, filepath.Join(dir, c.wantDir))
++			}
++			if (c.wantNote == "") != (place.Note == "") || !strings.Contains(place.Note, c.wantNote) {
++				t.Errorf("Note = %q, want one with %q", place.Note, c.wantNote)
++			}
++			if config.Cfg.SkillsDir != before {
++				t.Errorf("the global settings changed: skillsDir %q → %q", before, config.Cfg.SkillsDir)
++			}
++		})
++	}
++}
++
++// configDefaultSkillsDir is read when the test binary starts, before any
++// test loads a file into config.Cfg: it is the package default.
++var configDefaultSkillsDir = config.Cfg.SkillsDir
++
++// LocateIn's default is mm's: the package default of internal/config.
++func TestDefaultSkillsDirIsConfigs(t *testing.T) {
++	if configDefaultSkillsDir != defaultSkillsDir {
++		t.Errorf("config's default skillsDir is %q, LocateIn's %q", configDefaultSkillsDir, defaultSkillsDir)
++	}
++}

modified internal/skillcreate/main.go +32 -17 Viewed

@@ -73,7 +73,7 @@ func Main(args []string, stdin io.Reader, stdout io.Writer, opts ...Options) int
73	73	return 1
74	74	}
75	75	flow := NewFlow(place, Spec{}, output)
76		- if err := flow.setGiven(spec); err != nil {
	76	+ if err := flow.SetGiven(spec); err != nil {
77	77	fmt.Fprintln(stdout, "⚠️ "+err.Error())
78	78	return 1
79	79	}
@@ -103,9 +103,9 @@ func Main(args []string, stdin io.Reader, stdout io.Writer, opts ...Options) int
103	103	return finish(flow, stdout)
104	104	}
105	105
106		-// setGiven records the flags' answers, refusing a value no question would
107		-// accept.
108		-func (f *Flow) setGiven(s Spec) error {
	106	+// SetGiven records the flags' answers — never asked —, refusing a value no
	107	+// question would accept. mm acp-create's /skillcreate uses it too.
	108	+func (f *Flow) SetGiven(s Spec) error {
109	109	for _, kv := range [][2]string{{"name", s.Name}, {"description", s.Description}, {"keywords", s.Keywords}, {"body", s.Body}} {
110	110	if kv[1] == "" {
111	111	continue
@@ -138,33 +138,48 @@ func (f *Flow) takeDefaults() error {
138	138
139	139	// finish writes the skill the flow describes and reads it back.
140	140	func finish(flow *Flow, stdout io.Writer) int {
	141	+ if _, ok := WriteSkill(flow, stdout); !ok {
	142	+ return 1
	143	+ }
	144	+ _, place, output := flow.Result()
	145	+ if output == "-" \|\| place.Note != "" {
	146	+ return 0
	147	+ }
	148	+ fmt.Fprintln(stdout, "Next: start mm from this directory — the banner counts it under skills: N")
	149	+ return 0
	150	+}
	151	+
	152	+// WriteSkill writes the skill the answered flow describes — or prints it,
	153	+// for "-" —, reads it back with mm's own loader, and says the place's note,
	154	+// reporting each step on out. It returns the file written and whether
	155	+// everything went well. mm skillcreate and mm acp-create's /skillcreate
	156	+// both end with it.
	157	+func WriteSkill(flow *Flow, out io.Writer) (string, bool) {
141	158	spec, place, output := flow.Result()
142	159	if output == "-" {
143		- fmt.Fprint(stdout, Render(spec))
144		- return 0
	160	+ fmt.Fprint(out, Render(spec))
	161	+ return output, true
145	162	}
146	163	path, err := write(flow, spec, place, output)
147	164	if err != nil {
148		- fmt.Fprintln(stdout, "⚠️ "+err.Error())
149		- return 1
	165	+ fmt.Fprintln(out, "⚠️ "+err.Error())
	166	+ return "", false
150	167	}
151		- fmt.Fprintf(stdout, "✅ wrote %s\n", path)
	168	+ fmt.Fprintf(out, "✅ wrote %s\n", path)
152	169	if n := len(KeywordList(spec.Keywords)); n > skills.MaxKeywords {
153		- fmt.Fprintf(stdout, "⚠️ %d keywords: only the first %d reach the catalogue — put the most distinctive first\n", n, skills.MaxKeywords)
	170	+ fmt.Fprintf(out, "⚠️ %d keywords: only the first %d reach the catalogue — put the most distinctive first\n", n, skills.MaxKeywords)
154	171	}
155	172	if path == File(place.Dir, spec.Name) {
156	173	if err := Verify(place.Dir, spec); err != nil {
157		- fmt.Fprintln(stdout, "⚠️ "+err.Error())
158		- return 1
	174	+ fmt.Fprintln(out, "⚠️ "+err.Error())
	175	+ return path, false
159	176	}
160		- fmt.Fprintf(stdout, "✅ mm reads it: %s — %s\n", Normalize(spec.Name), oneLine(spec.Description))
	177	+ fmt.Fprintf(out, "✅ mm reads it: %s — %s\n", Normalize(spec.Name), oneLine(spec.Description))
161	178	}
162	179	if place.Note != "" {
163		- fmt.Fprintln(stdout, "⚠️ "+place.Note)
164		- return 0
	180	+ fmt.Fprintln(out, "⚠️ "+place.Note)
165	181	}
166		- fmt.Fprintln(stdout, "Next: start mm from this directory — the banner counts it under skills: N")
167		- return 0
	182	+ return path, true
168	183	}
169	184
170	185	// write writes the skill where Output says: the skills directory, or the -o

  		return 1
  	}
  	flow := NewFlow(place, Spec{}, output)
--	if err := flow.setGiven(spec); err != nil {
++	if err := flow.SetGiven(spec); err != nil {
  		fmt.Fprintln(stdout, "⚠️ "+err.Error())
  		return 1
  	}
  	return finish(flow, stdout)
  }
--// setGiven records the flags' answers, refusing a value no question would
++// SetGiven records the flags' answers — never asked —, refusing a value no
--// accept.
++// question would accept. mm acp-create's /skillcreate uses it too.
--func (f *Flow) setGiven(s Spec) error {
++func (f *Flow) SetGiven(s Spec) error {
  	for _, kv := range [][2]string{{"name", s.Name}, {"description", s.Description}, {"keywords", s.Keywords}, {"body", s.Body}} {
  		if kv[1] == "" {
  			continue
  // finish writes the skill the flow describes and reads it back.
  func finish(flow *Flow, stdout io.Writer) int {
++	if _, ok := WriteSkill(flow, stdout); !ok {
++		return 1
++	}
++	_, place, output := flow.Result()
++	if output == "-" || place.Note != "" {
++		return 0
++	}
++	fmt.Fprintln(stdout, "Next: start mm from this directory — the banner counts it under skills: N")
++	return 0
++}
++
++// WriteSkill writes the skill the answered flow describes — or prints it,
++// for "-" —, reads it back with mm's own loader, and says the place's note,
++// reporting each step on out. It returns the file written and whether
++// everything went well. mm skillcreate and mm acp-create's /skillcreate
++// both end with it.
++func WriteSkill(flow *Flow, out io.Writer) (string, bool) {
  	spec, place, output := flow.Result()
  	if output == "-" {
--		fmt.Fprint(stdout, Render(spec))
++		fmt.Fprint(out, Render(spec))
--		return 0
++		return output, true
  	}
  	path, err := write(flow, spec, place, output)
  	if err != nil {
--		fmt.Fprintln(stdout, "⚠️ "+err.Error())
++		fmt.Fprintln(out, "⚠️ "+err.Error())
--		return 1
++		return "", false
  	}
--	fmt.Fprintf(stdout, "✅ wrote %s\n", path)
++	fmt.Fprintf(out, "✅ wrote %s\n", path)
  	if n := len(KeywordList(spec.Keywords)); n > skills.MaxKeywords {
--		fmt.Fprintf(stdout, "⚠️ %d keywords: only the first %d reach the catalogue — put the most distinctive first\n", n, skills.MaxKeywords)
++		fmt.Fprintf(out, "⚠️ %d keywords: only the first %d reach the catalogue — put the most distinctive first\n", n, skills.MaxKeywords)
  	}
  	if path == File(place.Dir, spec.Name) {
  		if err := Verify(place.Dir, spec); err != nil {
--			fmt.Fprintln(stdout, "⚠️ "+err.Error())
++			fmt.Fprintln(out, "⚠️ "+err.Error())
--			return 1
++			return path, false
  		}
--		fmt.Fprintf(stdout, "✅ mm reads it: %s — %s\n", Normalize(spec.Name), oneLine(spec.Description))
++		fmt.Fprintf(out, "✅ mm reads it: %s — %s\n", Normalize(spec.Name), oneLine(spec.Description))
  	}
  	if place.Note != "" {
--		fmt.Fprintln(stdout, "⚠️ "+place.Note)
++		fmt.Fprintln(out, "⚠️ "+place.Note)
--		return 0
  	}
--	fmt.Fprintln(stdout, "Next: start mm from this directory — the banner counts it under skills: N")
++	return path, true
--	return 0
  }
  // write writes the skill where Output says: the skills directory, or the -o

modified internal/skillcreate/place.go +63 -0 Viewed

@@ -10,6 +10,8 @@ import (
10	10
11	11	"mm/internal/config"
12	12	"mm/internal/skills"
	13	+
	14	+ "gopkg.in/yaml.v3"
13	15	)
14	16
15	17	// noSkills is the skillsDir `mm init` writes for an agent without skills.
@@ -54,6 +56,67 @@ func Locate(configPath string) (Place, error) {
54	56	return p, nil
55	57	}
56	58
	59	+// defaultSkillsDir is mm's skillsDir when an agent file names none — the
	60	+// default of internal/config (a test keeps them equal). Not read from
	61	+// config.Cfg: LocateIn must not depend on whatever config a process loaded.
	62	+const defaultSkillsDir = "skills"
	63	+
	64	+// LocateIn is Locate for the project in dir, without loading the agent file
	65	+// into the global settings and without the process's working directory or
	66	+// AGENT_CONFIG — what mm acp-create needs (ticket 213): its project is the
	67	+// session's cwd, and several sessions may run in one process. The agent
	68	+// file is found as mm finds it in a project, agent.yaml then
	69	+// .mm/agent.yaml; its skillsDir is read from the project root (the parent
	70	+// of .mm/ for .mm/agent.yaml, as mm reads it there). Place.Dir and
	71	+// Place.Config are absolute; Note names the folders as seen from dir.
	72	+//
	73	+// place, err := skillcreate.LocateIn("/home/me/project")
	74	+// // place.Dir == "/home/me/project/.mm/skills" for a project made by mm init --project yes --skills yes
	75	+func LocateIn(dir string) (Place, error) {
	76	+ rel, dirName := "", ""
	77	+ for _, name := range []string{config.DefaultPath, filepath.Join(config.ProjectDir, config.DefaultPath)} {
	78	+ if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
	79	+ rel = name
	80	+ break
	81	+ }
	82	+ }
	83	+ if rel != "" {
	84	+ data, err := os.ReadFile(filepath.Join(dir, rel))
	85	+ if err != nil {
	86	+ return Place{}, err
	87	+ }
	88	+ var file struct {
	89	+ SkillsDir *string `yaml:"skillsDir"`
	90	+ }
	91	+ if err := yaml.Unmarshal(data, &file); err != nil {
	92	+ return Place{}, fmt.Errorf("%s: %v", rel, err)
	93	+ }
	94	+ dirName = defaultSkillsDir
	95	+ if file.SkillsDir != nil {
	96	+ dirName = *file.SkillsDir
	97	+ }
	98	+ }
	99	+ if rel != "" && dirName != "" && dirName != noSkills {
	100	+ abs := dirName
	101	+ if !filepath.IsAbs(abs) {
	102	+ abs = filepath.Join(dir, abs)
	103	+ }
	104	+ return Place{Dir: abs, Config: filepath.Join(dir, rel)}, nil
	105	+ }
	106	+ fallback := "skills"
	107	+ if info, err := os.Stat(filepath.Join(dir, config.ProjectDir)); err == nil && info.IsDir() {
	108	+ fallback = filepath.Join(config.ProjectDir, "skills")
	109	+ }
	110	+ p := Place{Dir: filepath.Join(dir, fallback)}
	111	+ if rel == "" {
	112	+ p.Note = fmt.Sprintf("no agent file in this project: an agent sees this skill with skillsDir: %s", fallback)
	113	+ } else {
	114	+ p.Config = filepath.Join(dir, rel)
	115	+ p.Note = fmt.Sprintf("%s has no skills (skillsDir: %s): set skillsDir: %s for the agent to see this skill", rel, dirName, fallback)
	116	+ }
	117	+ return p, nil
	118	+}
	119	+
57	120	// File is the skill's file in dir: one folder per skill.
58	121	//
59	122	// File(".mm/skills", "Vulcan Salute") // ".mm/skills/vulcan-salute/SKILL.md"

  	"mm/internal/config"
  	"mm/internal/skills"
++
++	"gopkg.in/yaml.v3"
  )
  // noSkills is the skillsDir `mm init` writes for an agent without skills.
  	return p, nil
  }
++// defaultSkillsDir is mm's skillsDir when an agent file names none — the
++// default of internal/config (a test keeps them equal). Not read from
++// config.Cfg: LocateIn must not depend on whatever config a process loaded.
++const defaultSkillsDir = "skills"
++
++// LocateIn is Locate for the project in dir, without loading the agent file
++// into the global settings and without the process's working directory or
++// AGENT_CONFIG — what mm acp-create needs (ticket 213): its project is the
++// session's cwd, and several sessions may run in one process. The agent
++// file is found as mm finds it in a project, agent.yaml then
++// .mm/agent.yaml; its skillsDir is read from the project root (the parent
++// of .mm/ for .mm/agent.yaml, as mm reads it there). Place.Dir and
++// Place.Config are absolute; Note names the folders as seen from dir.
++//
++//	place, err := skillcreate.LocateIn("/home/me/project")
++//	// place.Dir == "/home/me/project/.mm/skills" for a project made by mm init --project yes --skills yes
++func LocateIn(dir string) (Place, error) {
++	rel, dirName := "", ""
++	for _, name := range []string{config.DefaultPath, filepath.Join(config.ProjectDir, config.DefaultPath)} {
++		if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
++			rel = name
++			break
++		}
++	}
++	if rel != "" {
++		data, err := os.ReadFile(filepath.Join(dir, rel))
++		if err != nil {
++			return Place{}, err
++		}
++		var file struct {
++			SkillsDir *string `yaml:"skillsDir"`
++		}
++		if err := yaml.Unmarshal(data, &file); err != nil {
++			return Place{}, fmt.Errorf("%s: %v", rel, err)
++		}
++		dirName = defaultSkillsDir
++		if file.SkillsDir != nil {
++			dirName = *file.SkillsDir
++		}
++	}
++	if rel != "" && dirName != "" && dirName != noSkills {
++		abs := dirName
++		if !filepath.IsAbs(abs) {
++			abs = filepath.Join(dir, abs)
++		}
++		return Place{Dir: abs, Config: filepath.Join(dir, rel)}, nil
++	}
++	fallback := "skills"
++	if info, err := os.Stat(filepath.Join(dir, config.ProjectDir)); err == nil && info.IsDir() {
++		fallback = filepath.Join(config.ProjectDir, "skills")
++	}
++	p := Place{Dir: filepath.Join(dir, fallback)}
++	if rel == "" {
++		p.Note = fmt.Sprintf("no agent file in this project: an agent sees this skill with skillsDir: %s", fallback)
++	} else {
++		p.Config = filepath.Join(dir, rel)
++		p.Note = fmt.Sprintf("%s has no skills (skillsDir: %s): set skillsDir: %s for the agent to see this skill", rel, dirName, fallback)
++	}
++	return p, nil
++}
++
  // File is the skill's file in dir: one folder per skill.
  //
  //	File(".mm/skills", "Vulcan Salute") // ".mm/skills/vulcan-salute/SKILL.md"

✨ mm acp-create: a /skillcreate command (ticket 213)