agent-knowledge-cli 0.1.2__py3-none-any.whl

agent_knowledge/assets/rules/shared-memory.mdc

@@ -0,0 +1,102 @@
+---
+description: Keep the shared project memory file up to date across all AI agents.
+alwaysApply: true
+---
+
+# Shared Memory
+
+This project stores persistent memory at `agent-knowledge/Memory/MEMORY.md`.
+The repo-local `./agent-knowledge` path is the working entrypoint and should point to the real dedicated knowledge folder.
+If Cursor project memory is used, `~/.cursor/projects/<project-id>/memory/` should point to `./agent-knowledge/Memory/` so all agents read and write the same curated files.
+
+When the symlink is missing or broken, create it:
+```bash
+ln -s <workspace>/agent-knowledge/Memory ~/.cursor/projects/<project-id>/memory
+```
+
+## Tree structure
+
+Memory is organized as a **tree** using the same-name branch convention.
+Agents load only the branches relevant to their current task.
+
+```text
+agent-knowledge/
+  Memory/
+    MEMORY.md               <- root curated-memory index -- always loaded, max ~200 lines
+    <topic>.md              <- flat branch note (no subtopics)
+    <topic>/
+      <topic>.md            <- branch entry note (same name as folder)
+      <subtopic>.md         <- leaf note beside the entry
+    decisions/
+      decisions.md          <- decision log
+  Evidence/
+    raw/
+    imports/
+  Sessions/
+```
+
+### Reading the tree
+
+1. `Memory/MEMORY.md` is always loaded automatically. It is a concise index only -- no deep detail.
+2. At session start, identify which branch(es) your task touches from the Branches section.
+3. Read the relevant branch entry notes before starting work.
+4. If the branch has subtopic files needed for your task, read those too.
+5. Do not read branches unrelated to your task -- keep context lean.
+
+### Writing to the tree
+
+- **Memory/MEMORY.md**: short branch summaries with relative links. Keep it under 200 lines.
+- **Branch entry note** (`<topic>.md` or `<topic>/<topic>.md`): stable facts for one focused domain.
+- **Subtopic note** (`<topic>/<subtopic>.md`): created only when a branch note grows beyond ~150 lines.
+- When adding a subtopic, replace the inline detail in the entry note with a link.
+- **Each note must stay under ~150 lines.** Split if bigger.
+- **Link related notes** with relative markdown links (e.g., `See [perception](perception/perception.md)`).
+- **One branch = one functional domain.** Do NOT lump unrelated subsystems into one file.
+
+### Example branch link in Memory/MEMORY.md
+
+```markdown
+## Branches
+
+- [Perception](perception/perception.md) -- camera pipeline, YOLO detection, depth fusion
+- [Stack](stack.md) -- Python 3.10, ROS2, colcon
+```
+
+### Example branch entry note
+
+```markdown
+# Perception
+
+## Purpose
+Camera data acquisition, object detection, and depth fusion pipeline.
+
+## Current State
+- YOLO v8 for detection, custom depth fusion node
+- 30 Hz pipeline on Jetson Orin
+
+## Decisions
+- [2025-01-20-yolo-v8.md](decisions/2025-01-20-yolo-v8.md) -- chose YOLO v8 for latency
+```
+
+## When to update
+
+Update the tree when you learn:
+- A new architectural decision or pattern
+- A critical "gotcha" (DB state, build requirement, PATH issue, etc.)
+- A customer-facing fact that changed
+- A lesson from a mistake that should not be repeated
+
+Do NOT save: in-progress task state, speculative plans, or anything already in git history.
+
+## Format
+
+Lead with the fact. For feedback/lessons: add a **Why:** line and a **How to apply:** line so future agents understand the context, not just the rule.
+
+## Extensions
+
+- **Bootstrap**: if `agent-knowledge/Memory/MEMORY.md` is missing, apply the `memory-bootstrap` rule before any other work.
+- **Writeback**: after meaningful state changes, apply the `memory-writeback` rule.
+- **Backfill**: when memory is sparse and the repo has history, apply the `history-backfill` rule.
+- **Decisions**: record architecture decisions with the `decision-recording` skill.
+- **Compaction**: when files grow large, apply the `memory-compaction` skill.
+- **Evidence**: evidence lives in `agent-knowledge/Evidence/` -- never mix with curated memory.

agent_knowledge/assets/rules/workflow-orchestration.mdc

@@ -0,0 +1,93 @@
+---
+description: Workflow orchestration, task management, and core engineering principles for AI-assisted development.
+alwaysApply: true
+---
+
+# Workflow Orchestration
+
+## 1. Plan First (Default)
+
+- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
+- If something goes sideways, STOP and re-plan immediately - do not keep pushing
+- Use plan mode for verification steps, not just building
+- Write detailed specs upfront to reduce ambiguity
+
+## 2. Subagent Strategy
+
+- Use subagents liberally to keep the main context window clean
+- Offload research, exploration, and parallel analysis to subagents
+- For complex problems, throw more compute at it via subagents
+- One task per subagent for focused execution
+
+## 3. Self-Improvement Loop
+
+- After ANY correction from the user: update `tasks/lessons.md` with the pattern
+- Write rules for yourself that prevent the same mistake
+- Ruthlessly iterate on these lessons until mistake rate drops
+- Review lessons at session start for relevant project
+
+## 4. Verification Before Done
+
+- Never mark a task complete without proving it works
+- Diff behavior between main and your changes when relevant
+- Ask yourself: "Would a staff engineer approve this?"
+- Run tests, check logs, demonstrate correctness
+
+## 5. Demand Elegance (Balanced)
+
+- For non-trivial changes: pause and ask "is there a more elegant way?"
+- If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+- Skip this for simple, obvious fixes - do not over-engineer
+- Challenge your own work before presenting it
+
+## 6. Autonomous Bug Fixing
+
+- When given a bug report: just fix it. Do not ask for hand-holding
+- Point at logs, errors, failing tests - then resolve them
+- Zero context switching required from the user
+- Go fix failing CI tests without being told how
+
+## Task Management
+
+1. **Plan First**: Write plan to `tasks/todo.md` with checkable items
+2. **Verify Plan**: Check in before starting implementation
+3. **Track Progress**: Mark items complete as you go
+4. **Explain Changes**: High-level summary at each step
+5. **Document Results**: Add review section to `tasks/todo.md`
+6. **Capture Lessons**: Update `tasks/lessons.md` after corrections
+
+## Core Principles
+
+- **Simplicity First**: Make every change as simple as possible. Impact minimal code.
+- **No Laziness**: Find root causes. No temporary fixes. Senior developer standards.
+- **Minimal Impact**: Changes should only touch what is necessary. Avoid introducing bugs.
+
+## Memory Flow
+
+Session lifecycle includes memory at start and end:
+
+```
+session start
+  ├─ check memory-bootstrap rule (bootstrap if Memory/MEMORY.md missing or generic)
+  ├─ read agent-knowledge/Memory/MEMORY.md and relevant branch notes
+  └─ read session-management skill
+
+plan → execute → verify
+  └─ update session file at milestones
+
+session end
+  ├─ evaluate writeback: did this session produce durable knowledge?
+  ├─ if yes: apply memory-writeback rule (branch notes + decisions/ as needed)
+  └─ if no: state "Memory writeback: none needed."
+```
+
+For new or inherited projects, insert **history backfill** after bootstrap:
+```
+bootstrap → import-agent-history.sh → history-backfill skill → steady-state
+```
+
+The required loop is:
+1. Plan the work.
+2. Execute the change.
+3. Verify behavior.
+4. Write back durable project understanding when needed.

agent_knowledge/assets/rules-global/action-first.mdc

@@ -0,0 +1,26 @@
+---
+description: Think deeply, act decisively, speak briefly - maximum intelligence with minimum verbal output
+alwaysApply: true
+---
+
+# Action-First Principle
+
+THINK DEEPLY. ACT DECISIVELY. SPEAK BRIEFLY.
+
+## Maximize
+
+- Thinking depth, reasoning, and cognitive effort
+- Code quality, correctness, and solution completeness
+- Strategic planning and risk assessment
+
+## Minimize
+
+- Verbal responses and filler text
+- Explanations, lists, and summaries (unless explicitly requested)
+- Redundant descriptions and unnecessary elaboration
+
+## Behavior
+
+- Execute over explain -- let code and results speak
+- Ask before irreversible or destructive actions
+- Only provide detailed explanations when explicitly requested

agent_knowledge/assets/rules-global/no-icons-emojis.mdc

@@ -0,0 +1,16 @@
+---
+description: Prohibit use of icons and emojis in code, logs, and LLM output
+alwaysApply: true
+---
+
+# No Icons or Emojis
+
+Icons and emojis are NOT allowed in:
+
+- Code
+- Logs
+- Skills
+- Commands
+- LLM output
+
+Use plain text for all communication and code and files output.

agent_knowledge/assets/rules-global/no-unsolicited-docs.mdc

@@ -0,0 +1,20 @@
+---
+description: Never create documentation files unless explicitly requested
+alwaysApply: true
+---
+
+# No Unsolicited Documentation
+
+NEVER create .md, README, or documentation files unless the user explicitly requests it.
+
+This includes:
+
+- README.md
+- CHANGELOG.md
+- CONTRIBUTING.md
+- docs/ files
+- Any explanatory markdown files
+
+**Exception:** Internal workspace files (memory, session, topic files managed by skills) are not documentation -- create and update them freely.
+
+If documentation is genuinely needed for a task, ask first.

agent_knowledge/assets/scripts/bootstrap-memory-tree.sh

@@ -0,0 +1,389 @@
+#!/bin/bash
+#
+# Bootstrap a minimal project knowledge tree under ./agent-knowledge/.
+#
+# Usage:
+#   ./bootstrap-memory-tree.sh [project-dir] [profile]
+#   ./bootstrap-memory-tree.sh .                 # auto-detect profile hint
+#   ./bootstrap-memory-tree.sh /path/to/project robotics
+#
+# Profile hints: web-app | robotics | ml-platform | hybrid
+#
+# What it does:
+#   1. Detects a profile hint from manifests, docs, configs, tests, and workflows
+#   2. Creates the minimal knowledge tree: Memory/, Evidence/, Sessions/, Outputs/, Dashboards/
+#   3. Creates Memory/MEMORY.md and Memory/decisions/decisions.md
+#   4. Stores profile hint in STATUS.md (the agent infers the actual ontology)
+#
+# What it does NOT do:
+#   - Create per-area branch notes (the agent does this after inspecting the repo)
+#   - Define the ontology tree (the agent infers it from the project)
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+AGENTS_RULES_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+# shellcheck source=/dev/null
+. "$SCRIPT_DIR/lib/knowledge-common.sh"
+TEMPLATES_DIR="$AGENTS_RULES_DIR/templates/memory"
+PROJECT_TEMPLATE_DIR="$AGENTS_RULES_DIR/templates/project/agent-knowledge"
+DASHBOARD_TEMPLATES_DIR="$AGENTS_RULES_DIR/templates/dashboards"
+STATUS_TEMPLATE="$AGENTS_RULES_DIR/templates/project/agent-knowledge/STATUS.md"
+
+TARGET_PROJECT_ARG="."
+PROFILE=""
+POSITIONAL=()
+CHANGES=()
+
+while [ "$#" -gt 0 ]; do
+    if kc_parse_common_flag "$@" ; then
+        shift
+        continue
+    fi
+    flag_status=$?
+    if [ "$flag_status" -eq 2 ]; then
+        shift 2
+        continue
+    fi
+
+    case "$1" in
+        --project)
+            TARGET_PROJECT_ARG="${2:-.}"
+            shift 2
+            ;;
+        --profile)
+            PROFILE="${2:-}"
+            shift 2
+            ;;
+        *)
+            POSITIONAL+=("$1")
+            shift
+            ;;
+    esac
+done
+
+if [ "$SHOW_HELP" -eq 1 ]; then
+    cat <<'EOF'
+Usage:
+  scripts/bootstrap-memory-tree.sh [project-dir] [profile]
+  scripts/bootstrap-memory-tree.sh --project <dir> [--profile <profile>] [--dry-run] [--json] [--summary-file <file>] [--force]
+EOF
+    exit 0
+fi
+
+if [ ${#POSITIONAL[@]} -ge 1 ]; then
+    TARGET_PROJECT_ARG="${POSITIONAL[0]}"
+fi
+if [ ${#POSITIONAL[@]} -ge 2 ] && [ -z "$PROFILE" ]; then
+    PROFILE="${POSITIONAL[1]}"
+fi
+
+kc_load_project_context "$TARGET_PROJECT_ARG"
+DATE="$(kc_today)"
+
+[ -L "$KNOWLEDGE_POINTER_PATH" ] || kc_fail "Bootstrap requires ./agent-knowledge to already be a pointer to the external knowledge folder. Run: agent-knowledge init"
+
+# ---------------------------------------------------------------------------
+# Profile detection (hint only -- does not drive file creation)
+# ---------------------------------------------------------------------------
+
+detect_profile() {
+    local dir="$1"
+    local docs_text=""
+    local has_workspace="no"
+    local manifest_total=0
+
+    local manifest_paths=""
+    manifest_paths="$(list_existing_paths "$dir" \
+        package.json pnpm-workspace.yaml nx.json turbo.json yarn.lock pnpm-lock.yaml package-lock.json \
+        pyproject.toml requirements.txt setup.py setup.cfg Pipfile poetry.lock \
+        Cargo.toml Cargo.lock go.mod go.sum CMakeLists.txt Makefile package.xml)"
+
+    manifest_total="$(printf "%s\n" "$manifest_paths" | awk 'NF{count++} END{print count+0}')"
+
+    if [ -f "$dir/pnpm-workspace.yaml" ] || [ -f "$dir/nx.json" ] || [ -f "$dir/turbo.json" ] || \
+       [ -d "$dir/packages" ] || [ -d "$dir/services" ] || [ -d "$dir/apps" ] || \
+       ( [ -f "$dir/package.json" ] && grep -q '"workspaces"' "$dir/package.json" 2>/dev/null ); then
+        has_workspace="yes"
+    fi
+
+    docs_text="$(cat "$dir/README.md" "$dir/docs/README.md" "$dir/AGENTS.md" "$dir/CLAUDE.md" 2>/dev/null || true)"
+
+    if [ -f "$dir/package.xml" ] || [ -f "$dir/CMakeLists.txt" ] || [ -d "$dir/urdf" ] || [ -d "$dir/launch" ] || \
+       printf "%s" "$docs_text" | grep -Eiq 'ros2|ros |gazebo|rviz|urdf|moveit'; then
+        echo "robotics"
+        return
+    fi
+
+    if { [ -f "$dir/pyproject.toml" ] || [ -f "$dir/requirements.txt" ]; } && \
+       { [ -d "$dir/notebooks" ] || [ -d "$dir/models" ] || [ -d "$dir/data" ] || \
+         grep -Eiq 'torch|tensorflow|jax|sklearn|transformers|mlflow|wandb|ray' "$dir/requirements.txt" "$dir/pyproject.toml" 2>/dev/null || \
+         printf "%s" "$docs_text" | grep -Eiq 'training|inference|model registry|feature store'; }; then
+        echo "ml-platform"
+        return
+    fi
+
+    if [ "$has_workspace" = "yes" ] || [ "$manifest_total" -ge 3 ]; then
+        echo "hybrid"
+        return
+    fi
+
+    if [ -f "$dir/package.json" ] && \
+       grep -qE '"react"|"next"|"vue"|"svelte"|"angular"|"nuxt"|"vite"' "$dir/package.json" 2>/dev/null; then
+        echo "web-app"
+        return
+    fi
+
+    echo "hybrid"
+}
+
+relative_path() {
+    sed "s|$TARGET_PROJECT/||" | sed "s|^$TARGET_PROJECT$|.|"
+}
+
+list_existing_paths() {
+    local base="$1"
+    shift
+    local path=""
+
+    for path in "$@"; do
+        if [ -e "$base/$path" ]; then
+            printf "%s\n" "$path"
+        fi
+    done
+}
+
+render_text_template() {
+    local src="$1"
+    local dst="$2"
+    local current_state_lines="${3:-}"
+    local recent_change_lines="${4:-}"
+    local decision_lines="${5:-}"
+    local open_question_lines="${6:-}"
+    local branch_lines="${7:-}"
+    local tmp_file
+
+    tmp_file="$(mktemp)"
+
+    TEMPLATE_PROJECT_NAME="$PROJECT_NAME" \
+    TEMPLATE_DATE="$DATE" \
+    TEMPLATE_CURRENT_STATE_LINES="$current_state_lines" \
+    TEMPLATE_RECENT_CHANGE_LINES="$recent_change_lines" \
+    TEMPLATE_DECISION_LINES="$decision_lines" \
+    TEMPLATE_OPEN_QUESTION_LINES="$open_question_lines" \
+    TEMPLATE_BRANCH_LINES="$branch_lines" \
+    awk '
+        BEGIN {
+            project = ENVIRON["TEMPLATE_PROJECT_NAME"]
+            date = ENVIRON["TEMPLATE_DATE"]
+            current_state_lines = ENVIRON["TEMPLATE_CURRENT_STATE_LINES"]
+            recent_change_lines = ENVIRON["TEMPLATE_RECENT_CHANGE_LINES"]
+            decision_lines = ENVIRON["TEMPLATE_DECISION_LINES"]
+            open_question_lines = ENVIRON["TEMPLATE_OPEN_QUESTION_LINES"]
+            branch_lines = ENVIRON["TEMPLATE_BRANCH_LINES"]
+        }
+        {
+            gsub(/<project-name>/, project)
+            gsub(/<date>/, date)
+
+            if ($0 == "<current-state-lines>") { print current_state_lines; next }
+            if ($0 == "<recent-change-lines>") { print recent_change_lines; next }
+            if ($0 == "<decision-lines>") { print decision_lines; next }
+            if ($0 == "<open-question-lines>") { print open_question_lines; next }
+            if ($0 == "<branch-lines>") { print branch_lines; next }
+
+            print
+        }' "$src" > "$tmp_file"
+
+    kc_apply_temp_file "$tmp_file" "$dst" "$dst"
+}
+
+copy_static_template() {
+    local src="$1"
+    local dst="$2"
+    local label="$3"
+
+    render_text_template "$src" "$dst"
+    case "$KC_LAST_ACTION" in
+        created|updated|would-create|would-update)
+            CHANGES+=("$label")
+            ;;
+    esac
+}
+
+render_dashboard_note() {
+    local src="$1"
+    local dst="$2"
+    local label="$3"
+
+    render_text_template "$src" "$dst"
+    case "$KC_LAST_ACTION" in
+        created|updated|would-create|would-update)
+            CHANGES+=("$label")
+            ;;
+    esac
+}
+
+# ---------------------------------------------------------------------------
+# Detect or accept profile hint
+# ---------------------------------------------------------------------------
+
+if [ -z "$PROFILE" ]; then
+    PROFILE="$(detect_profile "$TARGET_PROJECT")"
+    kc_log "Auto-detected profile hint: $PROFILE"
+fi
+
+PROFILE_FILE="$TEMPLATES_DIR/profile.$PROFILE.yaml"
+if [ ! -f "$PROFILE_FILE" ]; then
+    kc_log "Warning: Unknown profile hint '$PROFILE'; defaulting to hybrid"
+    PROFILE="hybrid"
+    PROFILE_FILE="$TEMPLATES_DIR/profile.$PROFILE.yaml"
+fi
+
+if [ -f "$AGENT_PROJECT_FILE" ]; then
+    tmp_file="$(mktemp)"
+    sed "s/^\([[:space:]]*profile_hint:[[:space:]]*\).*/\1$PROFILE/" "$AGENT_PROJECT_FILE" > "$tmp_file"
+    # Also handle legacy 'profile:' key for compat
+    sed -i "s/^\([[:space:]]*profile:[[:space:]]*\).*/\1$PROFILE/" "$tmp_file" 2>/dev/null || true
+    kc_apply_temp_file "$tmp_file" "$AGENT_PROJECT_FILE" ".agent-project.yaml"
+    case "$KC_LAST_ACTION" in
+        created|updated|would-create|would-update)
+            CHANGES+=(".agent-project.yaml")
+            ;;
+    esac
+fi
+
+kc_log "Bootstrapping memory tree: $PROJECT_NAME (profile hint: $PROFILE)"
+kc_log ""
+
+# ---------------------------------------------------------------------------
+# Create minimal directory scaffold
+# ---------------------------------------------------------------------------
+
+for dir in \
+    "$KNOWLEDGE_DIR" \
+    "$MEMORY_DIR" \
+    "$DECISIONS_DIR" \
+    "$EVIDENCE_DIR" \
+    "$EVIDENCE_RAW_DIR" \
+    "$EVIDENCE_IMPORTS_DIR" \
+    "$SESSIONS_DIR" \
+    "$OUTPUTS_DIR" \
+    "$DASHBOARDS_DIR" \
+    "$LOCAL_TEMPLATES_DIR" \
+    "$OBSIDIAN_DIR"; do
+    kc_ensure_dir "$dir" "$dir"
+done
+
+# ---------------------------------------------------------------------------
+# Copy static templates (no INDEX.md -- uses STATUS.md + MEMORY.md as entries)
+# ---------------------------------------------------------------------------
+
+copy_static_template "$PROJECT_TEMPLATE_DIR/Evidence/README.md" "$EVIDENCE_DIR/README.md" "agent-knowledge/Evidence/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Evidence/raw/README.md" "$EVIDENCE_RAW_DIR/README.md" "agent-knowledge/Evidence/raw/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Evidence/imports/README.md" "$EVIDENCE_IMPORTS_DIR/README.md" "agent-knowledge/Evidence/imports/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Sessions/README.md" "$SESSIONS_DIR/README.md" "agent-knowledge/Sessions/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Outputs/README.md" "$OUTPUTS_DIR/README.md" "agent-knowledge/Outputs/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Templates/README.md" "$LOCAL_TEMPLATES_DIR/README.md" "agent-knowledge/Templates/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/.obsidian/README.md" "$OBSIDIAN_DIR/README.md" "agent-knowledge/.obsidian/README.md"
+copy_static_template "$PROJECT_TEMPLATE_DIR/Memory/decisions/decisions.md" "$DECISIONS_DIR/decisions.md" "agent-knowledge/Memory/decisions/decisions.md"
+
+kc_copy_file "$PROJECT_TEMPLATE_DIR/.obsidian/core-plugins.json" "$OBSIDIAN_DIR/core-plugins.json" "agent-knowledge/.obsidian/core-plugins.json"
+case "$KC_LAST_ACTION" in
+    created|updated|would-create|would-update)
+        CHANGES+=("agent-knowledge/.obsidian/core-plugins.json")
+        ;;
+esac
+kc_copy_file "$PROJECT_TEMPLATE_DIR/.obsidian/app.json" "$OBSIDIAN_DIR/app.json" "agent-knowledge/.obsidian/app.json"
+case "$KC_LAST_ACTION" in
+    created|updated|would-create|would-update)
+        CHANGES+=("agent-knowledge/.obsidian/app.json")
+        ;;
+esac
+
+# ---------------------------------------------------------------------------
+# STATUS.md
+# ---------------------------------------------------------------------------
+
+kc_replace_in_template \
+    "$STATUS_TEMPLATE" \
+    "$STATUS_FILE" \
+    "agent-knowledge/STATUS.md" \
+    "<project-name>" "$PROJECT_NAME" \
+    "<profile-type>" "$PROFILE" \
+    "<absolute-path-to-dedicated-knowledge-folder>" "$KNOWLEDGE_REAL_DIR"
+case "$KC_LAST_ACTION" in
+    created|updated|would-create|would-update)
+        CHANGES+=("agent-knowledge/STATUS.md")
+        ;;
+esac
+
+# ---------------------------------------------------------------------------
+# Dashboard stubs
+# ---------------------------------------------------------------------------
+
+render_dashboard_note \
+    "$DASHBOARD_TEMPLATES_DIR/project-overview.template.md" \
+    "$DASHBOARDS_DIR/project-overview.md" \
+    "agent-knowledge/Dashboards/project-overview.md"
+render_dashboard_note \
+    "$DASHBOARD_TEMPLATES_DIR/session-rollup.template.md" \
+    "$DASHBOARDS_DIR/session-rollup.md" \
+    "agent-knowledge/Dashboards/session-rollup.md"
+
+# ---------------------------------------------------------------------------
+# Memory/MEMORY.md (minimal -- agent infers branches later)
+# ---------------------------------------------------------------------------
+
+render_text_template \
+    "$TEMPLATES_DIR/MEMORY.root.template.md" \
+    "$MEMORY_ROOT" \
+    "$(printf -- '- Profile hint: `%s`. The agent should inspect the repo to infer the real ontology.\n- Memory has been initialized but branches have not been created yet.' "$PROFILE")" \
+    "$(printf -- '- %s - Bootstrapped minimal memory root.' "$DATE")" \
+    "$(printf -- '- [decisions/decisions.md](decisions/decisions.md) - Decision log.')" \
+    "$(printf -- '- Which areas of the project should become the first memory branches?\n- Which decisions should be recorded explicitly from existing docs and code?')" \
+    "$(printf -- '- Add branch links here as the agent infers project structure.')"
+case "$KC_LAST_ACTION" in
+    created|updated|would-create|would-update)
+        CHANGES+=("agent-knowledge/Memory/MEMORY.md")
+        ;;
+esac
+
+# ---------------------------------------------------------------------------
+# STATUS bookkeeping
+# ---------------------------------------------------------------------------
+
+kc_status_load
+STATUS_PROFILE="$PROFILE"
+STATUS_REAL_PATH="$KNOWLEDGE_REAL_DIR"
+STATUS_POINTER_PATH="$POINTER_DISPLAY"
+if [ "${DRY_RUN:-0}" -eq 0 ] && [ ${#CHANGES[@]} -gt 0 ]; then
+    STATUS_LAST_BOOTSTRAP="$(kc_now_utc)"
+fi
+kc_status_write
+
+# ---------------------------------------------------------------------------
+# JSON summary
+# ---------------------------------------------------------------------------
+
+json_summary="{"
+json_summary="$json_summary\"script\":\"bootstrap-memory-tree\","
+json_summary="$json_summary\"project_root\":\"$(kc_json_escape "$TARGET_PROJECT")\","
+json_summary="$json_summary\"profile_hint\":\"$(kc_json_escape "$PROFILE")\","
+json_summary="$json_summary\"real_knowledge_path\":\"$(kc_json_escape "$KNOWLEDGE_REAL_DIR")\","
+json_summary="$json_summary\"dry_run\":$(kc_json_bool "$DRY_RUN"),"
+json_summary="$json_summary\"changes\":$(kc_json_array "${CHANGES[@]+"${CHANGES[@]}"}")"
+json_summary="$json_summary}"
+kc_write_json_output "$json_summary"
+
+if [ "$JSON_MODE" -ne 1 ]; then
+    kc_log ""
+    kc_log "Memory tree ready for: $PROJECT_NAME"
+    kc_log "Profile hint: $PROFILE"
+    kc_log ""
+    kc_log "Next steps:"
+    kc_log "  1. agent-knowledge import --project $TARGET_PROJECT"
+    kc_log "  2. Agent inspects repo and creates initial branch notes in Memory/"
+    kc_log "  3. agent-knowledge doctor --project $TARGET_PROJECT"
+fi