@holt-os/holt 0.16.0 → 0.17.0

package/README.md

@@ -22,7 +22,8 @@
 - **Private memory you can see.** Per-folder semantic recall and distilled facts, an interactive knowledge graph (`holt graph`), and a self-maintaining wiki (`holt wiki`) over everything you tell it. Nothing leaves your machine.
 - **Ambient by default.** `holt hook` wires memory into Claude Code so it recalls and remembers with no manual step, and an MCP server exposes the same memory to Cursor and Codex.
 - **Runs your work.** Run a task once, on a schedule, or as a named routine, and reach it from your phone over Telegram.
-- **Extensible, zero-infra.** Ten built-in skills plus a git-based community registry (`holt skill search`) in the portable `SKILL.md` format.
+- **Useful on day one.** `/skill onboard` interviews you and fills memory in about fifteen minutes, `/skill audit` shows what is still missing, and `/skill level-up` turns one manual chore a week into something Holt does.
+- **Extensible, zero-infra.** Thirteen built-in skills plus a git-based community registry (`holt skill search`) in the portable `SKILL.md` format.
 - **Writes in your voice.** `holt write` drafts in a style Holt learns from you, with built-in anti-AI checks.
 
 > **Status:** shipping and usable today. Every capability above works now.
@@ -43,6 +44,14 @@ Or with npm, if you already have Node:
 npm install -g @holt-os/holt
 ```
 
+**Not comfortable in a terminal?** Install [Claude Code](https://claude.com/claude-code), open it, and paste this:
+
+```
+Set up Holt for me: read https://raw.githubusercontent.com/holt-os/holt/main/docs/INSTALL.md and follow it exactly.
+```
+
+It installs Holt, checks its own work, and fixes what breaks. Full detail, system requirements, and troubleshooting: [docs/INSTALL.md](./docs/INSTALL.md).
+
 ## Quickstart
 
 ```bash
@@ -139,6 +148,8 @@ Every exchange is saved to `<folder>/.holt/memory/turns.jsonl`, private and loca
 
 When you end a chat, Holt asks the brain to distill 1 to 5 durable facts from the session (decisions, preferences, key names, numbers) and writes them to a human-readable `<folder>/.holt/memory/facts.md` you can read and edit. Those facts are also embedded and ranked slightly higher than raw turns during recall, so the signal rises to the top over time. See them with `holt memory facts`. Turn it off by setting `memory.extractFacts` to `false` in `config.json`.
 
+You do not have to wait for the end of a session. `holt memory add "<fact>"` saves one immediately, and duplicates are ignored, so it is safe to run twice. Piping in several facts, one per line, works too. Prefer this over editing `facts.md` by hand: a fact typed straight into that file is never embedded, so semantic recall will not find it.
+
 Two recall modes, picked automatically:
 
 - **Semantic** (best): a local [Ollama](https://ollama.com) with an embedding model, which `holt init` offers to set up for you. Recall matches by meaning: asking "who owns my apartment" finds "my landlord is called Pieter". No API keys, nothing leaves your machine.
@@ -148,6 +159,7 @@ Inspect it any time:
 
 ```bash
 holt memory                    # stats for this folder
+holt memory add "<fact>"       # teach it something durable right now
 holt memory facts              # show the distilled facts (facts.md)
 holt memory search <query>     # find remembered moments
 holt memory embed              # embed older moments for semantic recall
@@ -315,6 +327,11 @@ Holt ships with a small, curated set of general-purpose skills, available in eve
 - **plan**: break a goal into a concrete, ordered set of steps.
 - **rewrite**: tighten and clarify a piece of text without changing its meaning.
 - **decide**: weigh a decision and give a clear recommendation.
+- **onboard**: a guided first-day interview that fills memory with who you are and what you are working on.
+- **audit**: a read-only health check across the four rungs, naming the gaps and the single next fix.
+- **level-up**: a weekly session that turns one recurring manual chore into something Holt does, and ships it.
+
+The last three are the setup loop. `onboard` on day one, then `audit` and `level-up` weekly. Holt gets useful in four rungs, in order: **Know** (it holds facts about you), **Reach** (it can see your real material), **Do** (it runs your repeated work), **Run** (it acts while you are away). Automating on top of an empty memory just produces confident nonsense on a timer, so the order matters.
 
 ### Skill registry (`holt skill search` / `publish`)
 
@@ -578,7 +595,7 @@ holt graph           see your memory as an interactive knowledge graph
 holt mcp             run an MCP server so other tools use this folder's memory (holt mcp setup)
 holt hook            ambient memory for Claude Code: install | remove | status
 holt skill           manage skills: list | show | create | add | remove
-holt memory          inspect memory: holt memory [search <query> | facts | embed | clear]
+holt memory          inspect memory: holt memory [add <fact> | search <query> | facts | embed | clear]
 holt wiki            derived knowledge wiki: holt wiki [sync | auto | rebuild | lint | list | show | status]
 holt setting         configure brains, API brains, and launch command
 holt login <brain>   sign in to claude, codex, or gemini

package/dist/cli.js

@@ -677,7 +677,7 @@ function clearMemory() {
 function normalizeFact(s) {
   return (s || "").toLowerCase().replace(/\s+/g, " ").trim().replace(/[.,;:!?]+$/, "");
 }
-var FACTS_HEADER = "# Holt facts\n\nDistilled memories for this folder. Safe to edit by hand.\n";
+var FACTS_HEADER = '# Holt facts\n\nDistilled memories for this folder. Edit or delete lines freely.\nTo ADD one, use `holt memory add "<fact>"`: a line typed in here by hand is\nnever embedded, so semantic recall will not find it.\n';
 async function saveFact(content, session) {
   const clean = content.trim();
   if (!clean) return false;
@@ -2515,6 +2515,24 @@ function buildCronLine(job, holtPath) {
   const command = buildCommand(job, holtPath);
   return `${minute} ${hour} * * * ${command} # ${CRON_MARKER}${job.id}`;
 }
+function buildWindowsTaskFields(job, holtPath) {
+  let args;
+  if (job.runArgs && job.runArgs.length > 0) {
+    args = [...job.runArgs, "--quiet"];
+  } else {
+    args = ["run", job.task];
+    if (job.brain) args.push("--brain", job.brain);
+    args.push("--quiet", "--out", logPath(job.id));
+  }
+  const quoted = args.map((a) => /[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a);
+  return {
+    program: holtPath,
+    args: quoted.join(" "),
+    startIn: job.workspace,
+    when: job.when,
+    name: `Holt ${job.id}`
+  };
+}
 function stripCronLines(crontab, id) {
   const marker = `# ${CRON_MARKER}${id}`;
   const kept = crontab.split("\n").filter((line) => !line.includes(marker));
@@ -4824,6 +4842,34 @@ async function memoryCmd(sub, rest = []) {
     close();
     return;
   }
+  if (action === "add" || action === "remember") {
+    let items = [];
+    const inline = rest.join(" ").trim();
+    if (inline) items = [inline];
+    else if (!process.stdin.isTTY) {
+      items = readFileSync14(0, "utf8").split("\n").map((l) => l.replace(/^\s*[-*]\s+/, "").trim()).filter(Boolean);
+    }
+    if (items.length === 0) {
+      console.log(c.dim('\n  Usage: holt memory add "<fact>"   (or pipe one fact per line on stdin)\n'));
+      close();
+      return;
+    }
+    const session = newSessionId();
+    let saved = 0;
+    let dupes = 0;
+    for (const item of items) {
+      if (await saveFact(item, session)) saved++;
+      else dupes++;
+    }
+    const dupNote = dupes ? c.dim(`  (${dupes} already known)`) : "";
+    console.log("\n" + c.green(`  Remembered ${saved} fact${saved === 1 ? "" : "s"}.`) + dupNote);
+    if (saved && !await embeddingsAvailable()) {
+      console.log(c.dim('  Saved in keyword mode. Run "holt doctor --fix" for semantic recall.'));
+    }
+    console.log("");
+    close();
+    return;
+  }
   if (action === "facts") {
     if (!existsSync13(factsMdPath())) {
       console.log(c.dim("\n  No facts distilled yet. They form when you end a chat session.\n"));
@@ -4864,9 +4910,9 @@ async function memoryCmd(sub, rest = []) {
     close();
     return;
   }
-  if (action && !["clear", "embed", "facts", "search", "global"].includes(action)) {
+  if (action && !["add", "remember", "clear", "embed", "facts", "search", "global"].includes(action)) {
     console.error(`
-  Unknown memory subcommand: "${sub}". Use: search <query> | facts | embed | global | clear
+  Unknown memory subcommand: "${sub}". Use: add <fact> | search <query> | facts | embed | global | clear
 `);
     process.exitCode = 1;
     close();
@@ -4888,7 +4934,8 @@ async function memoryCmd(sub, rest = []) {
   }
   const gEnabled = isGlobalEnabled(workspace());
   console.log(`  global      ${gEnabled ? c.green("on") + c.dim("  (contributes + reads shared facts)") : c.dim("off  (this folder is isolated, the default)")}`);
-  console.log(c.dim("\n  holt memory search <query>   find remembered moments"));
+  console.log(c.dim('\n  holt memory add "<fact>"     teach it something durable right now'));
+  console.log(c.dim("  holt memory search <query>   find remembered moments"));
   console.log(c.dim("  holt memory facts            show distilled facts (facts.md)"));
   console.log(c.dim("  holt memory embed            embed older memories for semantic recall"));
   console.log(c.dim("  holt memory global           share high-value facts across your folders"));
@@ -7486,7 +7533,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.16.0";
+var VERSION = "0.17.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -7801,11 +7848,28 @@ async function addCmd(rest) {
   console.log(`  log        ${logPath(job.id)}`);
   if (process.platform === "darwin") installDarwin(job, holtPath);
   else if (process.platform === "linux") installLinux(job, holtPath);
-  else {
+  else printManualInstall(job, holtPath);
+  console.log("");
+}
+function printManualInstall(job, holtPath) {
+  if (process.platform !== "win32") {
     console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
     console.log("  " + buildCronLine(job, holtPath));
+    return;
+  }
+  const f = buildWindowsTaskFields(job, holtPath);
+  console.log(c.dim("\n  Saved, but not started: Holt cannot install timers on Windows yet."));
+  console.log(c.dim('  Open Task Scheduler, choose "Create Basic Task", and fill in:'));
+  console.log(`    Name        ${f.name}`);
+  console.log(`    Trigger     Daily at ${f.when}`);
+  console.log(`    Program     ${f.program}`);
+  console.log(`    Arguments   ${f.args}`);
+  console.log(`    Start in    ${f.startIn}`);
+  if (job.notify) {
+    console.log(
+      c.dim("\n  Note: --notify does not carry over to Task Scheduler. Read the log file instead.")
+    );
   }
-  console.log("");
 }
 function listCmd2() {
   const jobs = loadJobs();
@@ -8007,10 +8071,7 @@ function installSchedule(r) {
   addJob(job);
   if (process.platform === "darwin") installDarwin2(job, holtPath);
   else if (process.platform === "linux") installLinux2(job, holtPath);
-  else {
-    console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
-    console.log("  " + buildCronLine(job, holtPath));
-  }
+  else printManualInstall(job, holtPath);
 }
 function removeScheduleDarwin(id) {
   const path = plistPath(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holt-os/holt",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "An open-source personal agent OS: any LLM, private memory you can see and walk.",
   "type": "module",
   "license": "MIT",

package/skills/audit/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: audit
+description: A read-only health check of your Holt setup across the four rungs (Know, Reach, Do, Run), naming the gaps and the single next thing to fix. Use weekly, or when Holt feels less useful than expected.
+---
+
+# audit
+
+## When to use
+
+The user wants to know whether Holt is actually set up well, or why it feels
+thin. This skill inspects the real state of the folder and reports back. It
+changes nothing: no files written, no settings altered, no facts saved. If a fix
+is obvious, name the command and let the user run it.
+
+## The four rungs
+
+Each rung depends on the one below it. A gap low down makes everything above it
+worse, so always report the lowest gap first.
+
+1. **Know**: it holds facts about the user and their work.
+2. **Reach**: it can see the real material, not just what is typed at it.
+3. **Do**: it runs their repeated work as skills.
+4. **Run**: it acts without the user being present.
+
+## Instructions
+
+### Gather the state
+
+Run these and read the output. If you cannot run commands in this session, ask
+the user to paste the output of the first three rather than guessing.
+
+```
+holt memory                 facts count, embedded count, recall mode
+holt memory facts           what it actually knows
+holt voice show             is there a writing profile
+holt hook status            ambient memory in Claude Code
+holt skill list             which skills exist, and which are built in
+holt routine list           named jobs
+holt schedule list          timers
+holt doctor                 machine level problems
+holt wiki status            derived knowledge, if used
+```
+
+### Score each rung
+
+Be strict. A generous audit is a useless one. Mark each rung **solid**, **thin**,
+or **missing**, and say what the evidence was.
+
+- **Know** is solid when memory holds a few dozen facts that are about the
+  user's actual work, and recall is running on embeddings rather than keyword
+  match. It is thin when the facts are mostly setup trivia, or when
+  `holt memory` shows moments that were never embedded. Read the facts, do not
+  just count them: fifty facts about one afternoon is still thin.
+- **Reach** is solid when Holt sees material without the user pasting it: the
+  hook is installed, or MCP is wired into the tools they use, or the folder
+  holds the real files. It is missing when every session starts by pasting
+  context in by hand.
+- **Do** is solid when at least one skill exists that the user or their
+  registry provided, tuned to their work. Built-in skills alone do not count;
+  everyone has those. Note which ones are actually being used.
+- **Run** is solid when something has produced output while they were away, and
+  they read it. A routine that exists but has never run is thin, not solid.
+
+### Report
+
+1. Name the rung they are on: the highest one that is solid, with everything
+   below it also solid. Say it in one line.
+2. List the gaps, lowest rung first. For each, state what is missing and the
+   command that would close it.
+3. Give **one** next action. Not a menu, not a ranked list of five. The single
+   thing that unblocks the most.
+4. Flag anything actively broken separately from anything merely absent. A
+   scheduled routine that fails every night is worse than no routine, and a
+   memory in keyword mode is quietly degrading every answer.
+
+Keep the whole report short enough to read in a minute. It is a dashboard, not
+an essay.
+
+### Known traps to check for
+
+- **Keyword mode.** If `holt memory` says recall is keyword rather than
+  embeddings, semantic recall is off and every answer is worse. `holt doctor
+  --fix` usually repairs it.
+- **Unembedded moments.** If embedded count is below total, older memories are
+  invisible to semantic recall. `holt memory embed` fixes it in one pass.
+- **Hand-edited facts.** Facts added by editing `facts.md` directly are never
+  embedded, so they never come back through recall. They must be re-added with
+  `holt memory add`.
+- **Windows and timers.** On Windows, `holt schedule` and a routine's `--at`
+  time do not install anything. Anything on rung four there has to run another
+  way, so check the platform before calling rung four solid.
+- **Automation above an empty memory.** If Run looks solid while Know is thin,
+  say so bluntly. That setup produces confident wrong output on a timer, and it
+  is the most expensive failure on this list.
+
+## Example
+
+You are on rung two. Know and Reach are solid, Do is thin.
+
+Know: solid. 41 facts covering the agro project, the job search, and family
+health. Recall is on embeddings.
+Reach: solid. Hook installed, so Claude Code sessions recall automatically.
+Do: thin. Ten skills listed, all built in. Nothing tuned to your work.
+Run: missing. No routines, no schedules.
+
+Broken: 12 of 340 moments have no embeddings, so a slice of last month is
+invisible to recall.
+
+Next action: run `/skill level-up` and turn the weekly client update into a
+skill. Rung four is not worth touching until something on rung three has earned
+its place.

package/skills/level-up/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: level-up
+description: A weekly working session that turns one piece of recurring manual work into something Holt does for you, and ships it before the session ends. Use as a standing ritual once memory has real facts in it.
+---
+
+# level-up
+
+## When to use
+
+The user has been using Holt and wants it to carry more. This is the ritual that
+compounds: once a week, one drain becomes one shipped capability. Run it after
+memory holds real facts about their work; on an empty folder, run `onboard`
+first.
+
+The session fails if it ends in a plan. It succeeds if something exists that did
+not exist an hour ago.
+
+## Instructions
+
+### 1. Find the constraint
+
+Read what memory already knows. Relevant past notes are injected above; also run
+`holt memory facts` and search for the work they complain about:
+
+```
+holt memory search <what they keep doing by hand>
+```
+
+Then ask what ate their time this week, and what they did more than once. Pick
+**one**. The best candidate is frequent, rule-shaped, and low-stakes if it comes
+out slightly wrong. Say plainly why you picked it over the others.
+
+If several are tempting, choose the boring one. A dull thing that runs every
+week beats an ambitious thing that runs once.
+
+### 2. Decide what to do with it
+
+Three options, in this order:
+
+- **Drop it.** Does this task need to exist? Work that only continues out of
+  habit should be stopped, not automated. Ask this first and mean it; the
+  cheapest automation is the one you do not build.
+- **Automate it.** Rule-shaped and repeatable, with a checkable output.
+- **Hand it off.** It needs judgement, relationships, or accountability a
+  machine should not hold. Say so and move to the next candidate.
+
+Automating something that should have been dropped makes the waste permanent
+and harder to see. Push back before building.
+
+### 3. Map it before building
+
+Walk the task through in the user's own words: what starts it, what information
+it needs, what it produces, and who sees the output. Write the steps down. If
+you cannot state the steps in plain sentences, it is not ready to build.
+
+Then set how much rope it gets:
+
+- **Drafts, you send.** Anything that leaves the house: email, posts, messages.
+- **Runs, you review.** Produces a file or a note you read afterwards.
+- **Runs unattended.** Only for work that is reversible and already proven by
+  hand for a few cycles.
+
+Start one level more cautious than feels necessary. Moving up later is easy;
+un-sending is not.
+
+### 4. Build it now
+
+Pick the lightest thing that works:
+
+- A **skill**, when it is a repeatable way of thinking or writing:
+  `holt skill create <name>`, then write the instructions into its `SKILL.md`.
+  Check the registry first with `holt skill search <topic>`, because the work
+  may be done already.
+- A **routine**, when it is a task worth naming and rerunning:
+  `holt routine add <name> "<task>"`, run it with `holt routine run <name>`.
+- A **schedule**, when it should happen without being asked:
+  `holt schedule add`, or a scheduled routine. Only after it has produced good
+  output by hand at least twice.
+- A **connection**, when the blocker is that Holt cannot see the material:
+  `holt hook` for ambient memory in Claude Code, `holt mcp setup` for other
+  tools. Sometimes the whole win is that it can finally read the thing.
+
+Prefer a fixed sequence of steps over an open-ended agent. Predictable and
+slightly dumb beats clever and unrepeatable.
+
+### 5. Test it on something real
+
+Run it once, now, on genuine input, and read the output with the user. If it is
+wrong, fix it in this session. A capability that has never run on real data is
+not shipped.
+
+Then agree how it gets switched off: which command removes it, or which file to
+delete. Anything that runs on a timer needs a way to stop.
+
+### 6. Close the loop
+
+1. Save what was built and why, so next week starts informed:
+   ```
+   holt memory add "Built the <name> routine on <date>: <what it does, what triggers it>"
+   ```
+2. Note what to watch for: the failure mode most likely to show up first.
+3. Name the single next candidate from the list you did not pick, so the next
+   session starts with a running head start.
+
+## Example
+
+This week: forty minutes lost to writing the same client update every Friday.
+
+Not dropped, it is genuinely wanted. Not handed off, the facts live here.
+Automate it, at drafts-you-send, because it goes to a client.
+
+Built as a routine over the folder's memory, run once against this week's real
+work. First draft named the wrong milestone; instructions tightened, second
+draft was sendable. Off switch: `holt routine remove friday-update`.
+
+Watch for: it will keep sounding confident about numbers it has not been given.
+
+Next week's candidate: the invoice chase.

package/skills/onboard/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: onboard
+description: A guided first-day interview that fills Holt's memory with who you are and what you are working on, so recall is useful from day one instead of after weeks of use. Use on a fresh folder, or to top up a thin memory.
+---
+
+# onboard
+
+## When to use
+
+Holt is installed but it does not know the user yet. An empty memory makes every
+answer generic, which is the most common reason people install Holt and drift
+away. This skill front-loads the knowledge that recall needs, in about fifteen
+minutes, and ends with one real piece of work.
+
+Also use it when `holt memory` shows very few facts and answers still feel
+generic, or when the user starts a new folder for a different part of their life.
+
+## The ladder
+
+Holt gets useful in four rungs, in order. Onboarding is rung one.
+
+1. **Know**: it holds facts about you and your work. (`holt memory`)
+2. **Reach**: it can see your real material: files, notes, other tools. (`holt hook`, `holt mcp`)
+3. **Do**: it runs your repeated work as skills. (`holt skill`)
+4. **Run**: it acts without you being there. (`holt routine`, `holt schedule`)
+
+Do not skip ahead. Automation on top of an empty memory produces confident
+nonsense on a timer.
+
+## Instructions
+
+### Before you start
+
+1. Check what is already known: run `holt memory` and, if any facts exist,
+   `holt memory facts`. If the folder already holds real facts, say so and offer
+   a top-up on the thin areas instead of the full interview. Never re-ask
+   something already in memory.
+2. Set expectations in two lines: seven questions, about fifteen minutes, and
+   they can stop at any point because you save as you go.
+
+### Running the interview
+
+Ask **one question at a time.** Wait for the answer before moving on. Never
+present the whole list at once; a wall of questions is the main reason people
+abandon setup. Keep your own words short between questions.
+
+Ask for the real thing, never a description of it. "Paste the last update you
+sent your team" beats "how would you describe your writing style". Concrete
+input is what makes recall work later.
+
+If an answer is thin or abstract, ask one follow-up for a specific name, number,
+or example, then move on. Two follow-ups on one question is too many.
+
+The seven questions:
+
+1. **Who you are.** What is your work, and what does a normal day actually
+   involve? Get the role, and what they are responsible for.
+2. **What is live.** The three to five things genuinely in flight right now, and
+   the state of each. Push for status, not just titles.
+3. **Who matters.** The people, clients, teams, or companies that come up
+   regularly, and how each relates to them. Names matter here.
+4. **Standing rules.** Decisions and preferences you should never re-ask:
+   how they want to be spoken to, what is off limits, choices already made.
+5. **Where the work lives.** Which folders, tools, and accounts hold the real
+   material. This becomes the map for rung two, so note what is not reachable
+   yet rather than pretending it is.
+6. **What drains the time.** The recurring work they resent doing by hand. Ask
+   for the last three times it happened. These are the candidates the `level-up`
+   skill will draw from later.
+7. **Their voice.** Ask them to paste two or three samples of their real
+   writing: a sent email, a message, a published post. Then run
+   `holt voice add <file>` if the samples are in files, or tell them the command
+   so their drafts sound like them rather than like a model.
+
+### Saving as you go
+
+After every two questions, write what you learned to memory with:
+
+```
+holt memory add "<one durable fact>"
+```
+
+One fact per call. Several facts can be piped in at once, one per line.
+
+Write facts that will still be true in a month and that a future session could
+not guess. "Runs product for a fintech in Bhubaneswar, nine years in" is a fact.
+"Wants to be more productive" is noise. Include names, numbers, and dates. Write
+the fact so it stands alone, because recall will surface it without this
+conversation around it.
+
+If you cannot run commands in this session, write the facts out as a block of
+`holt memory add` lines and ask the user to paste them into their terminal.
+Do not hand-edit `facts.md`: facts added that way are never embedded, so
+semantic recall will not find them.
+
+### Finishing
+
+1. Show what was captured: run `holt memory facts` so they see their own words
+   stored in a file they own and can edit.
+2. Prove it works. Ask one question whose answer depends on what they just told
+   you, and answer it from memory. This is the moment the tool becomes real, so
+   do not skip it.
+3. Do one real thing now. Pick the smallest useful task from what they said
+   drains their time and complete it in this session. An artifact beats a plan.
+4. Name rung two. Tell them the single next step, usually `holt hook` so Claude
+   Code remembers automatically, or `holt mcp setup` to reach their other tools.
+   One step, not a menu.
+5. Point at the ritual: `/skill level-up` weekly turns one drain into one
+   automation, and `/skill audit` shows which rung they are on.
+
+## Example
+
+Not: "Tell me about your business, your projects, your clients, your
+preferences, and your writing style."
+
+Instead: "First one. What is your work, and what does a normal Tuesday actually
+look like?" then, after the answer: "Got it. Now the live list: what are the three to five
+things genuinely in flight this week?"
+
+Then, quietly, between questions:
+
+```
+holt memory add "Senior product manager, nine years, currently between roles and job-hunting in the Netherlands"
+holt memory add "Runs Sasyam Agro with an uncle in Bargarh; demo plots are on the uncle's land"
+```