@rayul/kordis 0.14.0 → 0.15.0

package/assets/KORDIS.md

@@ -35,6 +35,15 @@ from reusable domain knowledge, structure, or templates, run
 `kordis read <full_slug>` before proceeding; otherwise continue ad hoc.
 NEVER fabricate a slug.
 
+**Search in the user's own words** — NEVER translate the user's query
+before searching, in any language. Pass their words through verbatim. The
+server already translates the non-Latin words it knows AND keeps the
+originals in the same query, so a query you pre-translated searches strictly
+less: it can no longer reach titles and keywords written in that language.
+The answer names what else was searched and which words it could not
+translate — relay both, because a word it skipped may be the one that
+mattered.
+
 **Judgment patterns** — `judgment-pattern` packages carry agentic _judgment_
 (when to switch modes, what to verify, what NOT to do), not installable files.
 Don't install them: `kordis read` one, or `kordis adapt <slug>` to get a brief

package/assets/MEMGINEERING.md

@@ -2,7 +2,7 @@
 name: memgineering
 description: Use whenever the user refers to something they told you before, asks what was decided, tells you something worth keeping, or settles something that should hold next time. The memory lives in their own folder and outlives this session; check it before answering from guesswork, and write to it when you learn something durable.
 type: skill
-version: 0.19.0
+version: 0.20.0
 ---
 
 # memgineering
@@ -68,11 +68,12 @@ never attribute a decision to somebody this conversation has not mentioned.
 
 ## The public layer
 
-`memgineering search <words>` finds one, `memgineering read <user>/<slug>`
-inlines it and `memgineering adapt <user>/<slug>` briefs you on fitting it
-here. Neither writes a file or a note, so an empty brain works from day one;
-only what this user confirms goes in. `memgineering publish <ref>` sends one
-out — dry run until `--yes`, only when they said to.
+`memgineering registry search <words>` finds one,
+`memgineering registry read <user>/<slug>` inlines it and
+`memgineering registry adapt <user>/<slug>` briefs you on fitting it here.
+Neither writes a file or a note, so an empty brain works from day one; only
+what this user confirms goes in. `memgineering registry publish <ref>` sends
+one out — dry run until `--yes`, only when they said to.
 
 ## Where the detail is
 

package/assets/kordis-search/SKILL.md

@@ -67,6 +67,21 @@ the right filters.
 ALWAYS with `--json`. **Success criteria**: CLI exits 0 and returns a results
 array.
 
+**If the response carries `query_translation`, SAY SO in your answer.** It has
+three parts and each changes how the user should read your results:
+`translated` (what else was searched on their behalf — a slash means either
+word matches), and `unmapped` (words the lexicon did not know, which therefore
+reached the index only as typed). One sentence before the results is enough:
+"searched your words as typed, and also as `commit message rule/convention`".
+
+This is a rule, not a flourish. The user cannot see the field — only you can —
+so an unreported translation makes a widened search look like a narrow one, and
+an unreported `unmapped` makes a thin answer read as "the registry has nothing"
+when it may mean "two of your three words were never looked up". Measured
+2026-09-07: agents that had this only as an example in the Examples section
+relayed it 0 times out of 2 on the weaker tier while seeing the field every
+time.
+
 ### 3. Triage the results
 
 - Prefer `review_status: passed`, higher `stars`, then `tier: A`.
@@ -109,6 +124,22 @@ User: "find me a Python skill"
 - ask which to read or pull
 </example>
 
+<example>
+User: "커밋 메시지 규칙 패키지 있어?"
+- kordis search "커밋 메시지 규칙" --json — the user's words, VERBATIM
+- do NOT search `"commit message rule"` instead. The registry being mostly
+  English is not a reason to translate first: the server already searches the
+  English terms AND the Korean originals in one query, so your translation
+  only subtracts — Korean titles and the Korean keywords on English packages
+  become unreachable
+- the response carries `query_translation` {original, translated, unmapped}
+- tell the user what else was searched ("commit message rule/convention" — a
+  slash means either word matches) and
+  which words the lexicon skipped (`unmapped`); a row may have matched only
+  the translation. If `unmapped` is non-empty and the answer is thin, say so
+  before concluding the registry has nothing — those words were never searched
+</example>
+
 <example>
 User: "convert this .hwp file to text"
 - kordis search hwp --json

package/assets/kordis-using/SKILL.md

@@ -86,13 +86,41 @@ Writes files into the current project.
 | `--no-with-required` | skip transitive required deps (advanced; default installs) |
 
 IMPORTANT: `pull` **fails fast** when the target tool can't be inferred from
-the cwd (no `.claude/`, `.codex/`, `.cursor/`, `AGENTS.md`, `CLAUDE.md`,
-etc.). Pass `--tool <name>` explicitly when running in a project that has
-not been initialised for any specific tool yet. Don't rely on the old "drop
-a canonical SKILL.md at cwd" fallback — Claude Code never picked it up.
+the cwd. Pass `--tool <name>` explicitly in a project that has not been
+initialised for any tool yet. Don't rely on the old "drop a canonical
+SKILL.md at cwd" fallback — Claude Code never picked it up.
+
+Auto-detection is ordered by EVIDENCE, not by vendor. A project is matched
+against, in order: `.claude/` → `.codex/` → `.gemini/` → `.agents/` →
+`AGENTS.md` → `CLAUDE.md` → `GEMINI.md`, then the rules-file markers
+(`.cursorrules`, `.windsurfrules`, `.github/copilot-instructions.md`).
+A bare `.cursor/`, `.continue/`, `.windsurf/`, `.antigravity/` or
+`.opencode/` directory no longer selects its own vendor — nothing has been
+shown to read `<vendor>/skills/`. They still DETECT, and they resolve to
+`agents-md`, so such a project gets its package somewhere with evidence behind
+it rather than an error. An explicit `--tool` always wins over detection and
+never changes behaviour.
+
+`AGENTS.md` alone now resolves to `agents-md`, not to `codex`. AGENTS.md is a
+cross-vendor standard (an Agentic AI Foundation project alongside MCP and
+goose), so a project carrying one is not thereby a Codex project.
 
 Valid `--tool` values: `claude-code`, `codex`, `cursor`, `continue`,
-`windsurf`, `antigravity`, `copilot`.
+`windsurf`, `antigravity`, `copilot`, `opencode`, `gemini-cli`, `agents-md`.
+
+**PASS `--tool <your own tool>` WHEN YOU ARE THE ONE WHO WILL USE THE SKILL.**
+Detection reads the project's markers, which answer "what convention does this
+repo follow" — not "which agent is about to consume this". When the user asks
+YOU to install a skill so that YOU behave differently from now on, the right
+target is your own tool home, and you know that better than the directory
+does. Say `--tool claude-code` (or `codex`, `gemini-cli`, …) and, for a habit
+meant to outlive this one repo, `--target "$HOME"`.
+
+Leave detection to decide when the project's convention is the point: setting a
+repo up for whoever works in it next, or installing on behalf of a tool that is
+not you. Measured 2026-09-07: an agent that skipped this pulled with detection,
+read `--help`, `rm -rf`'d what it had just installed, and pulled again with
+`--tool` — four steps to reach the target it wanted from the start.
 
 ### `kordis info <full_slug> --json`
 
@@ -107,8 +135,16 @@ user is about to execute foreign code or runtime config.
 LLM-facing recipe (Markdown body following the open Agent Skills spec).
 
 - DEFAULT: `read`.
-- `pull` writes to the auto-detected tool's skill path
-  (e.g. `~/.claude/skills/<slug>/SKILL.md` for Claude Code).
+- `pull` writes to the detected tool's skill path — `.claude/skills/<name>/SKILL.md`
+  for Claude Code, `.codex/skills/…` for Codex, `.gemini/skills/…` for Gemini CLI,
+  and `.agents/skills/<name>/SKILL.md` for `agents-md`.
+- `.agents/skills/` is the shared one: measured 2026-09-06, both Codex 0.153.4
+  and Gemini CLI 0.56.0 load it, at project level and at `~/.agents/skills`.
+  So a package installed there is picked up by either without further setup.
+  Claude Code does not read it and keeps `.claude/skills/`.
+- Gemini CLI only loads PROJECT skills in a folder the user has marked trusted.
+  If a freshly pulled skill does not show up, that trust prompt is the reason,
+  not the install.
 
 ### `project-rules`
 

package/assets/memgineering-registry/SKILL.md

@@ -2,7 +2,7 @@
 name: memgineering-registry
 description: Use when the user wants judgment somebody else has already settled — "what do other people do about this", "is there a pattern for it", "read that judgment", "adapt that pattern to this repo", "fit it to our setup", "how do others handle X" — or when one of their own decisions should go out: "publish this decision", "share this rule", "put it on memgineering", "send it to the registry". Also when they ask whether what you read gets stored. Covers the public layer: reading somebody else's judgment into context, the transplant brief, publishing one claim out of this brain, lineage, why reading is never copying, and how author-controlled text is fenced.
 type: skill
-version: 0.19.0
+version: 0.20.0
 allowed-tools: Bash(memgineering:*)
 ---
 
@@ -12,16 +12,19 @@ memgineering.com is where settled decisions live in public. A package there is
 one person's judgment — a decision, a preference, or a procedure — carrying the
 scope it holds in, when it was true, and what it rests on.
 
-Five verbs reach it. None of them installs anything, and none of them writes a
-note. An identifier looks like `<username>/<slug>`, optionally `@<version>`; it
-comes from the user, or from the attribution line under something you already
-read.
+Five verbs reach it, all of them under `memgineering registry`. None of them
+installs anything, and none of them writes a note. An identifier looks like
+`<username>/<slug>`, optionally `@<version>`; it comes from the user, or from
+the attribution line under something you already read.
 
-## `search` — find one without knowing its name
+Each one still answers to its bare name as well, which prints a line on stderr
+saying so and is not the documented form — write the namespaced spelling.
+
+## `registry search` — find one without knowing its name
 
 ```
-memgineering search additive migrations
-memgineering search --type judgment-pattern --limit 5
+memgineering registry search additive migrations
+memgineering registry search --type judgment-pattern --limit 5
 ```
 
 Titles, one-line descriptions, and the verb that would fetch each result. No
@@ -33,11 +36,23 @@ to drop the filter or broaden the words, and the same sentence is on `hint`
 under `--json`. Take it. Guessing a third phrasing when the tool has already
 named the lever is how one lookup becomes five.
 
-## `read` — somebody else's judgment, in your context
+NEVER translate the user's words before searching. Pass them as typed, in
+whatever script they arrive in. That the registry is mostly English is not a
+reason to search in English first: the server translates the words a fixed
+lexicon knows AND searches the originals in the same query, so a pre-translated
+query searches strictly less — the Korean titles, and the Korean keywords
+carried by English packages, stop being reachable. The answer carries a line
+naming what else was searched and which words were skipped
+(`query_translation` under `--json`: `original`, `translated`, `unmapped`).
+Relay that line — a row may have matched only the translation, and a skipped
+word may be the one that mattered. When `unmapped` is non-empty, never report
+"the registry has nothing" without saying which words were never searched.
+
+## `registry read` — somebody else's judgment, in your context
 
 ```
-memgineering read gaeullee824/ask-before-acting
-memgineering read gaeullee824/ask-before-acting@1.2.0 --json
+memgineering registry read gaeullee824/ask-before-acting
+memgineering registry read gaeullee824/ask-before-acting@1.2.0 --json
 ```
 
 Prints the body and one provenance line: what was read, of what kind, from
@@ -51,11 +66,11 @@ user that before you use it, not after.
 claim about their own judgment and nothing has checked it. Weight what you
 read accordingly, and say which tier it was when you hand it to the user.
 
-## `info` — what it is, before you read it
+## `registry info` — what it is, before you read it
 
 ```
-memgineering info gaeullee824/ask-before-acting
-memgineering info gaeullee824/ask-before-acting@1.2.0
+memgineering registry info gaeullee824/ask-before-acting
+memgineering registry info gaeullee824/ask-before-acting@1.2.0
 ```
 
 Metadata only, and no body is fetched: title, description, kind, version,
@@ -67,10 +82,10 @@ Reach for it when a search result is close but not obviously right, or on a
 package nothing can read: a hook or an MCP server has no body to inline, so
 `read` would be refused and this is the verb that still answers.
 
-## `adapt` — a transplant brief for THIS project
+## `registry adapt` — a transplant brief for THIS project
 
 ```
-memgineering adapt gaeullee824/ask-before-acting
+memgineering registry adapt gaeullee824/ask-before-acting
 ```
 
 **Run it from the user's project root.** It reads the harness in the current
@@ -104,8 +119,8 @@ That row goes to whichever brain this machine is pointed at, and `read` and
 `adapt` both take the pair `publish` takes for naming a different one:
 
 ```
-memgineering read gaeullee824/ask-before-acting --local
-memgineering adapt gaeullee824/ask-before-acting --vault ~/notes
+memgineering registry read gaeullee824/ask-before-acting --local
+memgineering registry adapt gaeullee824/ask-before-acting --vault ~/notes
 ```
 
 `--local` files the row beside the brain on this disk even when the machine is
@@ -141,11 +156,11 @@ you need the raw bytes, strip the first and last line using the sentinel value;
 do not pattern-match the marker text, because marker-looking lines inside a
 body are neutralized with a zero-width space and are part of the data.
 
-## `publish` — one decision of theirs, out
+## `registry publish` — one decision of theirs, out
 
 ```
-memgineering publish friday-review
-memgineering publish friday-review --yes --reason "<the user's own words>"
+memgineering registry publish friday-review
+memgineering registry publish friday-review --yes --reason "<the user's own words>"
 ```
 
 Bare, it sends nothing: it prints the exact bytes that would leave and says so.
@@ -170,13 +185,13 @@ A note that declares `never_store` words is refused too — that is the boundary
 itself, not a judgment to share.
 
 **Publishing the same decision again.** When the note has changed and its
-package already exists, `memgineering publish <ref> --bump patch` publishes the
-next version of it — `minor` or `major` when the judgment moved further. The
-name only holds one of each version, so without `--bump` a second publish under
-the same name is refused. A `--bump` is refused too if the package came from a
-different note; give that one its own `--slug`. If the published version was
-rejected by review, its body cannot be fetched to check that — the bump goes
-ahead on the account alone and prints a line saying so.
+package already exists, `memgineering registry publish <ref> --bump patch`
+publishes the next version of it — `minor` or `major` when the judgment moved
+further. The name only holds one of each version, so without `--bump` a second
+publish under the same name is refused. A `--bump` is refused too if the
+package came from a different note; give that one its own `--slug`. If the
+published version was rejected by review, its body cannot be fetched to check
+that — the bump goes ahead on the account alone and prints a line saying so.
 
 What crosses: the claim, its scope, its validity, its evidence, and the note's
 title and summary. **Not the body.** `--slug` names the package when the title
@@ -202,7 +217,8 @@ another machine leaves no record here.
 
 Installing files, stars, follows, comments, and withdrawing a release stay in
 the `kordis` CLI for one release window. The public layer's verbs are
-`search`, `info`, `read`, `adapt` and `publish`.
+`registry search`, `registry info`, `registry read`, `registry adapt` and
+`registry publish`.
 
 `memgineering pull` is unrelated: it is the brain verb for a hosted brain, not
 a registry install.

package/assets/memgineering-writing/SKILL.md

@@ -188,6 +188,8 @@ neither the command nor you should rewrite it uninvited.
 ```
 memgineering retire <ref> --reason "the date moved"   # no longer current, still visible
 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

package/dist/index.js

@@ -36,7 +36,8 @@ var init_primitives = __esm({
       "continue",
       "copilot",
       "opencode",
-      "gemini-cli"
+      "gemini-cli",
+      "agents-md"
     ]);
     TagSchema = z.string().min(1).max(32).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/);
     UrlSchema = z.string().url().startsWith("http");
@@ -502,12 +503,34 @@ var init_manifest = __esm({
         modes: ["read", "install"],
         default: "read"
       }),
-      // Rules merge into a file the project already owns (.cursorrules,
-      // CLAUDE.md) — the reason they need review, not just approval.
+      // Rules merge into a file the project already owns (CLAUDE.md, AGENTS.md,
+      // GEMINI.md, …) — the reason they need review, not just approval.
+      //
+      // Cursor is the exception, and it is declared per host rather than folded
+      // into the wildcard. Its current rules format is one `.mdc` file per rule
+      // under `.cursor/rules/`, so Kordis writes a whole file Cursor did not have
+      // instead of appending to a file the project owns. That is a `create`, and
+      // declaring it as a merge would be a false statement about what install
+      // does — `packages/translators/src/parity.test.ts` compares this table
+      // against what the translators actually emit, per host, and catches exactly
+      // that. Risk is unchanged: `deriveAggregates` still sees a merge among the
+      // effects, so project-rules stays `review-required`.
       "project-rules": (input) => build(input, {
         kind: "rules",
         profile: null,
-        effects: [{ host: "*", phase: "install", mode: "filesystem-merge" }],
+        effects: [
+          { host: "claude-code", phase: "install", mode: "filesystem-merge" },
+          { host: "codex", phase: "install", mode: "filesystem-merge" },
+          { host: "agents-md", phase: "install", mode: "filesystem-merge" },
+          { host: "gemini-cli", phase: "install", mode: "filesystem-merge" },
+          { host: "windsurf", phase: "install", mode: "filesystem-merge" },
+          { host: "copilot", phase: "install", mode: "filesystem-merge" },
+          { host: "continue", phase: "install", mode: "filesystem-merge" },
+          { host: "antigravity", phase: "install", mode: "filesystem-merge" },
+          { host: "opencode", phase: "install", mode: "filesystem-merge" },
+          { host: "canonical", phase: "install", mode: "filesystem-merge" },
+          { host: "cursor", phase: "install", mode: "filesystem-create" }
+        ],
         modes: ["read", "install"],
         default: "read"
       }),
@@ -1035,7 +1058,7 @@ var init_auth = __esm({
 
 // ../../packages/contracts/src/api.ts
 import { z as z11 } from "zod";
-var SearchQuerySchema, SearchResponseSchema, TrendingQuerySchema, RisingQuerySchema, StarResponseSchema, AssetSchema, LineageEdgeInputSchema, LineageRelativeSchema, LineageStatsSchema, LineageGraphResponseSchema, PublishPackageRequestSchema, PublishWaitQuerySchema, PublishPackageResponseSchema, PackagePathParamsSchema, ContentQuerySchema, PackageContentResponseSchema, JitReadRequestSchema, JitReadResponseSchema, PullPackageRequestSchema, PullPackageResponseSchema, YankRequestSchema, YankResponseSchema, ResolveVersionQuerySchema, ResolveVersionResponseSchema, GetPackageQuerySchema, ListVersionsResponseSchema, VersionDiffQuerySchema, ListCommentsQuerySchema, ListCommentsResponseSchema, UserProfileResponseSchema, UserPackagesQuerySchema, ListUserPackagesResponseSchema, ListUserStarsResponseSchema, FollowResponseSchema, ListFollowersQuerySchema, ListFollowersResponseSchema;
+var SearchQuerySchema, SearchQueryTranslationSchema, SearchResponseSchema, TrendingQuerySchema, RisingQuerySchema, StarResponseSchema, AssetSchema, LineageEdgeInputSchema, LineageRelativeSchema, LineageStatsSchema, LineageGraphResponseSchema, PublishPackageRequestSchema, PublishWaitQuerySchema, PublishPackageResponseSchema, PackagePathParamsSchema, ContentQuerySchema, PackageContentResponseSchema, JitReadRequestSchema, JitReadResponseSchema, PullPackageRequestSchema, PullPackageResponseSchema, YankRequestSchema, YankResponseSchema, ResolveVersionQuerySchema, ResolveVersionResponseSchema, GetPackageQuerySchema, ListVersionsResponseSchema, VersionDiffQuerySchema, ListCommentsQuerySchema, ListCommentsResponseSchema, UserProfileResponseSchema, UserPackagesQuerySchema, ListUserPackagesResponseSchema, ListUserStarsResponseSchema, FollowResponseSchema, ListFollowersQuerySchema, ListFollowersResponseSchema;
 var init_api = __esm({
   "../../packages/contracts/src/api.ts"() {
     "use strict";
@@ -1057,7 +1080,15 @@ var init_api = __esm({
       limit: z11.coerce.number().int().min(1).max(100).default(20),
       cursor: CursorSchema.optional()
     });
-    SearchResponseSchema = paginatedResponseSchema(PackageSummarySchema);
+    SearchQueryTranslationSchema = z11.object({
+      kind: z11.literal("lexicon"),
+      original: z11.string(),
+      translated: z11.string(),
+      unmapped: z11.array(z11.string())
+    });
+    SearchResponseSchema = paginatedResponseSchema(PackageSummarySchema).extend({
+      query_translation: SearchQueryTranslationSchema.optional()
+    });
     TrendingQuerySchema = z11.object({
       window: TimeWindowSchema.default("24h"),
       type: HarnessTypeSchema.optional(),
@@ -1308,7 +1339,22 @@ var init_api = __esm({
        * Walk depth-0 `recommended` deps (transitive recommends NOT followed).
        * Default false — opt-in noise.
        */
-      with_recommends: z11.boolean().optional().default(false)
+      with_recommends: z11.boolean().optional().default(false),
+      /**
+       * 2026-09-06 — which install target the CLI resolved for this pull
+       * ('claude-code', 'agents-md', …). Recorded on `package_pull_events.tool`;
+       * the server never derives it, because only the client knows which tool
+       * home it is actually writing into.
+       *
+       * Why this ships without coordinating a CLI and a server release: this
+       * schema is a NON-STRICT `z.object`, so an OLD server handed the new field
+       * strips it rather than returning 400, and a NEW server handed no field
+       * records NULL. Both directions degrade to "tool not recorded", which is
+       * exactly what the nullable column already means — so CLI and server can
+       * roll out in either order, which matters here because this repo has no CD
+       * and the server is deployed by hand.
+       */
+      tool: ToolSlugSchema.optional()
     });
     PullPackageResponseSchema = z11.object({
       status: z11.enum(["installed", "already_installed", "skipped"]),
@@ -1451,8 +1497,12 @@ var init_context = __esm({
        * Which agentic tool configs exist locally. Presence only — no file
        * contents inspected. Used to boost packages whose `tools_compatible`
        * overlaps.
+       *
+       * The cap is derived from the enum rather than written as a literal: a
+       * hand-written `.max(8)` silently started rejecting honest payloads the
+       * moment a tenth member was added, and nothing in the type system says so.
        */
-      tools: z12.array(ToolSlugSchema).max(8).optional(),
+      tools: z12.array(ToolSlugSchema).max(ToolSlugSchema.options.length).optional(),
       /**
        * Top-3 file extensions in CWD (excluding `.git`, `node_modules`,
        * `dist`, `.next`, build artifacts). Each entry is a short lowercase
@@ -1920,6 +1970,15 @@ var init_client = __esm({
           { query: { range } }
         );
       }
+      /**
+       * `opts` is the CONTRACT's request type, not a hand-written copy of it.
+       * The copy that used to live here listed three fields and silently stopped
+       * matching the schema the moment a fourth (`tool`, 2026-09-06) was added —
+       * callers could not pass the new field without casting, and nothing failed
+       * until someone tried. Taking `PullPackageRequestInput` means a field added
+       * to the schema is transmissible the same day, and a field REMOVED from it
+       * becomes a compile error here instead of a body the server ignores.
+       */
       pull(username, slug, opts = {}) {
         return this.request(`/api/packages/${seg(username)}/${seg(slug)}/pull`, {
           method: "POST",
@@ -6521,7 +6580,14 @@ async function detectTools() {
     { tool: "claude-code", paths: [join4(homedir2(), ".claude", "skills")] },
     { tool: "codex", paths: [join4(homedir2(), ".codex"), join4(homedir2(), ".codex", "skills")] },
     { tool: "cursor", paths: [join4(homedir2(), ".cursor")] },
-    { tool: "gemini-cli", paths: [join4(homedir2(), ".gemini"), join4(homedir2(), ".gemini", "skills")] }
+    { tool: "gemini-cli", paths: [join4(homedir2(), ".gemini"), join4(homedir2(), ".gemini", "skills")] },
+    // `~/.agents/skills` is not one vendor's directory — measured 2026-09-06,
+    // both codex-cli 0.153.4 and gemini-cli 0.56.0 load skills from it (Codex
+    // lists it as a skill root; Gemini reaches it via `getUserAgentSkillsDir`).
+    // Its presence therefore means "this machine follows the AGENTS.md
+    // convention", which is exactly the personalization signal `agents-md`
+    // packages should be ranked on.
+    { tool: "agents-md", paths: [join4(homedir2(), ".agents", "skills")] }
   ];
   const found = [];
   for (const { tool, paths } of checks) {
@@ -7234,6 +7300,7 @@ async function maybeRenderReminder() {
 }
 
 // src/commands/search.ts
+init_src();
 var SORT_MODES = [
   "relevance",
   "stars",
@@ -7244,17 +7311,7 @@ var SORT_MODES = [
   "rising"
 ];
 var TIME_WINDOWS = ["24h", "7d", "30d"];
-var TOOL_SLUGS = [
-  "claude-code",
-  "codex",
-  "cursor",
-  "antigravity",
-  "windsurf",
-  "continue",
-  "copilot",
-  "opencode",
-  "gemini-cli"
-];
+var TOOL_SLUGS = ToolSlugSchema.options;
 var TOOL_ALIASES = {
   claude: "claude-code",
   gemini: "gemini-cli"
@@ -7321,13 +7378,24 @@ function searchCommand() {
       });
     }
     const queryProvided = query.length > 0;
-    const emptyHint = opts.type ? `no packages of type "${opts.type}" match. Try without --type, or list everything: kordis search --type ${opts.type} --sort recent --limit 25` : queryProvided ? "narrow with `--type skill|mcp-server|project-rules|custom-agent|hook|judgment-pattern` or `--tag <topic>` (e.g. aws, fastapi), broaden the keywords, or browse `--sort trending`" : 'try keywords (e.g. `kordis search "topic"`), `--tag <topic>`, or `kordis search --trending`';
+    const untranslatedWords = res.query_translation && res.query_translation.unmapped.length > 0 ? res.query_translation.unmapped.map(stripControl).join(", ") : "";
+    const partialNote = untranslatedWords === "" ? "" : `${untranslatedWords} could not be translated and were searched only as typed, so this answer may be partial \u2014 tell the user which words those were before judging what the registry has. `;
+    const baseEmptyHint = opts.type ? `no packages of type "${opts.type}" match. Try without --type, or list everything: kordis search --type ${opts.type} --sort recent --limit 25` : queryProvided ? "narrow with `--type skill|mcp-server|project-rules|custom-agent|hook|judgment-pattern` or `--tag <topic>` (e.g. aws, fastapi), broaden the keywords, or browse `--sort trending`" : 'try keywords (e.g. `kordis search "topic"`), `--tag <topic>`, or `kordis search --trending`';
+    const emptyHintForJson = partialNote === "" ? baseEmptyHint : `${partialNote}Then ${baseEmptyHint}`;
     printDual({
-      json: res.results.length === 0 ? { ...res, hint: emptyHint } : res,
+      json: res.results.length === 0 ? { ...res, hint: emptyHintForJson } : (
+        // A non-empty answer to a partly-untranslated query is still a
+        // partial one, and rows that look plausible are exactly when
+        // that goes unsaid: the session this came from read ten
+        // unrelated hits and reported the registry had nothing, never
+        // mentioning that two of its three words were never looked up.
+        partialNote === "" ? res : { ...res, hint: partialNote.trimEnd() }
+      ),
       human: () => {
         if (res.results.length === 0) {
           printHuman(c.yellow("(no results)"));
-          printHuman(c.gray(`  \u2192 ${emptyHint}`));
+          printTranslation(res.query_translation);
+          printHuman(c.gray(`  \u2192 ${baseEmptyHint}`));
           return;
         }
         if (typeof res.total === "number") {
@@ -7338,6 +7406,7 @@ function searchCommand() {
           );
           printHuman("");
         }
+        printTranslation(res.query_translation);
         for (const p of res.results) {
           printHuman(
             `${c.bold(p.full_slug)} ${c.gray(`v${p.current_version}`)} ${c.cyan(`[${p.type}]`)}`
@@ -7365,6 +7434,22 @@ function searchCommand() {
     });
   });
 }
+function printTranslation(fb) {
+  if (!fb) return;
+  printHuman(
+    c.gray(
+      `Korean words in "${stripControl(fb.original)}" were also searched as "${stripControl(fb.translated)}" (registry ko\u2192en lexicon)`
+    )
+  );
+  if (fb.unmapped.length > 0) {
+    printHuman(
+      c.yellow(
+        `\u26A0 NOT searched: ${fb.unmapped.map(stripControl).join(", ")} \u2014 no lexicon entry. Say so before reporting that nothing was found.`
+      )
+    );
+  }
+  printHuman("");
+}
 
 // src/commands/push.ts
 init_parser();
@@ -7617,13 +7702,11 @@ var ProjectRulesFrontmatterSchema = z18.object({
   /** When true, installation is idempotent via `<!-- kordis:... -->` markers. */
   mergeable: z18.boolean().default(true),
   license: z18.string().max(64).optional()
-}).strict().refine(
-  (v) => v.scope !== "nested" || !!v.target_path,
-  { message: 'scope="nested" requires target_path' }
-).refine(
-  (v) => v.scope !== "globs" || v.globs && v.globs.length > 0,
-  { message: 'scope="globs" requires a non-empty globs list' }
-);
+}).strict().refine((v) => v.scope !== "nested" || !!v.target_path, {
+  message: 'scope="nested" requires target_path'
+}).refine((v) => v.scope !== "globs" || v.globs && v.globs.length > 0, {
+  message: 'scope="globs" requires a non-empty globs list'
+});
 
 // ../../packages/harness-schema/src/types/custom-agent.ts
 init_src();
@@ -8652,9 +8735,10 @@ function buildSkillFile(input, outputPath) {
 function buildSkillDir(input, outputPath) {
   const result = buildSkillFile(input, outputPath);
   const skillMdPath = result.files[0].path;
-  const skillDir = skillMdPath.slice(0, skillMdPath.lastIndexOf("/"));
+  const slash = skillMdPath.lastIndexOf("/");
+  const skillDir = slash === -1 ? "" : skillMdPath.slice(0, slash);
   const assetFiles = (input.assets ?? []).map((asset) => ({
-    path: `${skillDir}/${asset.path}`,
+    path: skillDir ? `${skillDir}/${asset.path}` : asset.path,
     content: asset.content,
     mergeable: false,
     format: "plain",
@@ -8686,6 +8770,7 @@ var skillToCopilot = (input) => buildSkillSingleFile(input, ".github/skills/{nam
 var skillToGeminiCli = (input) => buildSkillDir(input, ".gemini/skills/{name}/SKILL.md");
 var skillToOpenCode = (input) => buildSkillSingleFile(input, ".opencode/skills/{name}.md");
 var skillToAntigravity = (input) => buildSkillSingleFile(input, ".antigravity/skills/{name}.md");
+var skillToAgentsMd = (input) => buildSkillDir(input, ".agents/skills/{name}/SKILL.md");
 var skillCanonical = (input) => {
   const res = buildSkillDir(input, "SKILL.md");
   res.format = "agent-skills-canonical";
@@ -8702,15 +8787,39 @@ function fence(input) {
 }
 var TOOL_FILE_SPEC = {
   claude: { path: "CLAUDE.md", format: "markdown" },
+  // Same file, two entries on purpose: `codex` is one vendor that reads
+  // AGENTS.md, `agents-md` is the convention itself. Splitting them lets the
+  // label stop lying without changing a byte of what gets written.
   codex: { path: "AGENTS.md", format: "markdown" },
-  gemini: { path: "GEMINI.md", format: "markdown" },
-  cursor: {
-    path: ".cursorrules",
-    format: "plain",
-    notes: [
-      "Cursor .cursorrules is a flat text file; fence markers are preserved as HTML comments."
-    ]
-  },
+  "agents-md": { path: "AGENTS.md", format: "markdown" },
+  // Gemini CLI's context file is GEMINI.md, and it is not an AGENTS.md reader:
+  // the shipped 0.56.0 bundle has `DEFAULT_CONTEXT_FILENAME = "GEMINI.md"` and
+  // zero occurrences of the string `AGENTS.md` anywhere in it (checked
+  // 2026-09-06). A `.gemini/rules/project.md` spec used to sit here as well and
+  // was never reachable — no such path exists in that bundle either.
+  "gemini-cli": { path: "GEMINI.md", format: "markdown" },
+  // `cursor` is deliberately absent from this table — `.cursor/rules/*.mdc`
+  // is a per-package path with YAML frontmatter and a whole-file write, none
+  // of which `ToolSpec`/`build()` can express. See `projectRulesToCursor`.
+  //
+  // `windsurf` is a LEGACY VENDOR NAME. Cognition rebranded Windsurf to Devin
+  // Desktop in 2026-06 and retired Cascade on 2026-07-01, so this slug names a
+  // product that no longer ships under that name. The slug stays because it is
+  // a member of `ToolSlugSchema`, it is recorded in published packages'
+  // `compatibility.hosts`, and people have scripted `--tool windsurf`.
+  //
+  // `.windsurfrules` is UNVERIFIED, and that is the honest status rather than
+  // an oversight: no current Devin Desktop documentation has been read
+  // first-hand for this path, and the Windsurf docs that once described it went
+  // with the product name. It is kept because it is what Kordis has always
+  // written here — not because anything confirmed it.
+  //
+  // Do NOT "fix" this by inventing `.devin/rules/`. There is no evidence for
+  // that path either, and writing to a guessed path is the exact failure this
+  // arc is correcting (compare the dead `.gemini/rules/project.md` above).
+  // Establishing Devin Desktop's real rules location — and its skills
+  // location, `skillToWindsurf` in `../skill/identity.ts` — is a separate
+  // track that needs the product in hand.
   windsurf: { path: ".windsurfrules", format: "plain" },
   copilot: {
     path: ".github/copilot-instructions.md",
@@ -8728,10 +8837,20 @@ var TOOL_FILE_SPEC = {
     path: ".antigravity/rules/project.md",
     format: "markdown"
   },
-  "gemini-cli": {
-    path: ".gemini/rules/project.md",
-    format: "markdown"
-  },
+  // `.opencode/rules/project.md` is DISPROVEN, not merely unverified: OpenCode
+  // reads the project's `AGENTS.md` for rules (opencode.ai/docs/rules, checked
+  // 2026-09-06; global copy at `~/.config/opencode/AGENTS.md`), and
+  // `.opencode/` appears nowhere in that documentation. So every rules package
+  // ever installed through this entry landed in a file OpenCode does not read.
+  // Full evidence on `skillToOpenCode` (`../skill/identity.ts`).
+  //
+  // Detection no longer routes here: `TOOL_MARKERS`
+  // (`apps/cli/src/commands/pull.ts`) maps an `AGENTS.md` project to
+  // `agents-md`, and there is no `.opencode` marker, so an OpenCode project
+  // now gets `AGENTS.md` written. This entry survives only for an explicit
+  // `--tool opencode`, and only so that flag keeps working for anyone who
+  // scripted it — the path it writes is still the wrong one.
+  // @deprecated Use `--tool agents-md` (or plain detection) instead.
   opencode: { path: ".opencode/rules/project.md", format: "markdown" }
 };
 function build2(spec, input, formatName) {
@@ -8750,13 +8869,37 @@ function build2(spec, input, formatName) {
 }
 var projectRulesToClaude = (input) => build2(TOOL_FILE_SPEC["claude"], input, "claude-md");
 var projectRulesToCodex = (input) => build2(TOOL_FILE_SPEC["codex"], input, "agents-md");
-var projectRulesToGemini = (input) => build2(TOOL_FILE_SPEC["gemini"], input, "gemini-md");
-var projectRulesToCursor = (input) => build2(TOOL_FILE_SPEC["cursor"], input, "cursorrules");
+var projectRulesToAgentsMd = (input) => build2(TOOL_FILE_SPEC["agents-md"], input, "agents-md");
+var projectRulesToGeminiCli = (input) => build2(TOOL_FILE_SPEC["gemini-cli"], input, "gemini-md");
+var CURSOR_RULE_DIR = ".cursor/rules";
+var projectRulesToCursor = (input) => {
+  const slug = input.fullSlug.split("/")[1] ?? input.fullSlug;
+  const description = typeof input.frontmatter["description"] === "string" ? input.frontmatter["description"] : input.fullSlug;
+  const frontmatter = `---
+description: ${JSON.stringify(description)}
+alwaysApply: true
+---
+
+`;
+  return {
+    files: [
+      {
+        path: `${CURSOR_RULE_DIR}/kordis-${slug}.mdc`,
+        content: frontmatter + fence(input),
+        mergeable: false,
+        format: "markdown"
+      }
+    ],
+    notes: [
+      `Cursor rule installed at ${CURSOR_RULE_DIR}/kordis-${slug}.mdc with alwaysApply: true \u2014 it is in context for every request. Delete the file to stop that.`
+    ],
+    format: "cursor-mdc"
+  };
+};
 var projectRulesToWindsurf = (input) => build2(TOOL_FILE_SPEC["windsurf"], input, "windsurfrules");
 var projectRulesToCopilot = (input) => build2(TOOL_FILE_SPEC["copilot"], input, "copilot-instructions-md");
 var projectRulesToContinue = (input) => build2(TOOL_FILE_SPEC["continue"], input, "continue-rules-md");
 var projectRulesToAntigravity = (input) => build2(TOOL_FILE_SPEC["antigravity"], input, "antigravity-rules-md");
-var projectRulesToGeminiCli = (input) => build2(TOOL_FILE_SPEC["gemini-cli"], input, "gemini-cli-rules-md");
 var projectRulesToOpenCode = (input) => build2(TOOL_FILE_SPEC["opencode"], input, "opencode-rules-md");
 var projectRulesCanonical = (input) => ({
   files: [
@@ -9072,7 +9215,8 @@ var REGISTRY = {
     copilot: skillToCopilot,
     "gemini-cli": skillToGeminiCli,
     opencode: skillToOpenCode,
-    antigravity: skillToAntigravity
+    antigravity: skillToAntigravity,
+    "agents-md": skillToAgentsMd
   },
   "project-rules": {
     canonical: projectRulesCanonical,
@@ -9084,9 +9228,8 @@ var REGISTRY = {
     copilot: projectRulesToCopilot,
     "gemini-cli": projectRulesToGeminiCli,
     opencode: projectRulesToOpenCode,
-    antigravity: projectRulesToAntigravity
-    // `gemini` CLI vs codex's GEMINI.md — codex reads both; we map "gemini-cli"
-    // to its own dir and "codex" to AGENTS.md. GEMINI.md alias below.
+    antigravity: projectRulesToAntigravity,
+    "agents-md": projectRulesToAgentsMd
   },
   "mcp-server": {
     canonical: mcpCanonical,
@@ -9110,7 +9253,6 @@ var REGISTRY = {
     "claude-code": judgmentToClaude
   }
 };
-REGISTRY["project-rules"]["gemini-cli"] = projectRulesToGemini;
 var TranslatorNotSupportedError = class extends Error {
   type;
   format;
@@ -9339,11 +9481,13 @@ async function doPullInstall(fullSlug, tool, installRoot, opts = {}) {
     throw e;
   }
   const bundle = await useClient();
-  const pullRes = await bundle.api.pull(username, slug, {
+  const pullBody = {
     ...opts.version ? { version: opts.version } : {},
     ...opts.withRequired !== void 0 ? { with_required: opts.withRequired } : {},
-    ...opts.withRecommends !== void 0 ? { with_recommends: opts.withRecommends } : {}
-  });
+    ...opts.withRecommends !== void 0 ? { with_recommends: opts.withRecommends } : {},
+    tool
+  };
+  const pullRes = await bundle.api.pull(username, slug, pullBody);
   const contentRes = await bundle.api.getContent(username, slug, {
     format: "canonical",
     // Server resolved the range during pull; pass the concrete version
@@ -9463,9 +9607,12 @@ function pullCommand() {
       const installRoot = opts.target ?? userCwd;
       const detected = opts.tool ?? await detectTool(installRoot);
       if (!detected) {
-        throw new Error(
-          "Cannot detect target tool from the current directory.\n  Pass --tool <name> explicitly. Valid: claude-code, codex, cursor,\n  continue, windsurf, antigravity, copilot.\n  Or run `kordis pull` inside a project that already has one of:\n  .claude/, .codex/, .cursor/, AGENTS.md, CLAUDE.md, .cursorrules,\n  .continue/, .windsurf/, .antigravity/, .github/copilot-instructions.md"
+        const e = new Error(
+          "Cannot detect target tool from the current directory."
         );
+        e.hint = `Pass --tool <name> explicitly. Valid: ${ToolSlugSchema.options.join(", ")}.
+Or run \`kordis pull\` inside a project that already has one of: ${TOOL_MARKERS.map(([marker]) => marker).join(", ")}.`;
+        throw e;
       }
       const rootLabel = pin ? `${parsed.fullSlug}@${pin}` : parsed.fullSlug;
       const spin = spinner(`Pulling ${rootLabel}`);
@@ -9560,22 +9707,33 @@ function pullCommand() {
     }
   );
 }
+var TOOL_MARKERS = [
+  [".claude", "claude-code"],
+  [".codex", "codex"],
+  [".gemini", "gemini-cli"],
+  // The shared skills dir. Both Codex and Gemini read it; neither owns it.
+  [".agents", "agents-md"],
+  // Was `codex` until 2026-09-06. AGENTS.md is a convention, not a vendor.
+  ["AGENTS.md", "agents-md"],
+  ["CLAUDE.md", "claude-code"],
+  ["GEMINI.md", "gemini-cli"],
+  // Project-rules markers only — about rules files, not skill routing.
+  [".cursorrules", "cursor"],
+  [".windsurfrules", "windsurf"],
+  [".github/copilot-instructions.md", "copilot"],
+  // Vendor directories with no evidence behind their skills path. Present =
+  // "a project set up for an agentic tool", which is true and useful; it just
+  // does not license writing to `<vendor>/skills/`. Last, so everything above
+  // wins first.
+  [".cursor", "agents-md"],
+  [".continue", "agents-md"],
+  [".windsurf", "agents-md"],
+  [".antigravity", "agents-md"],
+  [".opencode", "agents-md"]
+];
 async function detectTool(root) {
   const { stat: stat3 } = await import("fs/promises");
-  const checks = [
-    [".claude", "claude-code"],
-    [".cursor", "cursor"],
-    [".continue", "continue"],
-    [".windsurf", "windsurf"],
-    [".antigravity", "antigravity"],
-    [".codex", "codex"],
-    ["AGENTS.md", "codex"],
-    ["CLAUDE.md", "claude-code"],
-    [".cursorrules", "cursor"],
-    [".windsurfrules", "windsurf"],
-    [".github/copilot-instructions.md", "copilot"]
-  ];
-  for (const [path2, tool] of checks) {
+  for (const [path2, tool] of TOOL_MARKERS) {
     try {
       await stat3(join10(root, path2));
       return tool;
@@ -13593,7 +13751,7 @@ function memoryCommand() {
 }
 
 // src/index.ts
-var ALIAS_NOTICE = "kordis is now part of memgineering \u2014 `kordis` keeps working as an alias until memgineering 0.20.0; the same verbs live at `memgineering <verb>`.";
+var ALIAS_NOTICE = "kordis is now part of memgineering \u2014 `kordis` keeps working as an alias until memgineering 0.21.0; the same verbs live at `memgineering registry <verb>`.";
 var aliasNoticePrinted = false;
 function printAliasNotice() {
   if (aliasNoticePrinted) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayul/kordis",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "private": false,
   "description": "Command-line client for the Kordis registry — discover, install, and publish agentic-coding packages.",
   "license": "Apache-2.0",