@rayul/kordis 0.15.1 → 0.15.2

package/assets/memgineering-writing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: memgineering-writing
-description: Use when you learn something durable and should record it, when a conclusion you already recorded turns out to have changed, when something needs undoing or retiring, when the brain has filled up with near-duplicates that want tidying, or when the user's `01_BASE/` files are still empty and only a conversation can fill them. Triggers include "remember this", "that didn't work", "this worked instead", "that's not right anymore", "undo that", "looks good", "set up my memory", "fill in my profile", "stop reading that note", "clean up my notes", "these two say the same thing", "is this a duplicate", "move my memories over", "bring my notes from the other tool", "don't save that", "never store that". Covers remember, revise, undo, log, retire, exclude, onboard, the consolidate/propose/approve flow, carrying facts in from another store, storage boundaries, and what to say before writing.
+description: Use when you learn something durable and should record it, when a conclusion you already recorded turns out to have changed, when something needs undoing or retiring, when the brain has filled up with near-duplicates that want tidying, or when the user's `01_BASE/` files are still empty and only a conversation can fill them. Triggers include "remember this", "that didn't work", "this worked instead", "that's not right anymore", "undo that", "looks good", "set up my memory", "fill in my profile", "stop reading that note", "clean up my notes", "these two say the same thing", "is this a duplicate", "move my memories over", "bring my notes from the other tool", "don't save that", "never store that", "that's only true until <date>", "it stops being true after", "don't tell me that forever". Covers remember, revise, undo, log, retire, expire, exclude, onboard, the consolidate/propose/approve flow, carrying facts in from another store, storage boundaries, and what to say before writing.
 type: skill
 allowed-tools: Bash(memgineering:*)
 ---
@@ -23,24 +23,47 @@ reverse it. Do not ask permission for ordinary observations — write them, and
 mention it in a sentence.
 
 **A note born in a project folder carries that project as its `scope`** — the
-name comes from the git remote (`owner/repo`), or from the folder's binding
-(`memgineering project` shows it). The stamp is automatic; an explicit
-`--scope` beats it; a folder that names no project writes exactly what it
-always wrote. Two flags are worth reaching for on purpose:
+name comes from the folder's binding (`memgineering project` shows it), else the
+git remote (`owner/repo`), else — in a repository with no remote — the checkout
+folder's name. `remember` prints the scope and which of those it came from
+(`scope_via` in `--json`); when it is the folder name, say so, because that is
+the one nobody predicts. The stamp is automatic; an explicit `--scope` beats it;
+a folder that names no project writes exactly what it always wrote. Two flags
+are worth reaching for on purpose:
 
 ```
 memgineering remember "we always squash before merging" --rule --no-scope \
   --reason "they said from now on, about every repo — not this one"
 ```
 
-- `--no-scope` for anything meant to hold machine-wide, rules especially: a
-  rule stamped with one project's scope drops out of another project's
-  `recall --scope` answers.
+- `--no-scope` for a decision that genuinely holds in every project — a
+  security rule, a way of writing commits, something about the person rather
+  than the work. It is a real answer, not the safe one: use it when it is true.
 - `--scope <name>` when the note is ABOUT a project you are not standing in.
 
+**Prefer the project scope for a rule that is about one project.** `--no-scope`
+used to be the advice for rules in general, on the reasoning that a scoped rule
+drops out of other projects' answers — it does, and that is now the point. Rules
+reach a session in two budgets, one for what holds everywhere and one for the
+project in front of it, so a scoped rule is no longer competing with every other
+rule in the brain for the same few slots. Measured before the split: in a real
+repository all the slots went to rules about other things, and a rule written
+that morning about that project's own layout ranked 49th of 54 — present,
+enforced by nothing, invisible to the session it existed to stop.
+
 `--scope` and `--no-scope` together are refused — they answer the same
 question both ways.
 
+**A rule has to say what it binds, and one of the two is required.** A `--rule`
+write is refused when nothing names a scope and nothing can be derived — a
+folder that is not a repository and has no bound project. Add `--scope "<the
+project>"` or `--no-scope`, and retry; nothing was written. On the hosted API
+(`brain_remember`, or `POST /remember` directly) the same refusal applies with
+no derivation at all: send `scope`, or `"scope": "global"` for one that really
+does hold everywhere. `global` is reserved and is stored as no scope, which is
+what a machine-wide rule already looks like — so there is only ever one
+spelling of it to search for.
+
 **`--reason` on every write.** It goes in the ledger and is the only part of the
 record that still means anything six months later. Every write verb takes it:
 `remember`, `revise`, `retire`, `exclude`, `undo`. The one on `undo` matters
@@ -183,17 +206,26 @@ it>"`.
 This rewrites only the memory block in frontmatter. The prose is the user's;
 neither the command nor you should rewrite it uninvited.
 
-## Retiring versus excluding
+## Retiring versus expiring versus excluding
 
 ```
 memgineering retire <ref> --reason "the date moved"   # no longer current, still visible
+memgineering expire <ref> --until 2026-10-31 --reason "the phase ends then"  # NOT retired
 memgineering exclude path/to/note.md --reason "it has someone's phone number in it"   # stop reading it
 memgineering retract --actor "mcp:ChatGPT" --since 2026-09-01        # SHOWS what one writer / window wrote
 memgineering retract --actor "mcp:ChatGPT" --since 2026-09-01 --yes  # retires all of it, one ledger row each
 ```
 
 Retiring keeps the note in recall, ranked last and labelled. Excluding takes it
-out of the index and never touches the file. If the user says "delete", ask
+out of the index and never touches the file.
+
+**`expire` is not a retirement, and the difference only shows up later.** It
+gives a memory an end date: until then it is current, and after it recall still
+returns it — one step below what is current, labelled with the date. Reach for
+it when the memory was always going to run out ("Phase 1 lands by the end of
+October", a key that rotates, a plan with a deadline in it) rather than when a
+decision has been overtaken. Retiring such a note says something untrue about
+it; leaving it says something untrue too. If the user says "delete", ask
 which they mean.
 
 ## Tidying up a brain: detect, draft, approve
@@ -215,11 +247,30 @@ it is about without opening them. It does not carry their claims, so deciding
 which of a pair is right still means reading them: two notes can share a title
 and hold opposite conclusions, which is exactly the case a proposal exists for.
 It returns them with the evidence that caught them and the action it would
-suggest, under six rules: `declared_supersession`, a replaced note still active;
-`contradiction`, a disagreement nobody settled; `semantic_similarity`, indexed
-meaning agreeing reciprocally; `shared_context`, one scope naming the same
-thing; `similar_title`; and `kind_promotion`, a binding note filed as something
-other than a decision. Semantic detection reuses a complete, calibrated hosted
+suggest, under eight rules: `declared_supersession`, a replaced note still
+active; `contradiction`, a disagreement nobody settled; `semantic_similarity`,
+indexed meaning agreeing reciprocally; `shared_context`, one scope naming the
+same thing; `similar_title`; and three that read a note against itself, where
+its `binding` flag and its `kind` disagree. `rule_demotion` is a binding note
+the author classified as a fact, a procedure, an episode or a goal — two
+deliberate fields contradicting each other, and the marking is the one to
+doubt. `binding_unclassified` is a binding note with no kind at all, and it
+names BOTH moves rather than picking one, because the tool reads fields and not
+prose: it is either a decision nobody classified or something that was never a
+rule, and only somebody who reads it can say which. (`kind_promotion` remains
+in the vocabulary and no longer fires.)
+
+That neutrality was measured rather than chosen for balance. On a real brain,
+55 of 57 binding notes had no kind and every one was answered "promote this to
+a decision" — including the thirteen that turned out not to be rules, where
+approving the suggestion would have hardened the mistake.
+
+**The page is shared between the signals.** One rule used to take the whole
+list — 55 of 57 candidates — so the duplicate and the contradiction underneath
+got a line each. Candidates now round-robin across the rules that found
+something, and `by_rule` reports how many each found in total, which the page
+can no longer tell you. Raising `--limit` widens the page rather than returning
+more of one rule. Semantic detection reuses a complete, calibrated hosted
 vector generation and never calls a model during consolidation. Authored
 scope/entity context permits reciprocal neighbours; without it, evidence must
 form a stricter three-note semantic triangle.
@@ -308,7 +359,7 @@ so an empty one costs something every time.
 memgineering onboard
 ```
 
-Says which are still untouched and what to ask for each. Run it first rather
+Says which still have no body written and what to ask for each. Run it first rather
 than working from a script — asking somebody a question they already answered is
 its own kind of forgetting. They may also ask outright ("set up my memory", "fill in my profile"); same job.
 
@@ -353,7 +404,7 @@ always true and you have only just been told them, so dating them today is wrong
 in the one field a memory store exists to get right.
 
 **This is the ONE place you edit a brain file directly** — `01_BASE/` only, and
-only while it is still the template. After that first pass these are theirs like
+only while its body has not been written yet. After that first pass these are theirs like
 any other note.
 
 **Do not invent an answer to move on, and do not fill a file because it is