> ## Documentation Index
> Fetch the complete documentation index at: https://felimet-hub.jmcores.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Appendix C: Glossary

> One-sentence definitions for all terms used in the book, in Traditional Chinese academic usage with English originals retained for quick reference and consistent terminology.

export const GlossaryBrowser = ({lang = "zh", terms = [], categories = []}) => {
  const UI = lang === "en" ? {
    searchPH: "Search terms and definitions...",
    allCats: "All",
    noResults: "No matching terms found.",
    related: "Related",
    enLabel: "EN",
    count: n => n === 1 ? "1 term" : `${n} terms`
  } : {
    searchPH: "搜尋詞條或定義...",
    allCats: "全部",
    noResults: "沒有符合的詞條。",
    related: "相關",
    enLabel: "EN",
    count: n => `${n} 個詞條`
  };
  const ACCENT = "#bf7551";
  const ACCENT_L = "#cf8a68";
  const ACCENT_BG = "rgba(191,117,81,0.08)";
  const ACCENT_BDR = "rgba(191,117,81,0.35)";
  const safeTerms = Array.isArray(terms) ? terms : [];
  const safeCats = Array.isArray(categories) ? categories : [];
  const [query, setQuery] = useState("");
  const [cat, setCat] = useState("__all__");
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const detect = () => setIsDark(document.documentElement.classList.contains("dark"));
    detect();
    const obs = new MutationObserver(detect);
    obs.observe(document.documentElement, {
      attributes: true,
      attributeFilter: ["class"]
    });
    return () => obs.disconnect();
  }, []);
  const q = query.toLowerCase().trim();
  const filtered = safeTerms.filter(t => {
    const matchCat = cat === "__all__" || t.category === cat;
    if (!matchCat) return false;
    if (!q) return true;
    return (t.term || "").toLowerCase().includes(q) || (t.en || "").toLowerCase().includes(q) || (t.definition || "").toLowerCase().includes(q);
  });
  const highlight = text => {
    if (!q || !text) return text;
    const idx = text.toLowerCase().indexOf(q);
    if (idx === -1) return text;
    return <span>
        {text.slice(0, idx)}
        <mark style={{
      background: ACCENT_BG,
      color: ACCENT,
      borderRadius: "2px",
      padding: "0 1px"
    }}>
          {text.slice(idx, idx + q.length)}
        </mark>
        {text.slice(idx + q.length)}
      </span>;
  };
  const css = `
  .gb-root {
    --gb-bg:         #FAF8F3;
    --gb-surface:    rgba(0,0,0,0.025);
    --gb-border:     rgba(0,0,0,0.09);
    --gb-text:       #2b2722;
    --gb-dim:        #6f6a62;
    --gb-faint:      #8a8378;
    --gb-accent:     ${ACCENT};
    --gb-accent-l:   ${ACCENT_L};
    --gb-accent-bg:  ${ACCENT_BG};
    --gb-accent-bdr: ${ACCENT_BDR};
    --gb-card-bg:    #ffffff;
    --gb-input-bg:   #ffffff;
    font-size: 14px;
    border: 1px solid var(--gb-border);
    border-radius: 14px;
    background: var(--gb-bg);
    color: var(--gb-text);
    overflow: hidden;
  }
  .dark .gb-root {
    --gb-bg:         #1b1a18;
    --gb-surface:    rgba(255,255,255,0.03);
    --gb-border:     rgba(255,255,255,0.08);
    --gb-text:       #e7e3da;
    --gb-dim:        #a8a299;
    --gb-faint:      #706b64;
    --gb-accent:     ${ACCENT_L};
    --gb-accent-bg:  rgba(207,138,104,0.09);
    --gb-accent-bdr: rgba(207,138,104,0.35);
    --gb-card-bg:    #242220;
    --gb-input-bg:   #242220;
  }

  /* ── 搜尋列 ── */
  .gb-search-bar {
    padding: 13px 16px 10px;
    border-bottom: 1px solid var(--gb-border);
    background: var(--gb-surface);
    display: flex;
    align-items: center;
    gap: 10px;
  }
  .gb-search-icon {
    flex-shrink: 0;
    color: var(--gb-faint);
  }
  .gb-search-input {
    flex: 1 1 0;
    border: none;
    background: transparent;
    font: inherit;
    font-size: 14px;
    color: var(--gb-text);
    outline: none;
    min-width: 0;
  }
  .gb-search-input::placeholder { color: var(--gb-faint); }
  .gb-count {
    font-size: 12px;
    color: var(--gb-faint);
    white-space: nowrap;
  }
  /* 清除按鈕 */
  .gb-clear-btn {
    flex-shrink: 0;
    background: transparent;
    border: none;
    padding: 2px 5px;
    color: var(--gb-faint);
    font: inherit;
    font-size: 15px;
    cursor: pointer;
    line-height: 1;
    border-radius: 4px;
    transition: color 0.12s;
  }
  .gb-clear-btn:hover { color: var(--gb-accent); }

  /* ── 分類 chip 列 ── */
  .gb-cats {
    display: flex;
    gap: 6px;
    padding: 9px 16px;
    border-bottom: 1px solid var(--gb-border);
    overflow-x: auto;
    scrollbar-width: none;
    -webkit-overflow-scrolling: touch;
  }
  .gb-cats::-webkit-scrollbar { display: none; }
  .gb-cat {
    flex-shrink: 0;
    padding: 4px 11px;
    border-radius: 16px;
    border: 1px solid var(--gb-border);
    background: transparent;
    color: var(--gb-dim);
    font: inherit;
    font-size: 12.5px;
    font-weight: 500;
    cursor: pointer;
    white-space: nowrap;
    transition: border-color 0.13s, background 0.13s, color 0.13s;
  }
  .gb-cat:hover {
    background: var(--gb-surface);
    color: var(--gb-text);
  }
  .gb-cat-on {
    border-color: var(--gb-accent-bdr);
    background: var(--gb-accent-bg);
    color: var(--gb-accent);
    font-weight: 700;
  }

  /* ── 詞條卡片列表 ── */
  .gb-terms {
    padding: 12px 16px;
    display: flex;
    flex-direction: column;
    gap: 8px;
  }
  .gb-empty {
    padding: 24px 16px;
    text-align: center;
    color: var(--gb-faint);
    font-size: 13.5px;
  }

  /* ── 詞條卡 ── */
  .gb-card {
    border: 1px solid var(--gb-border);
    border-radius: 10px;
    background: var(--gb-card-bg);
    overflow: hidden;
  }
  .gb-card-head {
    display: flex;
    align-items: baseline;
    gap: 9px;
    padding: 10px 14px 8px;
    flex-wrap: wrap;
  }
  .gb-term {
    font-size: 14.5px;
    font-weight: 700;
    color: var(--gb-text);
    font-family: "JetBrains Mono", "Fira Code", monospace;
  }
  .gb-en-badge {
    font-size: 10.5px;
    font-weight: 600;
    letter-spacing: 0.04em;
    color: var(--gb-accent);
    background: var(--gb-accent-bg);
    border: 1px solid var(--gb-accent-bdr);
    border-radius: 4px;
    padding: 1px 6px;
    white-space: nowrap;
  }
  .gb-cat-badge {
    font-size: 10px;
    letter-spacing: 0.03em;
    color: var(--gb-faint);
    background: var(--gb-surface);
    border: 1px solid var(--gb-border);
    border-radius: 4px;
    padding: 1px 6px;
    white-space: nowrap;
  }
  .gb-definition {
    padding: 0 14px 10px;
    font-size: 13.5px;
    line-height: 1.6;
    color: var(--gb-dim);
    border-top: 1px dashed var(--gb-border);
    margin-top: 2px;
    padding-top: 9px;
  }
  .gb-related {
    padding: 0 14px 11px;
    display: flex;
    align-items: center;
    gap: 6px;
    flex-wrap: wrap;
  }
  .gb-related-label {
    font-size: 11px;
    font-weight: 600;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    color: var(--gb-faint);
  }
  .gb-related-link {
    font-size: 12.5px;
    color: var(--gb-accent);
    text-decoration: none;
    background: var(--gb-accent-bg);
    border: 1px solid var(--gb-accent-bdr);
    border-radius: 4px;
    padding: 1px 7px;
    transition: background 0.12s;
  }
  .gb-related-link:hover { background: rgba(191,117,81,0.14); }

  /* ── 手機 ── */
  @media (max-width: 600px) {
    .gb-search-bar { padding: 10px 12px 8px; }
    .gb-cats { padding: 8px 12px; }
    .gb-terms { padding: 10px 12px; }
    .gb-card-head { padding: 9px 12px 7px; }
    .gb-definition { padding: 8px 12px; }
    .gb-related { padding: 0 12px 10px; }
  }
  `;
  return <div className="gb-root">
      <style>{css}</style>

      {}
      <div className="gb-search-bar">
        <svg className="gb-search-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
          <circle cx="11" cy="11" r="8" /><line x1="21" y1="21" x2="16.65" y2="16.65" />
        </svg>
        <input type="text" className="gb-search-input" placeholder={UI.searchPH} value={query} onChange={e => setQuery(e.target.value)} aria-label={UI.searchPH} />
        <span className="gb-count">{UI.count(filtered.length)}</span>
        {query && <button type="button" className="gb-clear-btn" onClick={() => setQuery("")}>
            ×
          </button>}
      </div>

      {}
      {safeCats.length > 0 && <div className="gb-cats">
          <button type="button" className={"gb-cat" + (cat === "__all__" ? " gb-cat-on" : "")} onClick={() => setCat("__all__")}>
            {UI.allCats}
          </button>
          {safeCats.map(c => <button key={c.id} type="button" className={"gb-cat" + (cat === c.id ? " gb-cat-on" : "")} onClick={() => setCat(c.id)}>
              {c.label}
            </button>)}
        </div>}

      {}
      <div className="gb-terms">
        {filtered.length === 0 ? <div className="gb-empty">{UI.noResults}</div> : filtered.map(t => {
    const catObj = safeCats.find(c => c.id === t.category);
    return <div key={t.id} className="gb-card" id={t.id}>
                <div className="gb-card-head">
                  <span className="gb-term">{highlight(t.term)}</span>
                  {t.en && t.en !== t.term && <span className="gb-en-badge">{UI.enLabel} {highlight(t.en)}</span>}
                  {catObj && <span className="gb-cat-badge">{catObj.label}</span>}
                </div>
                {t.definition && <div className="gb-definition">{highlight(t.definition)}</div>}
                {t.related && t.related.length > 0 && <div className="gb-related">
                    <span className="gb-related-label">{UI.related}</span>
                    {t.related.map(r => <a key={r.label} href={r.href} className="gb-related-link">
                        {r.label}
                      </a>)}
                  </div>}
              </div>;
  })}
      </div>
    </div>;
};

<Info>
  One-sentence definitions for all terms used in the book. English originals are retained alongside Chinese equivalents. Claims are grounded in official documentation; fast-changing items are annotated as of 2026-05.
</Info>

<GlossaryBrowser
  lang="en"
  categories={[
{ id: "basics",  label: "Foundations" },
{ id: "config",  label: "Configuration" },
{ id: "risk",    label: "Risk & Evaluation" },
{ id: "custom",  label: "Customization" },
{ id: "eval",    label: "Case Studies" },
{ id: "cross",   label: "Cross-unit" },
]}
  terms={[
{
  id: "token",
  term: "token",
  en: "token",
  category: "basics",
  definition: "The smallest unit the model processes (a subword), not a character and not a word; affects cost and context occupancy. Chinese text typically runs 1 to 2 tokens per character, denser than English.",
  related: [{ label: "tokenization", href: "#tokenization" }, { label: "context window", href: "#context-window" }],
},
{
  id: "tokenization",
  term: "tokenization",
  en: "tokenization",
  category: "basics",
  definition: "The process of splitting input text into a token sequence; different models use different tokenizers, and rough estimates should use official tooling.",
  related: [{ label: "token", href: "#token" }],
},
{
  id: "context-window",
  term: "context window",
  en: "context window",
  category: "basics",
  definition: "The maximum number of tokens a model can process in one pass (input plus output); when the window fills, the oldest content is pushed out.",
  related: [{ label: "context rot", href: "#context-rot" }, { label: "context engineering", href: "#context-engineering" }],
},
{
  id: "context-rot",
  term: "context rot",
  en: "context rot",
  category: "basics",
  definition: "The phenomenon of declining model quality as the context approaches capacity or passes the midpoint; Chroma (2025) observed this across 18 models [1].",
  related: [{ label: "context window", href: "#context-window" }, { label: "lost in the middle", href: "#lost-in-middle" }],
},
{
  id: "lost-in-middle",
  term: "lost in the middle",
  en: "lost in the middle",
  category: "basics",
  definition: "In long contexts, the model pays significantly less attention to information in the middle than at the beginning or end (Liu, et al., 2023) [2].",
  related: [{ label: "context rot", href: "#context-rot" }],
},
{
  id: "context-engineering",
  term: "context engineering",
  en: "context engineering",
  category: "basics",
  definition: "Managing everything that enters the context window (instructions, knowledge, history, tool results) to improve output quality. Anthropic defines it as 'finding the minimum high-signal token set that maximizes goal achievement within a limited attention budget' [3]. See 01-4.",
  related: [{ label: "context window", href: "#context-window" }, { label: "augmented LLM", href: "#augmented-llm" }],
},
{
  id: "hallucination",
  term: "hallucination",
  en: "hallucination",
  category: "basics",
  definition: "Content the model produces that looks plausible but is incorrect; arises because generative models optimize for 'does it look right' rather than 'is it right.'",
},
{
  id: "temperature",
  term: "temperature",
  en: "temperature",
  category: "basics",
  definition: "A sampling parameter that scales the sharpness of the probability distribution. Approaching 0 converges output; approaching 1 increases divergence. Lower for reproducibility, higher for brainstorming.",
  related: [{ label: "top-p", href: "#top-p" }],
},
{
  id: "top-p",
  term: "top-p (nucleus sampling)",
  en: "top-p / nucleus sampling",
  category: "basics",
  definition: "Sampling only from the candidate token pool whose cumulative probability reaches p, dynamically trimming the long tail.",
  related: [{ label: "temperature", href: "#temperature" }],
},
{
  id: "system-prompt",
  term: "system prompt",
  en: "system prompt",
  category: "basics",
  definition: "The instruction layer set by the platform or developer, with higher priority than user input; the technical foundation for rules files.",
  related: [{ label: "CLAUDE.md", href: "#claude-md" }],
},
{
  id: "tool-use",
  term: "tool use / function calling",
  en: "tool use / function calling",
  category: "basics",
  definition: "The mechanism by which the model decides to call an external tool and feeds the result back into the context under the 'tool' role; the model only 'requests' -- the harness 'executes.'",
  related: [{ label: "harness", href: "#harness" }, { label: "agentic loop", href: "#agentic-loop" }],
},
{
  id: "agentic-loop",
  term: "agentic loop",
  en: "agentic loop",
  category: "basics",
  definition: "The autonomous cycle of observe, decide, act, observe again; the essential difference between an agent and a simple conversation.",
  related: [{ label: "agent", href: "#agent" }, { label: "harness", href: "#harness" }],
},
{
  id: "harness",
  term: "harness",
  en: "harness",
  category: "basics",
  definition: "The execution shell of an agent, responsible for tool execution, permission boundaries, state persistence, loop termination, observability, and kill switches. The model sets the capability ceiling; the harness determines how much of it you actually get. See 01-6.",
  related: [{ label: "kill switch", href: "#kill-switch" }, { label: "agentic loop", href: "#agentic-loop" }],
},
{
  id: "augmented-llm",
  term: "augmented LLM",
  en: "augmented LLM",
  category: "basics",
  definition: "Anthropic's term for an LLM enhanced with retrieval, tools, memory, and similar capabilities; the harness revolves around it.",
  related: [{ label: "harness", href: "#harness" }, { label: "context engineering", href: "#context-engineering" }],
},
{
  id: "kill-switch",
  term: "kill switch",
  en: "kill switch",
  category: "basics",
  definition: "A mechanism triggered externally to terminate the agent process; does not rely on the compromised process to terminate itself.",
  related: [{ label: "heartbeat dead-man switch", href: "#heartbeat-dms" }, { label: "harness", href: "#harness" }],
},
{
  id: "heartbeat-dms",
  term: "heartbeat dead-man switch",
  en: "heartbeat dead-man switch",
  category: "basics",
  definition: "A mechanism where a long-running task writes a heartbeat at regular intervals and an external supervisor kills the entire process group when the heartbeat stops.",
  related: [{ label: "kill switch", href: "#kill-switch" }],
},
{
  id: "prompt-engineering",
  term: "prompt engineering",
  en: "prompt engineering",
  category: "basics",
  definition: "The design practice of writing tasks as specifications the model can execute; structured scaffolding, XML tags, few-shot examples, Automated Prompt Optimization (APO). See 01-3.",
  related: [{ label: "few-shot", href: "#few-shot" }, { label: "APO", href: "#apo" }],
},
{
  id: "few-shot",
  term: "few-shot",
  en: "Few-Shot",
  category: "basics",
  definition: "Placing 2 to 3 examples in the prompt to calibrate abstract style or format requirements into templates the model can align to.",
  related: [{ label: "prompt engineering", href: "#prompt-engineering" }],
},
{
  id: "apo",
  term: "APO (Automated Prompt Optimization)",
  en: "APO",
  category: "basics",
  definition: "Automated prompt iteration driven by an evaluation function; representative implementations include OPRO (Yang, et al., 2023) [4] and DSPy (Khattab, et al., 2023) [5].",
  related: [{ label: "prompt engineering", href: "#prompt-engineering" }],
},
{
  id: "workflow",
  term: "workflow",
  en: "workflow",
  category: "basics",
  definition: "A system where LLMs and tools are pre-arranged along programmatic paths; you define the steps and branches, and the model only acts within each node. See 01-5.",
  related: [{ label: "agent", href: "#agent" }, { label: "DAG", href: "#dag" }],
},
{
  id: "agent",
  term: "agent",
  en: "agent",
  category: "basics",
  definition: "A system where the LLM autonomously decides the flow and tool usage; high flexibility, lower controllability.",
  related: [{ label: "workflow", href: "#workflow" }, { label: "agentic loop", href: "#agentic-loop" }],
},
{
  id: "dag",
  term: "DAG (directed acyclic graph)",
  en: "DAG",
  category: "basics",
  definition: "A directed graph of steps; parallelization opportunities surface naturally once drawn (nodes with no path between them can run concurrently).",
  related: [{ label: "workflow", href: "#workflow" }],
},
{
  id: "vibe-coding",
  term: "Vibe Coding",
  en: "Vibe Coding",
  category: "basics",
  definition: "Letting AI write code by feel with low structure; this Playbook advocates replacing blind acceptance with configuration and verification.",
},
{
  id: "claude-md",
  term: "CLAUDE.md",
  en: "CLAUDE.md",
  category: "config",
  definition: "Claude's memory and rules file, divided into four layers: managed, user, project, and local; the managed layer cannot be disabled by individuals. See 04-1.",
  related: [{ label: "AGENTS.md", href: "#agents-md" }, { label: "Rules", href: "#rules" }],
},
{
  id: "at-import",
  term: "@path import syntax",
  en: "@path import syntax",
  category: "config",
  definition: "Using @path/to/file inside CLAUDE.md to import other files; up to 4 levels of recursion; commonly used with @AGENTS.md so Claude and other tools share the same baseline.",
  related: [{ label: "CLAUDE.md", href: "#claude-md" }, { label: "AGENTS.md", href: "#agents-md" }],
},
{
  id: "agents-md",
  term: "AGENTS.md",
  en: "AGENTS.md",
  category: "config",
  definition: "An open standard for cross-tool rules files, governed by the Agentic AI Foundation under the Linux Foundation; natively supported by more than twenty tools, adopted by over sixty thousand projects (as of 2026-06).",
  related: [{ label: "CLAUDE.md", href: "#claude-md" }],
},
{
  id: "rules",
  term: "Rules (.claude/rules/*.md)",
  en: "Rules",
  category: "config",
  definition: "Modular rules files; setting 'paths' in frontmatter binds them to a glob, loading them only when matching files are touched, avoiding unnecessary context occupancy. See 04-2.",
  related: [{ label: "CLAUDE.md", href: "#claude-md" }, { label: "path-scoped rule", href: "#path-scoped-rule" }],
},
{
  id: "skill",
  term: "Skill (SKILL.md)",
  en: "Skill",
  category: "config",
  definition: "A reusable process that exists as a directory and is loaded on demand; whether the model auto-invokes it depends on how well the description is written. See 04-4.",
  related: [{ label: "progressive disclosure", href: "#progressive-disclosure" }, { label: "Hook", href: "#hook" }],
},
{
  id: "progressive-disclosure",
  term: "progressive disclosure",
  en: "progressive disclosure",
  category: "config",
  definition: "Skills move expensive content into references/ and scripts/, keeping the main file to essential entry points; reduces context cost per invocation.",
  related: [{ label: "Skill", href: "#skill" }],
},
{
  id: "hook",
  term: "Hook",
  en: "Hook",
  category: "config",
  definition: "An event-driven deterministic automation mechanism (PreToolUse, PostToolUse, Stop, SessionStart, and others: 30 events as of 2026-06) that upgrades 'the model remembers' to 'the system guarantees.' See 04-6.",
  related: [{ label: "exit 2 intercept semantics", href: "#exit-2" }, { label: "Skill", href: "#skill" }],
},
{
  id: "exit-2",
  term: "exit 2 intercept semantics",
  en: "exit 2 intercept semantics",
  category: "config",
  definition: "A hook returning exit 2 in the PreToolUse phase is equivalent to rejecting that tool call; the model sees the rejection feedback and adjusts its plan.",
  related: [{ label: "Hook", href: "#hook" }],
},
{
  id: "subagent",
  term: "Subagent",
  en: "Subagent",
  category: "config",
  definition: "A subtask execution container with its own independent context window; since v2.1, structured as built-in (Explore, Plan, general-purpose) plus custom layers. See 04-10.",
  related: [{ label: "isolation: worktree", href: "#isolation-worktree" }, { label: "agent", href: "#agent" }],
},
{
  id: "isolation-worktree",
  term: "isolation: worktree",
  en: "isolation: worktree",
  category: "config",
  definition: "Subagents physically isolate the filesystem via git worktree, enabling parallel subtasks without conflicts.",
  related: [{ label: "Subagent", href: "#subagent" }],
},
{
  id: "plugin",
  term: "Plugin",
  en: "Plugin",
  category: "config",
  definition: "A unit that packages skills, agents, hooks, MCP and LSP configuration, and background monitoring; distributed via marketplace or git URL, with namespace isolation to prevent name collisions. See 04-8.",
  related: [{ label: "Marketplace", href: "#marketplace" }],
},
{
  id: "marketplace",
  term: "Marketplace (plugin marketplace)",
  en: "Marketplace",
  category: "config",
  definition: "Two public marketplaces: official claude-plugins-official and community claude-community, with /plugin install as the installation path.",
  related: [{ label: "Plugin", href: "#plugin" }],
},
{
  id: "harness-layers",
  term: "harness layer composition",
  en: "harness layer composition",
  category: "config",
  definition: "Case studies such as OpenClaw establish that Identity (SOUL.md), Memory (MEMORY.md), Heartbeat, Tool conventions, Bootstrap, and User Markdown files in a workspace collectively assemble agent personality and behavior. See 05-1.",
  related: [{ label: "harness", href: "#harness" }, { label: "soul-md", href: "#soul-md" }],
},
{
  id: "mcp",
  term: "MCP (Model Context Protocol)",
  en: "MCP",
  category: "config",
  definition: "An open standard for connecting external tools and data sources to the model; a single server exposes three interface types: tools, resources, and prompts. See 04-9.",
  related: [{ label: "MCP transport", href: "#mcp-transport" }, { label: "MCP scope", href: "#mcp-scope" }],
},
{
  id: "mcp-transport",
  term: "MCP transport",
  en: "MCP transport",
  category: "config",
  definition: "The transport protocol between client and server; Claude Code supports stdio (local process), http (including the streamable-http alias), sse (deprecated), and ws.",
  related: [{ label: "MCP", href: "#mcp" }],
},
{
  id: "mcp-scope",
  term: "MCP scope",
  en: "MCP scope",
  category: "config",
  definition: "The configuration scope of an MCP server: local (personal, not shared), project (versioned, requires user approval), and user (all personal projects).",
  related: [{ label: "MCP", href: "#mcp" }],
},
{
  id: "cli-first",
  term: "CLI-first",
  en: "CLI-first",
  category: "config",
  definition: "Prefer CLI for any operation that can be done via CLI, with MCP as fallback; CLI has no schema preload cost, its stdout is trimmable, and it can be chained with shell pipes. See 04-10.",
  related: [{ label: "MCP", href: "#mcp" }],
},
{
  id: "prompt-injection",
  term: "prompt injection",
  en: "prompt injection",
  category: "risk",
  definition: "An attack where untrusted external content is mistakenly executed as instructions; a design constraint at the application layer, not a model bug. See 03-3.",
  related: [{ label: "Willison triple threat", href: "#triple-threat" }, { label: "memory poisoning", href: "#memory-poisoning" }],
},
{
  id: "triple-threat",
  term: "Willison triple threat",
  en: "Willison triple threat",
  category: "risk",
  definition: "When private data, untrusted content, and an outbound channel coexist, prompt injection escalates from 'making the model say strange things' to a data exfiltration vector.",
  related: [{ label: "prompt injection", href: "#prompt-injection" }],
},
{
  id: "memory-poisoning",
  term: "memory poisoning",
  en: "memory poisoning",
  category: "risk",
  definition: "Planting a payload in memory across sessions that triggers when a future session assembles its context; keeping memory narrow and rotating it regularly are mitigations.",
  related: [{ label: "prompt injection", href: "#prompt-injection" }],
},
{
  id: "supply-chain-risk",
  term: "supply chain risk",
  en: "supply chain risk",
  category: "risk",
  definition: "Security risks introduced by third-party Skills, plugins, rules, or hooks; the Snyk ToxicSkills report (2026-02) found approximately 36% of 3,984 public skills contained prompt injection [6].",
  related: [{ label: "provenance", href: "#provenance" }, { label: "hidden unicode / bidi attack", href: "#hidden-unicode" }],
},
{
  id: "provenance",
  term: "provenance",
  en: "provenance",
  category: "risk",
  definition: "Whether a component's origin is named and traceable, used as a trust signal.",
  related: [{ label: "supply chain risk", href: "#supply-chain-risk" }],
},
{
  id: "hidden-unicode",
  term: "hidden unicode / bidi attack",
  en: "hidden unicode / bidi attack",
  category: "risk",
  definition: "Invisible payloads hidden in zero-width characters (U+200B and similar) and bidirectional control codes (U+202A through U+202E); invisible to humans, visible to models.",
  related: [{ label: "supply chain risk", href: "#supply-chain-risk" }],
},
{
  id: "saturation-check",
  term: "saturation check",
  en: "saturation check",
  category: "risk",
  definition: "A 100% pass rate on a benchmark means the tests are too easy and lack discriminative power; add edge cases until at least one model tier fails. See 03-4.",
},
{
  id: "blind-trust",
  term: "blind trust",
  en: "blind trust",
  category: "risk",
  definition: "The verifiability blind spot of accepting something because it looks reasonable; verifying all verifiable claims is the antidote.",
},
{
  id: "path-scoped-rule",
  term: "path-scoped rule",
  en: "path-scoped rule",
  category: "custom",
  definition: "A rules file that uses frontmatter 'paths: [\"src/**/*.ts\"]' to restrict loading to only when matching glob files are touched. See 04-2.",
  related: [{ label: "Rules", href: "#rules" }],
},
{
  id: "at-mention",
  term: "@-mention explicit invocation",
  en: "@-mention explicit invocation",
  category: "custom",
  definition: "Using @subagent-name in the main conversation to directly invoke a Subagent rather than relying on the model to auto-trigger based on the description.",
  related: [{ label: "Subagent", href: "#subagent" }],
},
{
  id: "context-fork",
  term: "context: fork",
  en: "context: fork",
  category: "custom",
  definition: "A Skill executing its entire procedure inside a Subagent context; the Subagent uses skills: to preload procedures into its own context.",
  related: [{ label: "Subagent", href: "#subagent" }, { label: "Skill", href: "#skill" }],
},
{
  id: "heartbeat-schedule",
  term: "heartbeat scheduling",
  en: "heartbeat scheduling",
  category: "custom",
  definition: "The timed trigger mechanism used by harnesses such as OpenClaw; the agent is woken at scheduled points to run a turn, simulating 'standing watch in the background.'",
  related: [{ label: "heartbeat dead-man switch", href: "#heartbeat-dms" }],
},
{
  id: "soul-md",
  term: "SOUL.md / MEMORY.md",
  en: "SOUL.md / MEMORY.md",
  category: "custom",
  definition: "The personality and memory Markdown files in the OpenClaw workspace; the agent reads its own 'soul' before starting work each session. See 05-1.",
  related: [{ label: "harness layer composition", href: "#harness-layers" }],
},
{
  id: "nemoclaw",
  term: "NemoClaw / always-on agent",
  en: "NemoClaw / always-on agent",
  category: "eval",
  definition: "NVIDIA's security shell designed for resident agents; corresponds to a hardened mode covering enterprise-grade SLAs, shared team infrastructure, and unified auditing. See 05-3.",
},
{
  id: "harness-viz",
  term: "harness visualization",
  en: "harness visualization",
  category: "eval",
  definition: "OpenClaw breaks down personality, memory, heartbeat, and tool conventions into readable Markdown files so users can directly inspect and modify agent design.",
  related: [{ label: "harness layer composition", href: "#harness-layers" }],
},
{
  id: "config-layer",
  term: "config layer",
  en: "config layer",
  category: "cross",
  definition: "The configuration hierarchy of user-global, project, and local layers; higher layers do not necessarily have higher precedence: each tool's own rules determine priority. See 02-1.",
  related: [{ label: "CLAUDE.md", href: "#claude-md" }],
},
{
  id: "least-privilege",
  term: "least privilege",
  en: "least privilege",
  category: "cross",
  definition: "Agents and tools receive only the permissions actually required for the task; anything beyond that is revoked.",
  related: [{ label: "provenance", href: "#provenance" }],
},
{
  id: "credential-boundary",
  term: "credential boundary",
  en: "credential boundary",
  category: "cross",
  definition: "The isolation boundary between agent-specific PATs, personal PATs, and machine accounts.",
  related: [{ label: "least privilege", href: "#least-privilege" }],
},
{
  id: "pre-flight",
  term: "pre-flight check",
  en: "pre-flight check",
  category: "cross",
  definition: "A quick verification before execution (permissions, training opt-out, secret path scan) to avoid cleanup after the fact.",
},
{
  id: "hybrid-verification",
  term: "hybrid verification",
  en: "hybrid verification",
  category: "cross",
  definition: "Write general concepts directly; always look up fast-changing facts (config file names, versions, mechanisms) in official documentation.",
},
{
  id: "provenance-annotation",
  term: "provenance annotation",
  en: "provenance annotation",
  category: "cross",
  definition: "Marking source, author, date, and confidence level alongside references, examples, and links.",
  related: [{ label: "provenance", href: "#provenance" }],
},
]}
/>

***

## Corresponding units

* Foundations overview: [01-1 Why use AI tools "correctly"](/en/code-agent/foundations/why-correct-usage)
* LLM and agent mechanics: [01-2 How LLMs and Agents work](/en/code-agent/foundations/llm-agent-basics)
* Context engineering detail: [01-4 Context Engineering](/en/code-agent/foundations/context-engineering)
* Configuration layer model: [02-1 The Configuration Layer Model](/en/code-agent/configuration/config-layer-model)
* Privacy and security terms: [Appendix B Privacy and Security Checklist](/en/code-agent/appendix/privacy-security-checklist) and [03-3 Security, Privacy, and Supply Chain Risk](/en/code-agent/judgment/security-privacy-supply-chain)
* Cross-tool configuration terms: [02-6 Other Tools Comparison](/en/code-agent/configuration/other-tools-comparison)
* Customization terms: [04-1 CLAUDE.md](/en/code-agent/customization/claude-md-memory) through [04-11 Agent Teams and Sub Agents](/en/code-agent/customization/team-vs-subagent)
* Case study terms: [05-1 OpenClaw](/en/code-agent/case-studies/openclaw) through [05-4 Three Approaches Compared](/en/code-agent/case-studies/three-approaches-comparison)

***

<div className="references">
  * \[1] Chroma, "Context Rot in Long-Context Language Models," 2025. \[Online]. Available: [https://research.trychroma.com](https://research.trychroma.com) (verified 2026-06; includes empirical testing across 18 models)
  * \[2] Liu, et al., "Lost in the Middle: How Language Models Use Long Contexts," 2023. \[Online]. Available: [https://arxiv.org/abs/2307.03172](https://arxiv.org/abs/2307.03172)
  * \[3] Anthropic, "Effective context engineering for AI agents," 2026. \[Online]. Available: [https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
  * \[4] Yang, et al., "Large Language Models as Optimizers," 2023. \[Online]. Available: [https://arxiv.org/abs/2309.03409](https://arxiv.org/abs/2309.03409)
  * \[5] Khattab, et al., "DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines," 2023. \[Online]. Available: [https://arxiv.org/abs/2310.03714](https://arxiv.org/abs/2310.03714)
  * \[6] Snyk, "ToxicSkills: 2026 Report on Malicious Skills in the Wild," 2026. \[Online]. Available: [https://snyk.io](https://snyk.io)
</div>