diff --git a/README.ko.md b/README.ko.md
index 90d51ee..c5b5310 100644
--- a/README.ko.md
+++ b/README.ko.md
@@ -168,7 +168,7 @@ agent  APPROVED: intent of claims-status (.sdlc/work/claims-status/intent.md)
 
 **기록을 어디에 둘지는 사용자가 정합니다.** 기본값은 프로젝트 작업 사본 안이고, `init.sh . --area ~/knowledge`를 쓰면 사용자가 고른 폴더 아래 `<area>/<단위이름>-<체크아웃 식별자>/`에 저장하고 `.sdlc`를 그곳으로 연결합니다. 체크아웃마다 저장소가 하나씩이므로 워크트리 두 개가 승인 상태를 공유하는 일이 없습니다. 영역이 프로젝트 안에 있거나 프로젝트가 영역 안에 있을 때, 다른 체크아웃이 이미 그 저장소를 소유할 때, 실제 `.sdlc` 디렉터리가 이미 있을 때(자동으로 옮기지 않습니다), 링크를 만들 수 없을 때는 아무것도 쓰지 않고 분명히 실패합니다. 이 소유권은 init 시점뿐 아니라 실행 시점에도 다시 확인합니다. `<store>/PROJECT`에 적힌 체크아웃이 지금 실행 중인 체크아웃과 다르면 `check-gate.sh`, `approve.sh`, `close.sh`, `status.sh`, `tools/auto.sh`, `tools/verify.sh`, `tools/handoff.sh`가 판정을 내리거나 상태를 쓰기 전에 거부하므로, 심볼릭 링크를 그대로 복사한 작업 사본(`cp -R`, rsync, 대부분의 백업 복원)이 다른 체크아웃의 게이트를 열거나 그 피처를 닫을 수 없습니다. 읽기는 이 제약을 받지 않아 `tools/kb.sh show|search|list`는 그대로 쓸 수 있고, 소유권을 자동으로 옮기거나 다시 묶는 일은 없습니다. 어느 쪽을 고르든 **저장소 백업은 사용자의 몫입니다.** git이 더 이상 대신해 주지 않습니다.
 
-**기록을 다시 읽는 도구는 `tools/kb.sh`입니다.** `index`는 목차 페이지를 다시 만듭니다(`init.sh`와 `close.sh`가 자동으로 실행합니다). 페이지는 상태·날짜·태그를 담은 개요 표(최신순), 아직 close가 병합하지 않은 harvest 목록, 피처별 절 순서입니다. `show <slug>`는 피처 하나를 요약본으로 보여줍니다. 목표, `summary.md`(문제·원인·변경·결과·교훈을 담는, 계속 갱신하도록 만든 유일한 기록), 배포 상태, 병합되지 않은 harvest 후보, 교훈 제목이 먼저 나오고 파일 경로는 마지막입니다. `search "<문자열>"`은 열린 피처와 닫힌 피처, 지속 메모리를 대상으로 출력량을 제한한 문자열 검색을 하고, `harvest [--stale <일수>]`는 harvest.md가 아직 memory/에 들어가지 않은 열린 피처를 유휴 기간과 함께 나열합니다(유휴 상태가 오래된 피처는 close 없이 병합할 수 있습니다 — AGENTS.md 규칙 4). `--area <폴더>`를 붙이면 그 폴더 안의 모든 저장소를 대상으로 같은 일을 하며, 원래 체크아웃이 사라진 피처도 읽을 수 있습니다. `index --obsidian`(또는 저장소 config.md의 `index_style: obsidian`)은 Obsidian 볼트용 frontmatter와 인라인 `#태그`를 덧붙입니다. 생성 시각은 절대 쓰지 않으므로 내용이 같으면 diff도 생기지 않습니다. 종료 코드는 `0` 찾음, `1` 없음, `2` 사용법 오류 또는 거부입니다.
+**기록을 다시 읽는 도구는 `tools/kb.sh`입니다.** `index`는 목차 페이지를 다시 만듭니다(`init.sh`와 `close.sh`가 자동으로 실행합니다). 페이지는 상태·날짜·태그를 담은 개요 표(최신순), 아직 close가 병합하지 않은 harvest 목록, 피처별 절 순서입니다. `show <slug>`는 피처 하나를 요약본으로 보여줍니다. 목표, `summary.md`(문제·원인·변경·결과·교훈을 담는, 계속 갱신하도록 만든 유일한 기록), 배포 상태, 병합되지 않은 harvest 후보, 교훈 제목이 먼저 나오고 파일 경로는 마지막입니다. `search "<문자열>"`은 열린 피처와 닫힌 피처, 지속 메모리를 대상으로 출력량을 제한한 문자열 검색을 하고, `harvest [--stale <일수>]`는 harvest.md가 아직 memory/에 들어가지 않은 열린 피처를 유휴 기간과 함께 나열합니다(유휴 상태가 오래된 피처는 close 없이 병합할 수 있습니다 — AGENTS.md 규칙 4). `--area <폴더>`를 붙이면 그 폴더 안의 모든 저장소를 대상으로 같은 일을 하며, 원래 체크아웃이 사라진 피처도 읽을 수 있습니다. 저장소 config.md에 `index_style: obsidian`을 적으면 Obsidian 볼트용 frontmatter와 인라인 `#태그`를 덧붙입니다. 생성 시각은 절대 쓰지 않으므로 내용이 같으면 diff도 생기지 않습니다. 종료 코드는 `0` 찾음, `1` 없음, `2` 사용법 오류 또는 거부입니다.
 
 공개 sdlc-kit 저장소는 프레임워크만 담습니다. 기록은 작성된 자리, 즉 프로젝트 작업 사본이나 사용자가 고른 영역에 남아 그대로 읽힙니다.
 
diff --git a/README.md b/README.md
index a246f1b..87d5cab 100644
--- a/README.md
+++ b/README.md
@@ -168,7 +168,7 @@ Per feature, inside the **target project**:
 
 **Where the records live is your choice.** By default they sit in the project's working copy. `init.sh . --area ~/knowledge` puts them in a folder you choose instead — `<area>/<unit>-<checkout-id>/`, with `.sdlc` linked to it, one store per checkout so two worktrees never share approvals. The area is refused if it sits inside the project (or the project inside it), if another checkout already owns that store, if a real `.sdlc` directory is already there (nothing is ever relocated for you), or if the link cannot be made. That ownership is re-checked at RUNTIME, not only at init: `check-gate.sh`, `approve.sh`, `close.sh`, `status.sh`, `tools/auto.sh`, `tools/verify.sh` and `tools/handoff.sh` refuse before any verdict or write when `<store>/PROJECT` names a different checkout, so a copied working copy (`cp -R`, rsync and most restores keep the symlink) can neither open another checkout's gate nor close its features. Reading is never bound that way: `tools/kb.sh show|search|list` still works, and nothing is ever re-bound or moved for you. Whichever you choose, **the store is yours to back up** — git no longer does it for you.
 
-**Reading the records back** is `tools/kb.sh`: `index` regenerates the contents page (`init.sh` and `close.sh` do it for you) — an overview table by state, date and tags, newest first, the harvests no close has merged yet, then one section per feature; `show <slug>` prints one feature as a digest — goal, its `summary.md` (Problem/Cause/Change/Result/Lesson, the one record meant to be kept current), delivery, unmerged harvest candidates, lesson titles, then the paths; `search "<text>"` does a bounded literal search over open and closed features plus durable memory; `harvest [--stale <days>]` lists open features whose harvest.md is not in memory yet, with idle time (a stale one may be merged without closing — AGENTS.md rule 4); and `--area <folder>` does any of these across every store in that folder — including features whose checkout no longer exists. `index --obsidian` (or `index_style: obsidian` in the store's config.md) adds frontmatter and inline `#tags` for a vault; no timestamp is ever written, so an unchanged page produces no diff. Exit codes: `0` found, `1` nothing found, `2` usage error or refusal.
+**Reading the records back** is `tools/kb.sh`: `index` regenerates the contents page (`init.sh` and `close.sh` do it for you) — an overview table by state, date and tags, newest first, the harvests no close has merged yet, then one section per feature; `show <slug>` prints one feature as a digest — goal, its `summary.md` (Problem/Cause/Change/Result/Lesson, the one record meant to be kept current), delivery, unmerged harvest candidates, lesson titles, then the paths; `search "<text>"` does a bounded literal search over open and closed features plus durable memory; `harvest [--stale <days>]` lists open features whose harvest.md is not in memory yet, with idle time (a stale one may be merged without closing — AGENTS.md rule 4); and `--area <folder>` does any of these across every store in that folder — including features whose checkout no longer exists. `index_style: obsidian` in the store's config.md adds frontmatter and inline `#tags` for a vault; no timestamp is ever written, so an unchanged page produces no diff. Exit codes: `0` found, `1` nothing found, `2` usage error or refusal.
 
 The public sdlc-kit repository stays framework-only. The records live and stay readable where they were written — in the project's working copy, or in the area you chose.
 
diff --git a/SKILL.md b/SKILL.md
index 848bd33..70f20b0 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -36,7 +36,7 @@ they do it under this contract (gates, artifacts, memory), not beside it.
 | "continue <slug>" / "what's next" | Run `gates/status.sh <slug>` from the project root. Its `next →` line names the stage skill or gate command. |
 | "where are we" / "sdlc status" | `gates/status.sh` (open features; `--all` adds the newest 20 archived) + `gates/stats.sh` (open + recent closed). Full-archive sweeps: `ls`/`grep .sdlc/archive/`, never the whole listing into context. |
 | "has this been done before" / "why is X like this" / debugging an old area | `tools/kb.sh search "<text>"` then `tools/kb.sh show <slug>` — a digest (goal, summary.md, delivery, unmerged harvest candidates, lesson titles, then the paths) over open and closed features plus durable memory, bounded output (`--area <folder>` covers every store, even one whose checkout is gone). Exit 0 found · 1 nothing · 2 usage/refusal. |
-| "what did we learn that is not in memory yet" / many open features, few closes | `tools/kb.sh harvest [--stale <days>]` — open features whose harvest.md no close has merged, with idle time; a STALE one may be merged without closing (AGENTS.md rule 4). The contents page (`tools/kb.sh index`; `--obsidian` or `index_style: obsidian` in config.md for a vault) shows the same candidates and an overview table by state, date and tags. |
+| "what did we learn that is not in memory yet" / many open features, few closes | `tools/kb.sh harvest [--stale <days>]` — open features whose harvest.md no close has merged, with idle time; a STALE one may be merged without closing (AGENTS.md rule 4). The contents page (`tools/kb.sh index`; `index_style: obsidian` in config.md for a vault) shows the same candidates and an overview table by state, date and tags. |
 | a host/scheduler drives the loop, or you need machine state | `gates/status.sh --json` (= `tools/auto.sh status --json`) and `tools/auto.sh next <slug>` (exit 0 ready · 10 needs-human · 20 blocked · 30 complete). Verification receipts: `tools/verify.sh`; review handoff: `tools/handoff.sh`. Contract: `docs/automation.md`. These report and record — they run no stage. |
 | gate request answered "approve" in chat | `gates/approve.sh <stage> <artifact> --delegated` per AGENTS.md rule 3. |
 | incident / bug / alert on a shipped feature | Read `skills/6-maintain/SKILL.md`. |
diff --git a/VERSION b/VERSION
index 6345c21..b561134 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-v0.13.0
+v0.13.1
diff --git a/gates/knowledge-test.sh b/gates/knowledge-test.sh
index e29f4b3..eea8f9a 100755
--- a/gates/knowledge-test.sh
+++ b/gates/knowledge-test.sh
@@ -649,18 +649,19 @@ assert_exit "H23 harvest exits 1 for a store with nothing unmerged" 1 \
   sh -c "mkdir -p '$FIX/hempty/work/x' && echo '# Intent: x' > '$FIX/hempty/work/x/intent.md' && bash '$KIT/tools/kb.sh' harvest --store '$FIX/hempty'"
 assert_fail_msg "H24 harvest takes no positional argument" "takes no argument" bash "$KIT/tools/kb.sh" harvest h-new
 assert_fail_msg "H25 --stale wants a number" "number of days" bash "$KIT/tools/kb.sh" harvest --stale soon
-# obsidian — frontmatter and inline tags on the generated page only
-assert_ok "H26 index --obsidian writes the page" kb index --obsidian
+# obsidian — a store setting (config.md), so init.sh and close.sh keep the style;
+# it changes the generated page only
+printf 'index_style: obsidian   # tools/kb.sh index\n' >> .sdlc/config.md
+assert_ok_msg "H26 index_style: obsidian in config.md selects the style" "(obsidian)" kb index
 assert_ok_msg "H27 the page opens with frontmatter" "---" head -n 1 "$PAGE"
 assert_ok_msg "H28 the frontmatter tags the page" "tags: [sdlc-kit, knowledge]" head -n 5 "$PAGE"
 assert_ok_msg "H29 feature tags become inline #tags" "#roster #export" cat "$PAGE"
 assert_ok_msg "H30 links stay relative markdown" "](work/h-new/intent.md)" cat "$PAGE"
-assert_ok "H31 a frontmatter page is still recognized as generated (plain regenerate)" kb index
-assert_exit "H32 a plain regenerate drops the frontmatter again" 1 sh -c "head -n 1 '$PAGE' | grep -q '^---'"
-printf 'index_style: obsidian   # tools/kb.sh index\n' >> .sdlc/config.md
-assert_ok "H33 index_style in config.md selects the style without a flag" kb index
-assert_ok_msg "H34 the configured style produced frontmatter" "sdlc_store:" head -n 5 "$PAGE"
-assert_fail_msg "H35 --obsidian is refused for anything but index" "applies to index only" bash "$KIT/tools/kb.sh" show h-new --obsidian
+assert_ok "H31 a frontmatter page is still recognized as generated" kb index
+sed -i.bak '/^index_style:/d' .sdlc/config.md && rm -f .sdlc/config.md.bak
+assert_ok_msg "H32 removing the setting regenerates a plain page" "(plain)" kb index
+assert_exit "H33 the plain page has no frontmatter" 1 sh -c "head -n 1 '$PAGE' | grep -q '^---'"
+assert_fail_msg "H34 there is no style flag — one setting, one place" "unknown option" bash "$KIT/tools/kb.sh" index --obsidian
 assert_ok_msg "H36 records under work/ were not written by any of this" "not delivered" cat .sdlc/work/h-new/summary.md
 assert_nofile ".sdlc/work/h-new/README.md" "H37 no page was written inside a feature directory"
 cd "$FIX" || exit 2
diff --git a/log/changelog-v0.13.1.md b/log/changelog-v0.13.1.md
new file mode 100644
index 0000000..2831022
--- /dev/null
+++ b/log/changelog-v0.13.1.md
@@ -0,0 +1,43 @@
+# v0.13.1 — kb.sh without the duplication v0.13.0 shipped with
+
+A refactor of `tools/kb.sh` with one intentional behaviour change. Output of
+`show`, `index`, `list`, `search` and `harvest` is unchanged byte for byte
+except where noted; the gates are untouched.
+
+## Changes
+
+- **One definition of "unmerged harvest".** `index` and `harvest` each had their
+  own loop deciding which open features still hold candidates; both now read
+  `kb_unmerged`. `index`'s two passes over the features (overview table, then
+  one section each) share `kb_meta` for state, date, tags and title instead of
+  extracting them twice.
+- **`kb_get`** replaces the nine `kb_real "$(kb_field …)"` idioms; `kb_closed`
+  replaces the three awk one-liners over `CLOSED`.
+- **Dropped: the `## Summary`-inside-intent.md fallback.** It supported a format
+  no store ever wrote — designed and abandoned inside the v0.13.0 work — and its
+  helper `kb_summary_where` with it. `summary.md` is the digest.
+- **Dropped: `index --obsidian`.** The page style is a property of the store, and
+  `init.sh` and `close.sh` regenerate the page without flags, so
+  `index_style: obsidian` in the store's `config.md` was already the setting
+  that mattered. One setting, one place; the flag is now an unknown option.
+- **Fixed on the way:** `show` printed `Tags:` only when the intent carried them,
+  although the tags live in `summary.md` — the meta line now uses the same
+  `kb_tags` the page uses. A feature that carries a `CLOSED` record but was never
+  archived (an interrupted close) is now treated as closed everywhere on the
+  page — sorted by `closed_at` and labelled `closed <date>` — where before only
+  `archive/` entries were.
+- Internal record lines use `\037` as separator, not a tab: a tab is IFS
+  whitespace, so `read` collapses adjacent tabs and an empty field (no tags, no
+  date) shifted the fields after it.
+- Header comment shortened; `tools/kb.sh` 605 → 538 lines.
+
+Checked against a real store (84 open, 2 archived, Korean records): the page
+and the `show` digests are byte-identical to v0.13.0 except for the two lines
+the fixes above describe; `harvest` output is identical.
+
+## Validation
+
+- `bash gates/knowledge-test.sh` → `KNOWLEDGE-TEST PASS`, 144 assertions
+  (section H rewritten for the config-only style; the flag refusal is asserted)
+- `bash gates/selftest.sh` → `SELFTEST PASS`
+- `bash gates/e2e.sh` → `E2E PASS`, 152 · `bash gates/autotest.sh` → `AUTOTEST PASS`, 195
diff --git a/tools/kb.sh b/tools/kb.sh
index c2d349f..7fdef6b 100755
--- a/tools/kb.sh
+++ b/tools/kb.sh
@@ -3,7 +3,7 @@
 # evidence, delivery, CLOSED, lessons, harvest); this is how a later feature —
 # or a human — FINDS it and reads it without opening six files.
 #
-#   kb.sh index   [--store <dir>] [--obsidian]       regenerate the contents page
+#   kb.sh index   [--store <dir>]                   regenerate the contents page
 #   kb.sh list    [--store <dir> | --area <folder>]
 #   kb.sh show    <slug> [--store <dir> | --area <folder>]   one feature as a digest
 #   kb.sh search  [--store <dir> | --area <folder>] [--limit N] <literal text>
@@ -21,17 +21,12 @@
 # Never read: scratch/ (bulk evidence), approvals/ (machine records),
 # progress.md (heartbeat), baseline.txt, checkpoint.md, verify-receipt.md.
 #
-# What a reader gets (v0.13): `show` is a digest — the goal, the feature's
-# summary.md (templates/summary.md: Problem/Cause/Change/Result/Lesson, bound
-# by no approval so it can stay current), delivery state, the unmerged
-# harvest.md candidates, lesson titles — with the document paths last. `index` opens with
-# an overview table (state, date, tags), newest first, and lists the harvests
-# that no close has merged yet, so in-flight knowledge is visible from the
-# entry page instead of only after `close.sh`. `--obsidian` (or
-# `index_style: obsidian` in the store's config.md) adds YAML frontmatter and
-# inline #tags to the generated page; links stay standard relative markdown,
-# which Obsidian resolves and graphs. No timestamp is written into the page:
-# a regenerated page that did not change must not produce a diff.
+# `show` is a digest — goal, summary.md (templates/summary.md), delivery,
+# unmerged harvest.md candidates, lesson titles, then the paths. `index` opens
+# with an overview table (state, date, tags) newest first and lists the harvests
+# no close has merged yet. `index_style: obsidian` in the store's config.md adds
+# YAML frontmatter and inline #tags to the page; links stay relative markdown.
+# No timestamp is written into the page: an unchanged store yields no diff.
 #
 # Nothing under work/ or archive/ is ever written — an approval-bound artifact
 # cannot change because the page was regenerated. `index` writes exactly one
@@ -44,10 +39,14 @@ set -u
 
 MARKER='<!-- generated by sdlc-kit tools/kb.sh — regenerated by init.sh and close.sh; edits are overwritten -->'
 LINE_MAX=200
-SUMMARY_MAX=12     # lines of summary.md shown by `show` / `index`
-HARVEST_MAX=10     # harvest.md lines shown by `show`
+SUMMARY_MAX=12      # lines of summary.md shown by `show` / `index`
+HARVEST_MAX=10      # harvest.md lines shown by `show`
 HARVEST_INDEX_MAX=6 # harvest.md lines shown per feature on the contents page
-TABLE_GOAL_MAX=120 # bytes of the goal kept in the overview table (≈40 CJK / 120 ASCII characters)
+TABLE_GOAL_MAX=120  # bytes of the goal kept in the overview table (≈40 CJK / 120 ASCII characters)
+# Field separator for this tool's own record lines. Not a tab: a tab is IFS
+# whitespace, so `read` collapses adjacent tabs and an EMPTY field (no tags, no
+# date) would shift the fields after it. \037 (ASCII unit separator) is not.
+SEP=$(printf '\037')
 
 usage() {
   sed -n '3,11p' "$0" | sed 's/^# \{0,1\}//' >&2
@@ -83,67 +82,41 @@ kb_stores() { # <store-or-empty> <area-or-empty>
   printf '%s\n' "$store"
 }
 
-# --- feature reading ---------------------------------------------------------
+# --- record fields -----------------------------------------------------------
 KB_DOCS="summary.md origin.md intent.md spec.md plan.md map.md evidence.md delivery.md CLOSED"
 
-kb_field() { # <file> <label> → the first "- <label>: value" line's value
+kb_field() { # <file> <label> → the first "- <label>: value" line's value (raw)
   [ -f "$1" ] || return 1
   awk -v k="- $2:" 'index($0, k) == 1 { sub(/^[^:]*: */, ""); sub(/[ \t\r]*$/, ""); print; exit }' "$1"
 }
-kb_real() { # <value> → the value unless it is still a template placeholder (<…>, YYYY-…)
-  case "$1" in ''|'<'*|YYYY*) printf '';; *) printf '%s' "$1";; esac
-}
-# Feature directories of one store: "<work|archive> <slug> <dir>" lines.
-kb_features() { # <store>
-  local store="$1" kind d slug
-  for kind in work archive; do
-    [ -d "$store/$kind" ] || continue
-    for d in "$store/$kind"/*; do
-      [ -d "$d" ] || continue
-      if [ -L "$d" ]; then
-        echo "note: skipped $d — a feature directory that is a symlink is not read" >&2
-        continue
-      fi
-      slug=$(basename "$d")
-      printf '%s %s %s\n' "$kind" "$slug" "$d"
-    done
-  done
-}
-kb_lessons() { # <store> <slug> → lesson paths naming the slug
-  local d="$1/memory/lessons" f
-  [ -d "$d" ] || return 0
-  for f in "$d"/*"$2"*; do [ -f "$f" ] && printf '%s\n' "$f"; done
-}
-kb_state() { # <dir> → open | the CLOSED state
-  local c="$1/CLOSED"
-  if [ -f "$c" ]; then awk '/^state: /{print $2; exit}' "$c"; else echo open; fi
+kb_get() { # <file> <label> → the value, or empty when absent or still a template placeholder (<…>, YYYY-…)
+  local v; v=$(kb_field "$1" "$2" 2>/dev/null || true)
+  case "$v" in ''|'<'*|YYYY*) printf '';; *) printf '%s' "$v";; esac
 }
 kb_h1() { # <file> [prefix to drop, e.g. "Intent: "] → the first H1, cleaned
   [ -f "$1" ] || return 0
   awk -v p="${2:-}" '/^# /{ sub(/^# */, ""); if (p != "" && index($0, p) == 1) $0 = substr($0, length(p) + 1); sub(/[ \t\r]*$/, ""); print; exit }' "$1"
 }
+kb_state() { # <dir> → open | the CLOSED state
+  if [ -f "$1/CLOSED" ]; then awk '/^state: /{print $2; exit}' "$1/CLOSED"; else echo open; fi
+}
+kb_closed() { # <dir> <field> → a CLOSED record field (reason, closed_at as YYYY-MM-DD)
+  [ -f "$1/CLOSED" ] || return 0
+  awk -v k="$2: " 'index($0, k) == 1 { v = substr($0, length(k) + 1); sub(/[ \t\r]*$/, "", v); if (k == "closed_at: ") v = substr(v, 1, 10); print v; exit }' "$1/CLOSED"
+}
 kb_title() { # <dir> → the Goal line, else the intent's H1 (older intents have no Goal field)
-  local g; g=$(kb_real "$(kb_field "$1/intent.md" Goal 2>/dev/null || true)")
+  local g; g=$(kb_get "$1/intent.md" Goal)
   [ -n "$g" ] || g=$(kb_h1 "$1/intent.md" "Intent: ")
   printf '%s' "$g"
 }
-kb_date() { # <dir> <slug> → YYYY-MM-DD, from the intent's Date, else a YYMMDD- slug prefix, else empty
-  local d; d=$(kb_real "$(kb_field "$1/intent.md" Date 2>/dev/null || true)")
-  case "$d" in
-    [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*) printf '%s' "$(printf '%s' "$d" | cut -c1-10)"; return;;
-  esac
-  case "$2" in
-    [0-9][0-9][0-9][0-9][0-9][0-9]-*) printf '20%s-%s-%s' "$(printf '%s' "$2" | cut -c1-2)" "$(printf '%s' "$2" | cut -c3-4)" "$(printf '%s' "$2" | cut -c5-6)"; return;;
-  esac
-  printf ''
-}
-kb_closed_at() { # <dir> → YYYY-MM-DD of the CLOSED record, or empty
-  [ -f "$1/CLOSED" ] || return 0
-  awk '/^closed_at: /{print substr($2, 1, 10); exit}' "$1/CLOSED"
+kb_date() { # <dir> <slug> → YYYY-MM-DD from the intent's Date, else a YYMMDD- slug prefix, else empty
+  local d; d=$(kb_get "$1/intent.md" Date)
+  case "$d" in [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*) printf '%s' "$d" | cut -c1-10; return;; esac
+  case "$2" in [0-9][0-9][0-9][0-9][0-9][0-9]-*)
+    printf '20%s-%s-%s' "$(printf '%s' "$2" | cut -c1-2)" "$(printf '%s' "$2" | cut -c3-4)" "$(printf '%s' "$2" | cut -c5-6)";; esac
 }
 kb_tags() { # <dir> → "tag, tag" — summary.md's Tags line (else the intent's), normalized
-  local t; t=$(kb_real "$(kb_field "$1/summary.md" Tags 2>/dev/null || true)")
-  [ -n "$t" ] || t=$(kb_real "$(kb_field "$1/intent.md" Tags 2>/dev/null || true)")
+  local t; t=$(kb_get "$1/summary.md" Tags); [ -n "$t" ] || t=$(kb_get "$1/intent.md" Tags)
   [ -n "$t" ] || return 0
   printf '%s' "$t" | tr -d '[]' | tr ',' '\n' | awk '{ gsub(/^[ \t]+|[ \t]+$/, ""); if ($0 != "") { if (n++) printf ", "; printf "%s", $0 } }'
 }
@@ -152,11 +125,12 @@ kb_hashtags() { # "tag, tag" → "#tag #tag" for Obsidian's tag pane (spaces ins
 }
 # The readable body of a record: template comments (single- and multi-line),
 # blank lines and unfilled `<placeholder>` lines are dropped; the H1 is dropped;
-# `## X` becomes `X:`. With <heading>, only that section is returned.
-kb_body() { # <file> [heading]
+# `## X` (and deeper headings) become `X:` labels, so a record embedded in the
+# contents page cannot hijack its outline.
+kb_body() { # <file>
   [ -f "$1" ] || return 0
-  awk -v H="${2:-}" '
-    BEGIN { c = 0; f = (H == "") ? 1 : 0 }
+  awk '
+    BEGIN { c = 0 }
     {
       line = $0
       if (c) { i = index(line, "-->"); if (i) { c = 0; line = substr(line, i + 3) } else next }
@@ -166,15 +140,8 @@ kb_body() { # <file> [heading]
         else { line = substr(line, 1, s - 1); c = 1; break }
       }
       sub(/[ \t\r]+$/, "", line)
-      if (line ~ /^## /) {
-        if (H != "") { if (f) exit; if (index(line, "## " H) == 1) { f = 1 }; next }
-        sub(/^## +/, "", line); print line ":"; next
-      }
-      if (!f) next
       if (line ~ /^# /) next
-      # deeper headings (some harvests use ### per candidate) become labels too,
-      # so a record embedded in the contents page cannot hijack its outline
-      if (line ~ /^###+ /) { sub(/^#+ +/, "", line); print line ":"; next }
+      if (line ~ /^##+ /) { sub(/^#+ +/, "", line); print line ":"; next }
       if (line ~ /^[ \t]*$/) next
       if (line ~ /^[ \t]*[-*] *<[^>]*>[ \t]*$/) next
       if (line ~ /^[ \t]*<[^>]*>[ \t]*$/) next
@@ -182,43 +149,78 @@ kb_body() { # <file> [heading]
       print line
     }' "$1"
 }
-kb_summary() { # <dir> → the reader's digest: summary.md, else an intent's ## Summary section (older records)
-  if [ -f "$1/summary.md" ]; then kb_body "$1/summary.md" | awk '!/^[ \t]*[-*] *Tags:/'
-  else kb_body "$1/intent.md" Summary; fi
-}
-kb_summary_where() { [ -f "$1/summary.md" ] && echo summary.md || echo intent.md; }
+kb_summary() { kb_body "$1/summary.md" | awk '!/^[ \t]*[-*] *Tags:/'; }   # <dir>; Tags is shown on the meta line
 kb_print_bounded() { # <max> <indent> <"more" location>; text on stdin
   awk -v m="$1" -v ind="$2" -v where="$3" '
     { n++; if (n <= m) print ind $0 }
     END { if (n > m) printf "%s… %d more line(s): %s\n", ind, n - m, where }'
 }
-kb_count_lines() { # kb_body text on stdin → content lines (labels ending in ":" excluded)
-  awk '!/:$/ { n++ } END { print n + 0 }'
+kb_count_lines() { awk '!/:$/ { n++ } END { print n + 0 }'; }   # kb_body text on stdin → content lines (labels excluded)
+
+# --- features ----------------------------------------------------------------
+# "<kind> <slug> <dir>" lines. Feature directories that are symlinks are never
+# read (the gates refuse them too).
+kb_features() { # <store>
+  local store="$1" kind d
+  for kind in work archive; do
+    [ -d "$store/$kind" ] || continue
+    for d in "$store/$kind"/*; do
+      [ -d "$d" ] || continue
+      if [ -L "$d" ]; then echo "note: skipped $d — a feature directory that is a symlink is not read" >&2; continue; fi
+      printf '%s %s %s\n' "$kind" "$(basename "$d")" "$d"
+    done
+  done
+}
+# "<sortkey>\t<kind>\t<slug>\t<dir>" lines of one kind, newest first: closed
+# features by closed_at, open ones by the intent's date (undated ones last).
+kb_features_sorted() { # <store> <kind>
+  local kind slug dir key
+  kb_features "$1" 2>/dev/null | while read -r kind slug dir; do
+    [ "$kind" = "$2" ] || continue
+    key=$(kb_closed "$dir" closed_at); [ -n "$key" ] || key=$(kb_date "$dir" "$slug"); [ -n "$key" ] || key="0000-00-00"
+    printf '%s\037%s\037%s\037%s\n' "$key" "$kind" "$slug" "$dir"
+  done | LC_ALL=C sort -t "$SEP" -k1,1r -k3,3
+}
+# "<state>\t<date>\t<tags>\t<title>" — the fields both index passes print.
+kb_meta() { # <dir> <slug> <style>
+  local tags; tags=$(kb_tags "$1")
+  [ "$3" = obsidian ] && [ -n "$tags" ] && tags=$(kb_hashtags "$tags")
+  printf '%s\037%s\037%s\037%s\n' "$(kb_state "$1")" "$(kb_date "$1" "$2")" "$tags" "$(kb_title "$1" | tr '\t' ' ')"
+}
+# "<slug>\t<lines>\t<dir>" for every open feature whose harvest.md still holds
+# candidates — the one definition `index` and `harvest` share.
+kb_unmerged() { # <store>
+  local kind slug dir n
+  kb_features "$1" 2>/dev/null | while read -r kind slug dir; do
+    [ "$kind" = work ] && [ -f "$dir/harvest.md" ] || continue
+    n=$(kb_body "$dir/harvest.md" | kb_count_lines)
+    [ "$n" -gt 0 ] && printf '%s\037%s\037%s\n' "$slug" "$n" "$dir"
+  done
+}
+kb_lessons() { # <store> <slug> → lesson paths naming the slug
+  local f
+  [ -d "$1/memory/lessons" ] || return 0
+  for f in "$1/memory/lessons"/*"$2"*; do [ -f "$f" ] && printf '%s\n' "$f"; done
 }
-# Idle test for the harvest report: a feature is active when any of its own
-# records (not scratch/) was modified inside the window. GNU stat first: on GNU
-# `-f %m` is not a failure but the MOUNT POINT of the file system ("/"), so a
-# BSD-first order silently returns text on Linux and Git Bash. `-c` is an
-# illegal option on BSD/macOS, so that order fails over cleanly there.
-kb_mtime() { stat -c %Y "$1" 2>/dev/null || stat -f %m "$1" 2>/dev/null || true; }
-kb_idle_days() { # <feature dir> → whole days since the newest record, or empty when unknown
+# Idle time for the harvest report: whole days since the newest of the feature's
+# own records (never scratch/). GNU stat first: on GNU `-f %m` is not a failure
+# but the MOUNT POINT of the file system ("/"), so a BSD-first order silently
+# returns text on Linux and Git Bash; `-c` is an illegal option on BSD/macOS,
+# so this order fails over cleanly there.
+kb_idle_days() { # <feature dir> → days, or empty when unknown
   local f m newest=""
   for f in "$1"/*.md "$1"/CLOSED; do
     [ -f "$f" ] || continue
-    m=$(kb_mtime "$f"); case "$m" in ''|*[!0-9]*) continue;; esac
+    m=$(stat -c %Y "$f" 2>/dev/null || stat -f %m "$f" 2>/dev/null || true)
+    case "$m" in ''|*[!0-9]*) continue;; esac
     if [ -z "$newest" ] || [ "$m" -gt "$newest" ]; then newest="$m"; fi
   done
-  [ -n "$newest" ] || return 0
-  echo $(( ( $(date +%s) - newest ) / 86400 ))
+  [ -n "$newest" ] && echo $(( ( $(date +%s) - newest ) / 86400 ))
 }
 
 # --- index -------------------------------------------------------------------
-kb_index_style() { # <store> <flag> → obsidian | plain
-  if [ "$2" = obsidian ]; then echo obsidian; return; fi
-  if [ -f "$1/config.md" ] && awk '/^index_style:[ \t]*obsidian/{ f = 1 } END { exit !f }' "$1/config.md"; then
-    echo obsidian; return
-  fi
-  echo plain
+kb_index_style() { # <store> → obsidian | plain, from the store's config.md
+  if [ -f "$1/config.md" ] && awk '/^index_style:[ \t]*obsidian/{ f = 1 } END { exit !f }' "$1/config.md"; then echo obsidian; else echo plain; fi
 }
 kb_table_cell() { # text → one table cell: pipes escaped, newlines gone, bounded
   # Bounded in BYTES under LC_ALL=C (awk's length/substr are not UTF-8 aware
@@ -230,21 +232,9 @@ kb_table_cell() { # text → one table cell: pipes escaped, newlines gone, bound
     while (i > 1 && substr($0, i, 1) >= "\200" && substr($0, i, 1) < "\300") i--
     print substr($0, 1, i - 1) "…" }'
 }
-# "<sortkey>\t<kind>\t<slug>\t<dir>" lines, newest first within each kind.
-kb_features_sorted() { # <store> <kind>
-  local store="$1" want="$2" kind slug dir key
-  kb_features "$store" 2>/dev/null | while read -r kind slug dir; do
-    [ "$kind" = "$want" ] || continue
-    if [ "$kind" = archive ]; then key=$(kb_closed_at "$dir"); else key=""; fi
-    [ -n "$key" ] || key=$(kb_date "$dir" "$slug")
-    [ -n "$key" ] || key="0000-00-00"
-    printf '%s\t%s\t%s\t%s\n' "$key" "$kind" "$slug" "$dir"
-  done | LC_ALL=C sort -t "$(printf '\t')" -k1,1r -k3,3
-}
-kb_index() { # <store> <style>
-  local store="$1" style="$2" page kind slug dir doc goal track state f date tags key when label body n_h n_stale
-  page="$store/README.md"
-  label=$(kb_label "$store")
+kb_index() { # <store>
+  local store="$1" style page label kind slug dir doc f key state date tags title when body n
+  page="$store/README.md"; label=$(kb_label "$store"); style=$(kb_index_style "$store")
   if [ -e "$page" ]; then
     if [ -L "$page" ]; then echo "FAIL: $page is a symlink — refusing to write through it" >&2; return 2; fi
     if ! head -n 12 "$page" 2>/dev/null | grep -qF "$MARKER"; then
@@ -254,11 +244,9 @@ kb_index() { # <store> <style>
     fi
   fi
   {
-    if [ "$style" = obsidian ]; then
-      # frontmatter first (Obsidian reads it only at line 1); no generated-at
-      # stamp — a page whose content did not change must not produce a diff
-      printf -- '---\ntitle: "Knowledge: %s"\nsdlc_store: "%s"\ntags: [sdlc-kit, knowledge]\n---\n' "$label" "$label"
-    fi
+    # frontmatter first (Obsidian reads it only at line 1); no generated-at
+    # stamp — a page whose content did not change must not produce a diff
+    [ "$style" = obsidian ] && printf -- '---\ntitle: "Knowledge: %s"\nsdlc_store: "%s"\ntags: [sdlc-kit, knowledge]\n---\n' "$label" "$label"
     printf '%s\n' "$MARKER"
     printf '\n# Knowledge: %s\n\n' "$label"
     if [ -f "$store/PROJECT" ]; then
@@ -269,38 +257,29 @@ kb_index() { # <store> <style>
     printf 'Search: `tools/kb.sh search "<text>"` · one feature: `tools/kb.sh show <slug>` · knowledge not merged yet: `tools/kb.sh harvest`\n'
 
     # --- overview: one row per feature, open first, newest first --------------
-    printf '\n## Overview\n\n'
-    printf '| Feature | State | Date | Tags | Goal |\n|---|---|---|---|---|\n'
-    n_h=0
+    printf '\n## Overview\n\n| Feature | State | Date | Tags | Goal |\n|---|---|---|---|---|\n'
     for kind in work archive; do
-      kb_features_sorted "$store" "$kind" | while IFS="$(printf '\t')" read -r key kind slug dir; do
+      kb_features_sorted "$store" "$kind" | while IFS="$SEP" read -r key kind slug dir; do
         [ -n "${slug:-}" ] || continue
-        state=$(kb_state "$dir")
-        [ "$key" = "0000-00-00" ] && key="—"
-        tags=$(kb_tags "$dir")
-        [ "$style" = obsidian ] && [ -n "$tags" ] && tags=$(kb_hashtags "$tags")
-        doc=intent.md; [ -f "$dir/intent.md" ] || doc=""
-        if [ -n "$doc" ]; then printf '| [%s](%s/%s/%s) ' "$slug" "$kind" "$slug" "$doc"; else printf '| %s ' "$slug"; fi
-        printf '| %s | %s | %s | %s |\n' "$state" "$key" "${tags:-—}" "$(kb_table_cell "$(kb_title "$dir")")"
+        IFS="$SEP" read -r state date tags title <<EOF
+$(kb_meta "$dir" "$slug" "$style")
+EOF
+        [ "$key" = "0000-00-00" ] && key="—"   # the column shows what the row is sorted by: closed_at once closed, else the intent's date
+        if [ -f "$dir/intent.md" ]; then printf '| [%s](%s/%s/intent.md) ' "$slug" "$kind" "$slug"; else printf '| %s ' "$slug"; fi
+        printf '| %s | %s | %s | %s |\n' "$state" "$key" "${tags:-—}" "$(kb_table_cell "$title")"
       done
     done
-    if [ -z "$(kb_features "$store" 2>/dev/null)" ]; then printf '| _none_ | | | | |\n'; fi
+    [ -n "$(kb_features "$store" 2>/dev/null)" ] || printf '| _none_ | | | | |\n'
 
     # --- knowledge that exists but is not in memory/ yet ----------------------
     # AGENTS.md rule 4: harvest.md is merged at close. A loop that never closes
     # leaves it invisible to every stage start; this section makes it visible
     # from the entry page. Read-only — merging stays a deliberate step.
-    body=$(kb_features "$store" 2>/dev/null | awk '$1 == "work"' | while read -r kind slug dir; do
-      [ -f "$dir/harvest.md" ] || continue
-      n=$(kb_body "$dir/harvest.md" | kb_count_lines)
-      [ "$n" -gt 0 ] || continue
-      printf '%s\t%s\t%s\n' "$slug" "$n" "$dir"
-    done)
+    body=$(kb_unmerged "$store")
     if [ -n "$body" ]; then
       printf '\n## Knowledge not merged yet\n\n'
-      printf '%s\n' "$body" | awk -F '\t' '{ n++; c += $2 } END { printf "%d open feature(s) hold %d line(s) in harvest.md that no close has merged into memory/ (AGENTS.md rule 4). `tools/kb.sh harvest` lists them with their idle time.\n", n, c }'
-      printf '%s\n' "$body" | while IFS="$(printf '\t')" read -r slug n dir; do
-        [ -n "${slug:-}" ] || continue
+      printf '%s\n' "$body" | awk -F "$SEP" '{ n++; c += $2 } END { printf "%d open feature(s) hold %d line(s) in harvest.md that no close has merged into memory/ (AGENTS.md rule 4). `tools/kb.sh harvest` lists them with their idle time.\n", n, c }'
+      printf '%s\n' "$body" | while IFS="$SEP" read -r slug n dir; do
         printf '\n### %s — %s line(s) · [harvest.md](work/%s/harvest.md)\n\n' "$slug" "$n" "$slug"
         kb_body "$dir/harvest.md" | kb_print_bounded "$HARVEST_INDEX_MAX" "" "work/$slug/harvest.md"
       done
@@ -309,70 +288,49 @@ kb_index() { # <store> <style>
     # --- one section per feature ----------------------------------------------
     for kind in work archive; do
       [ -d "$store/$kind" ] || continue
-      case "$kind" in
-        work) printf '\n## Open features\n';;
-        archive) printf '\n## Closed features\n';;
-      esac
-      kb_features_sorted "$store" "$kind" | while IFS="$(printf '\t')" read -r key kind slug dir; do
+      case "$kind" in work) printf '\n## Open features\n';; archive) printf '\n## Closed features\n';; esac
+      kb_features_sorted "$store" "$kind" | while IFS="$SEP" read -r key kind slug dir; do
         [ -n "${slug:-}" ] || continue
-        state=$(kb_state "$dir")
-        goal=$(kb_title "$dir")
-        track=$(kb_real "$(kb_field "$dir/intent.md" Track 2>/dev/null || true)")
-        date=$(kb_date "$dir" "$slug")
-        tags=$(kb_tags "$dir")
-        [ "$style" = obsidian ] && [ -n "$tags" ] && tags=$(kb_hashtags "$tags")
-        when=""
-        [ -n "$date" ] && when=" · $date"
-        if [ "$kind" = archive ]; then f=$(kb_closed_at "$dir"); [ -n "$f" ] && when="$when · closed $f"; fi
+        IFS="$SEP" read -r state date tags title <<EOF
+$(kb_meta "$dir" "$slug" "$style")
+EOF
+        when="${date:+ · $date}"; f=$(kb_closed "$dir" closed_at); [ -n "$f" ] && when="$when · closed $f"
         printf '\n### %s — %s%s%s\n' "$slug" "$state" "$when" "${tags:+ · $tags}"
-        [ -n "$goal" ] && printf '\n%s\n' "$goal"
+        [ -n "$title" ] && printf '\n%s\n' "$title"
         body=$(kb_summary "$dir")
-        if [ -n "$body" ]; then printf '\n'; printf '%s\n' "$body" | kb_print_bounded "$SUMMARY_MAX" "" "$kind/$slug/$(kb_summary_where "$dir")"; fi
-        [ -n "$track" ] && printf '\nTrack: %s\n' "$track"
-        if [ -f "$dir/CLOSED" ]; then
-          f=$(awk '/^reason: /{sub(/^reason: /,""); sub(/[ \t\r]*$/,""); print; exit}' "$dir/CLOSED")
-          [ -n "$f" ] && printf '\nClosed: %s\n' "$f"
-        fi
+        [ -n "$body" ] && { printf '\n'; printf '%s\n' "$body" | kb_print_bounded "$SUMMARY_MAX" "" "$kind/$slug/summary.md"; }
+        f=$(kb_get "$dir/intent.md" Track); [ -n "$f" ] && printf '\nTrack: %s\n' "$f"
+        f=$(kb_closed "$dir" reason); [ -n "$f" ] && printf '\nClosed: %s\n' "$f"
         printf '\n'
-        for doc in $KB_DOCS; do
-          [ -f "$dir/$doc" ] && printf -- '- [%s](%s/%s/%s)\n' "$doc" "$kind" "$slug" "$doc"
-        done
+        for doc in $KB_DOCS; do [ -f "$dir/$doc" ] && printf -- '- [%s](%s/%s/%s)\n' "$doc" "$kind" "$slug" "$doc"; done
         [ -f "$dir/harvest.md" ] && printf -- '- [harvest.md](%s/%s/harvest.md) — not merged into memory/ yet\n' "$kind" "$slug"
         kb_lessons "$store" "$slug" | while read -r f; do
           printf -- '- [lesson: %s](memory/lessons/%s)\n' "$(kb_h1 "$f" "Lesson: ")" "$(basename "$f")"
         done
       done
-      # `wrote` cannot survive the subshell above; report emptiness by looking again
-      if [ -z "$(kb_features "$store" 2>/dev/null | awk -v k="$kind" '$1 == k')" ]; then
-        printf '\n_none_\n'
-      fi
+      [ -n "$(kb_features "$store" 2>/dev/null | awk -v k="$kind" '$1 == k')" ] || printf '\n_none_\n'
     done
     printf '\n## Memory\n\n'
-    for f in POLICY.md INDEX.md DOMAIN.md; do
-      [ -f "$store/memory/$f" ] && printf -- '- [%s](memory/%s)\n' "$f" "$f"
-    done
+    for f in POLICY.md INDEX.md DOMAIN.md; do [ -f "$store/memory/$f" ] && printf -- '- [%s](memory/%s)\n' "$f" "$f"; done
     [ -d "$store/memory/lessons" ] && printf -- '- [lessons/](memory/lessons/)\n'
     [ -f "$store/config.md" ] && printf -- '- [config.md](config.md)\n'
     printf ''
-  } > "$page.kb-tmp.$$" 2>/dev/null || {
-    rm -f "$page.kb-tmp.$$"; echo "FAIL: cannot write $page" >&2; return 2; }
+  } > "$page.kb-tmp.$$" 2>/dev/null || { rm -f "$page.kb-tmp.$$"; echo "FAIL: cannot write $page" >&2; return 2; }
   mv "$page.kb-tmp.$$" "$page" || { rm -f "$page.kb-tmp.$$"; echo "FAIL: cannot write $page" >&2; return 2; }
-  echo "contents page: $page${style:+ ($style)}"
+  echo "contents page: $page ($style)"
 }
 
 # --- list --------------------------------------------------------------------
 kb_list() { # <store>
-  local store="$1" n=0
-  printf '%s\n' "$(kb_label "$store")"
+  local n=0 kind slug dir
+  printf '%s\n' "$(kb_label "$1")"
   while read -r kind slug dir; do
     [ -n "${slug:-}" ] || continue
-    printf '  %-9s %-28s %s\n' "$kind" "$slug" "$(kb_state "$dir")"
-    n=$((n + 1))
+    printf '  %-9s %-28s %s\n' "$kind" "$slug" "$(kb_state "$dir")"; n=$((n + 1))
   done <<EOF
-$(kb_features "$store" 2>/dev/null)
+$(kb_features "$1" 2>/dev/null)
 EOF
   [ "$n" -gt 0 ] || printf '  (no features)\n'
-  return 0
 }
 
 # --- show --------------------------------------------------------------------
@@ -389,73 +347,50 @@ kb_show() { # <store> <slug> → 0 when found
     printf '%s/%s/%s — %s\n' "$(kb_label "$store")" "$kind" "$slug" "$(kb_state "$dir")"
     v=$(kb_title "$dir"); [ -n "$v" ] && printf '  %s\n' "$v"
     meta=""
-    for v in Track Type Date Tags "Requested by" Refs; do
-      f=$(kb_real "$(kb_field "$dir/intent.md" "$v" 2>/dev/null || true)")
-      [ -n "$f" ] && meta="$meta · $v: $f"
-    done
+    for v in Track Type Date "Requested by" Refs; do f=$(kb_get "$dir/intent.md" "$v"); [ -n "$f" ] && meta="$meta · $v: $f"; done
+    f=$(kb_tags "$dir"); [ -n "$f" ] && meta="$meta · Tags: $f"
     [ -n "$meta" ] && printf '  %s\n' "${meta# · }"
     body=$(kb_summary "$dir")
-    if [ -n "$body" ]; then
-      printf '  Summary:\n'
-      printf '%s\n' "$body" | kb_print_bounded "$SUMMARY_MAX" "    " "$kind/$slug/$(kb_summary_where "$dir")"
-    fi
-    v=$(kb_real "$(kb_field "$dir/delivery.md" Target 2>/dev/null || true)")
+    [ -n "$body" ] && { printf '  Summary:\n'; printf '%s\n' "$body" | kb_print_bounded "$SUMMARY_MAX" "    " "$kind/$slug/summary.md"; }
+    v=$(kb_get "$dir/delivery.md" Target)
     if [ -n "$v" ]; then
       printf '  Delivered: %s' "$v"
-      f=$(kb_real "$(kb_field "$dir/delivery.md" Confirmed 2>/dev/null || true)"); [ -n "$f" ] && printf ' (confirmed: %s)' "$f"
-      f=$(kb_real "$(kb_field "$dir/delivery.md" Handoff 2>/dev/null || true)"); [ -n "$f" ] && printf ' · handoff: %s' "$f"
+      f=$(kb_get "$dir/delivery.md" Confirmed); [ -n "$f" ] && printf ' (confirmed: %s)' "$f"
+      f=$(kb_get "$dir/delivery.md" Handoff); [ -n "$f" ] && printf ' · handoff: %s' "$f"
       printf '\n'
     fi
-    if [ -f "$dir/CLOSED" ]; then
-      printf '  Closed: %s' "$(awk '/^reason: /{sub(/^reason: /,""); sub(/[ \t\r]*$/,""); print; exit}' "$dir/CLOSED")"
-      f=$(kb_closed_at "$dir"); [ -n "$f" ] && printf ' (%s)' "$f"
-      printf '\n'
-    fi
-    if [ -f "$dir/harvest.md" ]; then
-      body=$(kb_body "$dir/harvest.md")
-      if [ -n "$body" ]; then
-        printf '  Not merged into memory/ yet (harvest.md):\n'
-        printf '%s\n' "$body" | kb_print_bounded "$HARVEST_MAX" "    " "$kind/$slug/harvest.md"
-      fi
-    fi
+    v=$(kb_closed "$dir" reason)
+    [ -n "$v" ] && { printf '  Closed: %s' "$v"; f=$(kb_closed "$dir" closed_at); [ -n "$f" ] && printf ' (%s)' "$f"; printf '\n'; }
+    body=$(kb_body "$dir/harvest.md")
+    [ -n "$body" ] && { printf '  Not merged into memory/ yet (harvest.md):\n'; printf '%s\n' "$body" | kb_print_bounded "$HARVEST_MAX" "    " "$kind/$slug/harvest.md"; }
     v=$(kb_lessons "$store" "$slug")
     if [ -n "$v" ]; then
       printf '  Lessons:\n'
-      printf '%s\n' "$v" | while read -r f; do
-        printf '    %s — memory/lessons/%s\n' "$(kb_h1 "$f" "Lesson: ")" "$(basename "$f")"
-      done
+      printf '%s\n' "$v" | while read -r f; do printf '    %s — memory/lessons/%s\n' "$(kb_h1 "$f" "Lesson: ")" "$(basename "$f")"; done
     fi
     printf '  Documents:\n'
-    for doc in $KB_DOCS harvest.md; do
-      [ -f "$dir/$doc" ] && printf '    %s/%s/%s\n' "$kind" "$slug" "$doc"
-    done
+    for doc in $KB_DOCS harvest.md; do [ -f "$dir/$doc" ] && printf '    %s/%s/%s\n' "$kind" "$slug" "$doc"; done
   done
   return $found
 }
 
 # --- harvest -----------------------------------------------------------------
 # Which open features hold knowledge that is not in memory/ yet, and for how
-# long nobody has touched them. This is the trigger the close-only merge
-# lacked: rule 4 makes close the merge moment, and a feature that never closes
-# never merges. A feature idle past --stale may be merged WITHOUT closing (the
-# same procedure, one at a time, in the owning checkout — AGENTS.md rule 4);
-# this command only reports, it writes nothing.
+# long nobody has touched them — the trigger the close-only merge lacked. A
+# feature idle past --stale may be merged WITHOUT closing (same procedure, one
+# at a time, in the owning checkout — AGENTS.md rule 4). Reports only.
 kb_harvest() { # <store> <stale-days> → prints; echoes "<found> <stale>" on fd 3
-  local store="$1" stale="$2" kind slug dir n idle flag found=0 nstale=0
-  printf '%s\n' "$(kb_label "$store")"
-  while read -r kind slug dir; do
+  local slug n dir idle flag found=0 nstale=0
+  printf '%s\n' "$(kb_label "$1")"
+  while IFS="$SEP" read -r slug n dir; do
     [ -n "${slug:-}" ] || continue
-    [ -f "$dir/harvest.md" ] || continue
-    n=$(kb_body "$dir/harvest.md" | kb_count_lines)
-    [ "$n" -gt 0 ] || continue
-    found=$((found + 1))
-    idle=$(kb_idle_days "$dir")
+    found=$((found + 1)); idle=$(kb_idle_days "$dir")
     if [ -z "$idle" ]; then flag="idle: unknown"
-    elif [ "$idle" -ge "$stale" ]; then flag="STALE — idle ${idle}d (≥ ${stale}d): merge without closing"; nstale=$((nstale + 1))
+    elif [ "$idle" -ge "$2" ]; then flag="STALE — idle ${idle}d (≥ $2d): merge without closing"; nstale=$((nstale + 1))
     else flag="active — idle ${idle}d"; fi
     printf '  %-32s %3s line(s)   %s\n' "$slug" "$n" "$flag"
   done <<EOF
-$(kb_features "$store" 2>/dev/null | awk '$1 == "work"')
+$(kb_unmerged "$1")
 EOF
   [ "$found" -gt 0 ] || printf '  (no unmerged harvest)\n'
   echo "$found $nstale" >&3
@@ -466,10 +401,10 @@ EOF
 # stray `.` or `*` must not silently widen the search. `-e` keeps a query that
 # starts with `-` a query.
 kb_searchable() { # <store> → readable record paths, one per line
-  local store="$1" d
+  local d
   for d in work archive memory; do
-    [ -d "$store/$d" ] || continue
-    find "$store/$d" -type f \( -name '*.md' -o -name 'CLOSED' \) 2>/dev/null
+    [ -d "$1/$d" ] || continue
+    find "$1/$d" -type f \( -name '*.md' -o -name 'CLOSED' \) 2>/dev/null
   done | awk '
     $0 ~ /\/scratch\// { next }
     $0 ~ /\/approvals\// { next }
@@ -479,7 +414,7 @@ kb_searchable() { # <store> → readable record paths, one per line
   ' | LC_ALL=C sort
 }
 kb_search() { # <store> <query> <limit> <shown-so-far> → prints, echoes the new count on fd 3
-  local store="$1" q="$2" limit="$3" shown="$4" label f rel hits
+  local store="$1" q="$2" limit="$3" shown="$4" label f rel hits h
   label=$(kb_label "$store")
   while IFS= read -r f; do
     [ -n "$f" ] || continue
@@ -505,7 +440,7 @@ cmd="$1"; shift
 # One positional argument at most (a slug, or the literal to search for). Flags
 # may follow it. A query that starts with `-` goes after `--`; an unknown option
 # is an error, never a silently ignored word.
-store=""; area=""; limit=50; stale=30; style=""; arg=""; have_arg=0; endopts=0
+store=""; area=""; limit=50; stale=30; arg=""; have_arg=0; endopts=0
 while [ $# -gt 0 ]; do
   if [ "$endopts" -eq 0 ]; then
     case "$1" in
@@ -518,7 +453,6 @@ while [ $# -gt 0 ]; do
       --limit=*) limit="${1#--limit=}"; shift; continue;;
       --stale) [ $# -ge 2 ] || usage; stale="$2"; shift 2; continue;;
       --stale=*) stale="${1#--stale=}"; shift; continue;;
-      --obsidian) style=obsidian; shift; continue;;
       -h|--help) usage;;
       -?*) echo "FAIL: unknown option '$1' (a query starting with '-' goes after --)" >&2; exit 2;;
     esac
@@ -530,7 +464,6 @@ if [ "$have_arg" -eq 1 ]; then set -- "$arg"; else set --; fi
 case "$limit" in (''|*[!0-9]*) echo "FAIL: --limit takes a number" >&2; exit 2;; esac
 [ "$limit" -gt 0 ] || { echo "FAIL: --limit must be > 0" >&2; exit 2; }
 case "$stale" in (''|*[!0-9]*) echo "FAIL: --stale takes a number of days" >&2; exit 2;; esac
-[ "$style" = obsidian ] && [ "$cmd" != index ] && { echo "FAIL: --obsidian applies to index only" >&2; exit 2; }
 
 stores=$(kb_stores "$store" "$area") || exit 2
 
@@ -551,7 +484,7 @@ case "$cmd" in
       . "$kb_kit/gates/_common.sh"
       sdlc_store_owner_ok || exit 2
     fi
-    kb_index "$stores" "$(kb_index_style "$stores" "$style")" || exit $?;;
+    kb_index "$stores" || exit $?;;
   list)
     while IFS= read -r s; do [ -n "$s" ] && kb_list "$s"; done <<EOF
 $stores