#Step 10 — 장기 메모리와 스킬

memory?: string[]

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
  }),
  store,                              // StoreBackend 를 쓰려면 필수
  checkpointer: new MemorySaver(),
  memory: ["/memories/AGENTS.md"],    // 이 파일 내용이 시스템 프롬프트에 주입됩니다
});

new CompositeBackend(defaultBackend, routes)

const backend = new CompositeBackend(
  new StateBackend(),                 // 기본: 스레드 안에서만 사는 임시 작업 공간
  {
    "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),  // 여기만 영속
  },
);

// --- 스레드 A: 정보를 알려주고 저장시킨다
await agent.invoke(
  { messages: [{ role: "user", content: "나는 들여쓰기를 스페이스 2칸으로 쓴다. 기억해줘." }] },
  { configurable: { thread_id: "10-2-A" } },
);

// --- 스레드 B: 완전히 새 대화. 대화 기록은 공유되지 않는다.
const rB = await agent.invoke(
  { messages: [{ role: "user", content: "내 들여쓰기 취향이 뭐였지?" }] },
  { configurable: { thread_id: "10-2-B" } },
);
console.log("스레드 B 응답:", rB.messages.at(-1)?.text);

// 사용자별 격리 (권장)
new StoreBackend({ namespace: () => ["users", userId, "memories"] })

// 런타임에서 뽑기 — 문서에 나온 형태
new StoreBackend({ namespace: (rt) => [rt.serverInfo.user.identity] })
new StoreBackend({ namespace: (rt) => [rt.serverInfo.assistantId] })
new StoreBackend({ namespace: (rt) => [rt.context.orgId] })

interface MemoryMiddlewareOptions {
  backend: AnyBackendProtocol | BackendFactory | ((config) => StateBackend);
  sources: string[];          // 로드할 메모리 파일 경로. 순서대로 로드됨
  addCacheControl?: boolean;  // 기본 false
}

const backend = new CompositeBackend(new StateBackend(), {
  "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend,
  store,
  checkpointer: new MemorySaver(),
  middleware: [
    createMemoryMiddleware({
      backend,                                              // ← 같은 인스턴스여야 합니다
      sources: ["/memories/AGENTS.md", "/memories/PROJECT.md"],
      addCacheControl: true,
    }),
  ],
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend, store,
  checkpointer: new MemorySaver(),
  memory: ["/memories/AGENTS.md"],
  systemPrompt: `너는 사용자를 기억하는 코딩 도우미다.

## 메모리 규칙
- 사용자가 "기억해", "앞으로는" 이라고 말하면 /memories/AGENTS.md 에 저장해라.
- 저장 전에 반드시 read_file 로 현재 내용을 먼저 읽어라.
- 기존 내용을 지우지 말고 edit_file 로 항목을 추가해라.
- 일회성 사실(오늘 날씨 등)은 저장하지 마라. 지속되는 선호만 저장해라.`,
});

const rememberPreference = tool(
  async ({ category, rule }) => `기록했습니다: [${category}] ${rule}`,
  {
    name: "remember_preference",
    description:
      "사용자의 지속적인 선호를 기록한다. 일회성 사실이 아니라 앞으로도 계속 적용될 규칙에만 사용해라.",
    schema: z.object({
      category: z.enum(["code-style", "communication", "workflow"]),
      rule: z.string().describe("한 문장으로 된 규칙. 예: '커밋 메시지는 한국어로 쓴다'"),
    }),
  },
);

skills?: string[]

const backend = new FilesystemBackend({ rootDir: process.cwd(), virtualMode: true });

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend,
  checkpointer: new MemorySaver(),
  middleware: [
    createSkillsMiddleware({
      backend,
      sources: [
        "/skills/",               // 디렉터리 스캔
        "/skills/code-review/",   // 단일 스킬 직접 지정
      ],
    }),
  ],
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  skills: ["/skills/main/"],        // 메인 에이전트용
  subagents: [
    {
      name: "researcher",
      description: "리서치 담당",
      skills: ["/skills/research/", "/skills/web-search/"],  // 이 서브에이전트만의 스킬
    },
  ],
});

const searchDocs = tool(
  async ({ query }) => {
    const retrievedDocs = await vectorStore.similaritySearch(query, 4);
    const paths: string[] = [];

    // 청크를 파일로 내려놓고, 경로만 기억한다
    retrievedDocs.forEach((doc, i) => {
      const path = `/retrieved/chunk_${i + 1}.md`;
      paths.push(path);
      // backend.uploadFiles(...) 로 파일시스템에 씁니다
    });

    // 반환값은 "본문" 이 아니라 "경로 목록" — 이게 offload 패턴의 핵심입니다
    return `${paths.length}개 청크를 저장했습니다:\n${paths.join("\n")}`;
  },
  {
    name: "search_documentation",
    description: "문서를 검색해 관련 청크를 파일시스템에 저장하고 경로를 반환한다.",
    schema: z.object({ query: z.string().describe("자연어 검색 질의") }),
  },
);

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend: new StateBackend(),
  checkpointer: new MemorySaver(),
  systemPrompt: `질문에 답하려면 /docs 안을 직접 뒤져라.

1. glob 으로 문서 목록을 본다.
2. grep 으로 키워드를 찾는다. 첫 검색이 실패하면 다른 표현으로 다시 시도해라.
3. 찾은 파일을 read_file 로 읽고 근거를 인용해 답한다.
4. 문서에 없으면 "문서에 없다" 고 답해라. 지어내지 마라.`,
});

const store = new InMemoryStore();
const USER_ID = "user-123";  // 실전에서는 인증된 사용자 ID

const backend = new CompositeBackend(new StateBackend(), {
  // 사용자별로 네임스페이스 분리 — 이게 없으면 정보가 샙니다
  "/memories/": new StoreBackend({ namespace: () => ["users", USER_ID, "memories"] }),
  // 스킬은 전체 공유 (사용자별로 다를 이유가 없음)
  "/skills/": new StoreBackend({ namespace: () => ["shared", "skills"] }),
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  backend,
  store,
  checkpointer: new MemorySaver(),
  memory: ["/memories/AGENTS.md"],
  skills: ["/skills/"],
  systemPrompt: `너는 이 프로젝트의 코딩 어시스턴트다.

## 메모리 규칙
- 사용자가 "앞으로", "항상", "기억해" 라고 말하면 /memories/AGENTS.md 에 규칙을 추가해라.
- 추가 전에 read_file 로 먼저 읽고, edit_file 로 항목만 덧붙여라. 덮어쓰지 마라.
- 이미 있는 규칙과 모순되면 사용자에게 물어봐라.`,

  // 메모리와 스킬은 읽기만 — 모델이 스킬 파일을 고치지 못하게 막습니다
  permissions: [
    { operations: ["write"], paths: ["/skills/**"], mode: "deny" },
    { operations: ["read", "write"], paths: ["/memories/**"], mode: "allow" },
    { operations: ["read", "write"], paths: ["/workspace/**"], mode: "allow" },
    { operations: ["read"], paths: ["/skills/**"], mode: "allow" },
    { operations: ["read", "write"], paths: ["/**"], mode: "deny" },
  ],
});

// --- 세션 1: 규칙을 알려준다
await agent.invoke(
  { messages: [{ role: "user", content: "앞으로 이 프로젝트에서는 함수를 화살표 함수로만 쓰고, 세미콜론은 생략해줘." }] },
  { configurable: { thread_id: "10-9-session-1" } },
);

// --- 세션 2: 완전히 새 대화. 대화 기록은 없지만 메모리는 남아 있다.
const r2 = await agent.invoke(
  { messages: [{ role: "user", content: "/workspace/util.ts 에 두 수를 더하는 함수를 만들어줘." }] },
  { configurable: { thread_id: "10-9-session-2" } },
);

/**
 * Step 10 — 장기 메모리와 스킬
 * 실행: npx tsx docs/reference/deepagent/step-10-memory-skills/practice.ts
 *
 * 본문 10-1 ~ 10-9 의 예제를 순서대로 담았습니다.
 * 검증 버전: deepagents 1.11.0 / langchain 1.5.3 / @langchain/langgraph 1.4.8
 */
import "dotenv/config";
import {
  createDeepAgent,
  createMemoryMiddleware,
  createSkillsMiddleware,
  CompositeBackend,
  StateBackend,
  StoreBackend,
  FilesystemBackend,
} from "deepagents";
import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
import { tool } from "langchain";
import * as z from "zod";

const MODEL = "anthropic:claude-sonnet-4-6";
// OpenAI 대안: const MODEL = "openai:gpt-5.5";

/**
 * state 의 files 에 넣을 FileData 객체를 만드는 헬퍼.
 *
 * 주의: files 는 `Record<string, string>` 이 아닙니다.
 * `{ content, mimeType, created_at, modified_at }` 형태의 FileData 객체를 요구합니다.
 * 문자열을 그대로 넣으면 타입 에러가 납니다.
 */
function textFile(content: string) {
  const now = new Date().toISOString();
  return { content, mimeType: "text/markdown", created_at: now, modified_at: now };
}

/* ===== [10-1] memory 옵션 — Deep Agent 의 장기 기억 ===== */
// memory: string[] — 시스템 프롬프트에 주입할 "메모리 파일 경로" 목록입니다.
// 벡터 DB 가 아니라 그냥 파일입니다. 매 턴 읽혀서 프롬프트에 붙습니다.

async function step10_1() {
  console.log("\n===== [10-1] memory 옵션 =====");

  const store = new InMemoryStore();

  const agent = await createDeepAgent({
    model: MODEL,
    // memory 경로가 영속되려면 그 경로를 StoreBackend 로 라우팅해야 합니다.
    // StateBackend 만 쓰면 스레드가 끝나는 순간 사라집니다 (= 장기 기억이 아님).
    backend: new CompositeBackend(new StateBackend(), {
      "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
    }),
    store, // StoreBackend 를 쓰려면 store 를 반드시 넘겨야 합니다
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"], // 이 파일 내용이 시스템 프롬프트에 주입됩니다
  });

  // 아직 파일이 없으므로 주입될 내용도 없습니다. 에러는 나지 않습니다.
  const r = await agent.invoke(
    { messages: [{ role: "user", content: "내 이름이 뭐라고 했지?" }] },
    { configurable: { thread_id: "10-1" } },
  );
  console.log("응답:", r.messages.at(-1)?.text);

  return { agent, store };
}

/* ===== [10-2] 파일시스템 = 메모리 — CompositeBackend 로 구성 ===== */
// CompositeBackend(defaultBackend, routes)
//   defaultBackend: 라우트에 안 걸리는 모든 경로가 여기로
//   routes:        경로 접두사 → 백엔드

async function step10_2() {
  console.log("\n===== [10-2] CompositeBackend 로 영속 경로 만들기 =====");

  const store = new InMemoryStore();

  const backend = new CompositeBackend(
    // 기본: 스레드 안에서만 사는 임시 작업 공간
    new StateBackend(),
    {
      // /memories/ 아래만 영속. 스레드가 바뀌어도 남습니다.
      "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
    },
  );

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"],
    systemPrompt:
      "너는 사용자를 기억하는 도우미다. 사용자가 알려준 선호는 /memories/AGENTS.md 에 write_file 로 저장해라.",
  });

  // --- 스레드 A: 정보를 알려주고 저장시킨다
  await agent.invoke(
    {
      messages: [
        {
          role: "user",
          content: "나는 들여쓰기를 스페이스 2칸으로 쓴다. 기억해줘.",
        },
      ],
    },
    { configurable: { thread_id: "10-2-A" } },
  );

  // --- 스레드 B: 완전히 새 대화. 대화 기록은 공유되지 않는다.
  const rB = await agent.invoke(
    { messages: [{ role: "user", content: "내 들여쓰기 취향이 뭐였지?" }] },
    { configurable: { thread_id: "10-2-B" } },
  );

  // 스레드가 달라도 /memories/AGENTS.md 는 남아 있으므로 답할 수 있습니다.
  console.log("스레드 B 응답:", rB.messages.at(-1)?.text);

  // store 에 실제로 뭐가 들었는지 직접 확인
  const items = await store.search(["demo-user"]);
  console.log("store 에 저장된 키:", items.map((i) => i.key));
}

/* ===== [10-3] createMemoryMiddleware ===== */
// memory: [...] 옵션은 내부적으로 이 미들웨어를 붙여줍니다.
// 직접 쓰면 addCacheControl 같은 옵션을 제어할 수 있습니다.

async function step10_3() {
  console.log("\n===== [10-3] createMemoryMiddleware 직접 쓰기 =====");

  const store = new InMemoryStore();
  const backend = new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
  });

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    // memory: [...] 를 쓰지 않고 미들웨어를 직접 붙입니다
    middleware: [
      createMemoryMiddleware({
        backend,
        sources: ["/memories/AGENTS.md", "/memories/PROJECT.md"], // 순서대로 로드
        // 메모리 블록에 cache_control 을 붙여 프롬프트 캐싱을 활성화 (Anthropic)
        // 메모리는 매 턴 똑같이 붙는 큰 덩어리라 캐싱 효과가 큽니다.
        addCacheControl: true,
      }),
    ],
  });

  console.log("sources 2개를 순서대로 주입하는 메모리 미들웨어 구성 완료");
  return agent;
}

/* ===== [10-4] 메모리 읽기/쓰기 전략 ===== */
// 언제 저장할지를 (a) 모델에게 맡기기 (b) 코드로 강제하기

async function step10_4() {
  console.log("\n===== [10-4] 저장 시점 전략 =====");

  const store = new InMemoryStore();
  const backend = new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ namespace: () => ["demo-user"] }),
  });

  // --- (a) 모델에게 맡기기: 프롬프트로 "언제 쓸지" 를 지시한다
  const modelDriven = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"],
    systemPrompt: `너는 사용자를 기억하는 코딩 도우미다.

## 메모리 규칙
- 사용자가 "기억해", "앞으로는" 이라고 말하면 /memories/AGENTS.md 에 저장해라.
- 저장 전에 반드시 read_file 로 현재 내용을 먼저 읽어라.
- 기존 내용을 지우지 말고 edit_file 로 항목을 추가해라.
- 일회성 사실(오늘 날씨 등)은 저장하지 마라. 지속되는 선호만 저장해라.`,
  });

  const r = await modelDriven.invoke(
    { messages: [{ role: "user", content: "앞으로 커밋 메시지는 한국어로 써줘." }] },
    { configurable: { thread_id: "10-4-a" } },
  );
  console.log("(a) 모델 주도 응답:", r.messages.at(-1)?.text);

  // --- (b) 코드로 강제하기: 저장 전용 도구를 만들고 스키마로 형식을 강제한다
  const rememberPreference = tool(
    async ({ category, rule }) => {
      // 실제로는 여기서 store 에 직접 씁니다. 형식이 코드로 보장됩니다.
      return `기록했습니다: [${category}] ${rule}`;
    },
    {
      name: "remember_preference",
      description:
        "사용자의 지속적인 선호를 기록한다. 일회성 사실이 아니라 앞으로도 계속 적용될 규칙에만 사용해라.",
      schema: z.object({
        category: z.enum(["code-style", "communication", "workflow"]),
        rule: z.string().describe("한 문장으로 된 규칙. 예: '커밋 메시지는 한국어로 쓴다'"),
      }),
    },
  );

  const toolDriven = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    tools: [rememberPreference],
    memory: ["/memories/AGENTS.md"],
  });

  const r2 = await toolDriven.invoke(
    { messages: [{ role: "user", content: "앞으로 커밋 메시지는 한국어로 써줘." }] },
    { configurable: { thread_id: "10-4-b" } },
  );
  console.log("(b) 도구 주도 응답:", r2.messages.at(-1)?.text);
}

/* ===== [10-5] Skills — 절차적 지식을 파일로 주기 ===== */
// 스킬은 "이 일을 이렇게 하라" 는 절차서입니다.
// SKILL.md 의 frontmatter(name, description)만 항상 로드되고,
// 본문은 모델이 필요하다고 판단할 때만 읽힙니다 (progressive disclosure).

const SKILL_MD = `---
name: code-review
description: 코드 리뷰를 수행할 때 사용한다. PR 리뷰, 코드 검토, 개선점 찾기 요청에 활성화된다.
---

# 코드 리뷰 절차

다음 순서를 반드시 지켜라.

1. glob 으로 변경 대상 파일 목록을 만든다.
2. 각 파일을 read_file 로 읽는다. 추측하지 말고 반드시 읽어라.
3. 아래 체크리스트로 검토한다.
   - 에러 처리가 빠진 곳
   - 하드코딩된 비밀값
   - 테스트되지 않은 분기
4. 발견한 문제를 심각도(high/medium/low)와 함께 목록으로 보고한다.
5. 파일을 직접 수정하지 마라. 보고만 해라.
`;

async function step10_5() {
  console.log("\n===== [10-5] 스킬이란 무엇인가 =====");

  const agent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    skills: ["/skills/"], // 이 디렉터리를 스캔해 SKILL.md 가 있는 하위 폴더를 스킬로 로드
  });

  // StateBackend 를 쓸 때는 files 로 스킬 내용을 직접 주입할 수 있습니다.
  const result = await agent.invoke(
    {
      messages: [{ role: "user", content: "/workspace 의 코드를 리뷰해줘." }],
      files: {
        "/skills/code-review/SKILL.md": textFile(SKILL_MD),
        "/workspace/app.ts": textFile("export const apiKey = 'sk-hardcoded-secret';\n"),
      },
    },
    { configurable: { thread_id: "10-5" } },
  );

  console.log("응답:", result.messages.at(-1)?.text);
}

/* ===== [10-6] skills 옵션 / createSkillsMiddleware ===== */
// sources 의 두 가지 형식:
//   "/skills/"          → 디렉터리를 스캔, SKILL.md 를 가진 하위 폴더를 각각 로드
//   "/skills/my-skill/" → SKILL.md 가 루트에 있는 단일 스킬 디렉터리

async function step10_6() {
  console.log("\n===== [10-6] createSkillsMiddleware =====");

  // 디스크의 실제 스킬 폴더를 읽는 구성
  const backend = new FilesystemBackend({ rootDir: process.cwd(), virtualMode: true });

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    checkpointer: new MemorySaver(),
    middleware: [
      createSkillsMiddleware({
        backend,
        sources: [
          "/skills/", // 디렉터리 스캔
          "/skills/code-review/", // 단일 스킬 직접 지정
        ],
        // 같은 name 의 스킬이 있으면 뒤에 온 source 가 이깁니다 (last one wins)
      }),
    ],
  });

  console.log("skills 미들웨어 구성 완료 (sources: 디렉터리 스캔 + 단일 스킬)");
  return agent;
}

/* ===== [10-7] 스킬 vs 도구 vs 서브에이전트 ===== */
// 같은 "코드 리뷰" 기능을 세 가지 방식으로 구현해 차이를 본다.

async function step10_7() {
  console.log("\n===== [10-7] 세 가지 방식 비교 =====");

  // (a) 도구 — 결정적 코드를 실행한다. 컨텍스트를 안 먹는다.
  const runLinter = tool(
    async ({ path }) => `${path}: 3개 경고 발견 (no-unused-vars x2, no-console x1)`,
    {
      name: "run_linter",
      description: "지정한 경로에 린터를 실행하고 경고 목록을 반환한다.",
      schema: z.object({ path: z.string() }),
    },
  );

  // (b) 스킬 — 절차서. 같은 컨텍스트에서 모델이 읽고 따른다.
  // (위 SKILL_MD 를 files 로 주입)

  // (c) 서브에이전트 — 별도 컨텍스트에서 독립적으로 돈다.
  const agent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    tools: [runLinter],
    skills: ["/skills/"],
    subagents: [
      {
        name: "security-auditor",
        description: "보안 취약점만 집중적으로 감사한다. 결과 요약만 반환한다.",
        systemPrompt: "너는 보안 감사자다. 비밀값 노출과 인젝션 위험만 찾아 보고해라.",
      },
    ],
  });

  const result = await agent.invoke(
    {
      messages: [{ role: "user", content: "/workspace 를 리뷰하고 보안 감사도 함께 해줘." }],
      files: {
        "/skills/code-review/SKILL.md": textFile(SKILL_MD),
        "/workspace/app.ts": textFile("export const apiKey = 'sk-hardcoded-secret';\n"),
      },
    },
    { configurable: { thread_id: "10-7" } },
  );

  console.log("응답:", result.messages.at(-1)?.text);
}

/* ===== [10-8] Deep Agent 에서의 RAG — 벡터 검색 vs grep ===== */
// Deep Agent 는 파일시스템을 갖고 있어서 grep 이라는 선택지가 하나 더 있습니다.

async function step10_8() {
  console.log("\n===== [10-8] RAG — 벡터 검색 vs grep =====");

  // (a) 벡터 검색을 도구로: 결과를 파일에 offload 하고 경로만 반환하는 것이 핵심
  const backend = new StateBackend();

  const searchDocs = tool(
    async ({ query }) => {
      // 실제로는 vectorStore.similaritySearch(query, 4) 를 호출합니다.
      // 여기서는 형태만 보여주기 위해 가짜 결과를 씁니다.
      const fakeHits = [
        { source: "guide.md", text: `${query} 관련 내용 1` },
        { source: "api.md", text: `${query} 관련 내용 2` },
      ];

      const paths: string[] = [];
      for (const [i, hit] of fakeHits.entries()) {
        const path = `/retrieved/chunk_${i + 1}.md`;
        paths.push(path);
        // 청크 본문을 컨텍스트에 붓지 않고 파일로 내려놓습니다
      }

      // 반환값은 "본문" 이 아니라 "경로 목록" — 이게 offload 패턴의 핵심입니다.
      return `${paths.length}개 청크를 저장했습니다:\n${paths.join("\n")}`;
    },
    {
      name: "search_documentation",
      description: "문서를 검색해 관련 청크를 파일시스템에 저장하고 경로를 반환한다.",
      schema: z.object({ query: z.string().describe("자연어 검색 질의") }),
    },
  );

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    checkpointer: new MemorySaver(),
    tools: [searchDocs],
    systemPrompt:
      "문서 질문에는 search_documentation 으로 검색한 뒤, 저장된 파일을 read_file 로 읽어 답해라.",
  });

  const result = await agent.invoke(
    { messages: [{ role: "user", content: "인증은 어떻게 설정해?" }] },
    { configurable: { thread_id: "10-8" } },
  );
  console.log("(a) 벡터 검색 응답:", result.messages.at(-1)?.text);

  // (b) grep 으로 파일 뒤지기: 도구도 인덱싱도 임베딩도 필요 없다.
  // 내장 grep/glob 만으로 충분한 경우가 생각보다 많습니다.
  const grepAgent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    systemPrompt: "질문에 답하려면 grep 과 glob 으로 /docs 안을 직접 뒤져라.",
  });

  const r2 = await grepAgent.invoke(
    {
      messages: [{ role: "user", content: "인증은 어떻게 설정해?" }],
      files: {
        "/docs/auth.md": textFile("# 인증\n\nAPI 키를 ANTHROPIC_API_KEY 환경변수에 넣으세요."),
        "/docs/deploy.md": textFile("# 배포\n\ndocker build 로 이미지를 만듭니다."),
      },
    },
    { configurable: { thread_id: "10-8-b" } },
  );
  console.log("(b) grep 응답:", r2.messages.at(-1)?.text);
}

/* ===== [10-9] 실전: 프로젝트 규칙을 기억하는 코딩 어시스턴트 ===== */

const CODING_SKILL = `---
name: apply-project-rules
description: 이 프로젝트의 코드를 작성하거나 수정할 때 사용한다. 코드 작성, 리팩터링, 파일 생성 요청에 활성화된다.
---

# 프로젝트 규칙 적용 절차

1. /memories/AGENTS.md 를 read_file 로 읽어 현재 규칙을 확인한다.
2. 수정 대상 파일을 read_file 로 읽는다.
3. 규칙을 지켜 코드를 작성한다.
4. 규칙과 충돌하는 요청을 받으면 즉시 실행하지 말고 사용자에게 확인한다.
`;

async function step10_9() {
  console.log("\n===== [10-9] 프로젝트 규칙을 기억하는 코딩 어시스턴트 =====");

  const store = new InMemoryStore();
  const USER_ID = "user-123"; // 실전에서는 인증된 사용자 ID

  const backend = new CompositeBackend(new StateBackend(), {
    // 사용자별로 네임스페이스를 분리 — 이게 없으면 정보가 새어나갑니다
    "/memories/": new StoreBackend({ namespace: () => ["users", USER_ID, "memories"] }),
    // 스킬은 전체 공유 (사용자별로 다를 이유가 없음)
    "/skills/": new StoreBackend({ namespace: () => ["shared", "skills"] }),
  });

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"],
    skills: ["/skills/"],
    systemPrompt: `너는 이 프로젝트의 코딩 어시스턴트다.

## 메모리 규칙
- 사용자가 "앞으로", "항상", "기억해" 라고 말하면 /memories/AGENTS.md 에 규칙을 추가해라.
- 추가 전에 read_file 로 먼저 읽고, edit_file 로 항목만 덧붙여라. 덮어쓰지 마라.
- 이미 있는 규칙과 모순되면 사용자에게 물어봐라.`,
    // 메모리와 스킬은 읽기만 — 모델이 스킬 파일을 고치지 못하게 막습니다
    permissions: [
      { operations: ["write"], paths: ["/skills/**"], mode: "deny" },
      { operations: ["read", "write"], paths: ["/memories/**"], mode: "allow" },
      { operations: ["read", "write"], paths: ["/workspace/**"], mode: "allow" },
      { operations: ["read"], paths: ["/skills/**"], mode: "allow" },
      { operations: ["read", "write"], paths: ["/**"], mode: "deny" },
    ],
  });

  // 스킬을 store 에 미리 심어둡니다 (실전에서는 배포 시점에 넣습니다).
  // key 는 전체 경로이고, value 는 FileData 와 같은 shape 입니다
  // ({ content, mimeType?, created_at, modified_at }).
  // created_at / modified_at 을 빠뜨리면 읽을 때 undefined 가 섞입니다.
  await store.put(
    ["shared", "skills"],
    "/skills/apply-project-rules/SKILL.md",
    textFile(CODING_SKILL),
  );

  // --- 세션 1: 규칙을 알려준다
  await agent.invoke(
    {
      messages: [
        {
          role: "user",
          content: "앞으로 이 프로젝트에서는 함수를 화살표 함수로만 쓰고, 세미콜론은 생략해줘.",
        },
      ],
    },
    { configurable: { thread_id: "10-9-session-1" } },
  );

  // --- 세션 2: 완전히 새 대화. 대화 기록은 없지만 메모리는 남아 있다.
  const r2 = await agent.invoke(
    {
      messages: [{ role: "user", content: "/workspace/util.ts 에 두 수를 더하는 함수를 만들어줘." }],
    },
    { configurable: { thread_id: "10-9-session-2" } },
  );

  console.log("세션 2 응답:", r2.messages.at(-1)?.text);
  console.log("생성된 파일:", Object.keys(r2.files ?? {}));

  // 메모리가 실제로 저장됐는지 확인
  const memItems = await store.search(["users", USER_ID, "memories"]);
  console.log("저장된 메모리 키:", memItems.map((i) => i.key));
}

/* ===== 실행 ===== */
async function main() {
  await step10_1();
  await step10_2();
  await step10_3();
  await step10_4();
  await step10_5();
  await step10_6();
  await step10_7();
  await step10_8();
  await step10_9();
}

main().catch(console.error);

/**
 * Step 10 — 장기 메모리와 스킬 · 연습문제
 * 실행: npx tsx docs/reference/deepagent/step-10-memory-skills/exercise.ts
 *
 * 각 [문제 N] 아래 빈 곳을 직접 채우세요.
 * 정답은 solution.ts 에 있습니다. 먼저 스스로 풀어보세요.
 */
import "dotenv/config";
import {
  createDeepAgent,
  createMemoryMiddleware,
  createSkillsMiddleware,
  CompositeBackend,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
import { tool } from "langchain";
import * as z from "zod";

const MODEL = "anthropic:claude-sonnet-4-6";

/** state 의 files 에 넣을 FileData 객체를 만드는 헬퍼. */
function textFile(content: string) {
  const now = new Date().toISOString();
  return { content, mimeType: "text/markdown", created_at: now, modified_at: now };
}

/* ===== [문제 1] 영속되는 메모리 구성하기 =====
 * /memories/ 아래만 영속되고 나머지는 스레드 안에서만 사는 에이전트를 만드세요.
 *   - memory 옵션으로 /memories/AGENTS.md 를 주입할 것
 *   - store 를 넘길 것
 * 그리고 StateBackend 만 썼을 때(= CompositeBackend 없이) 스레드를 바꾸면
 * 기억이 사라지는 것도 직접 확인해 보세요.
 * 힌트: CompositeBackend(defaultBackend, routes)
 */
async function ex1() {
  // 여기에 작성
}

/* ===== [문제 2] 스레드를 넘는 기억 확인 =====
 * 문제 1의 에이전트로 스레드 A 에서 "나는 다크 모드를 쓴다. 기억해줘" 라고 말하고,
 * 완전히 다른 스레드 B 에서 "내 테마 취향이 뭐였지?" 라고 물어보세요.
 * 스레드 B 가 답할 수 있어야 합니다.
 * 그리고 store.search() 로 실제로 뭐가 저장됐는지 키를 출력하세요.
 * 힌트: 에이전트가 저장하게 하려면 systemPrompt 에 저장 규칙을 적어줘야 합니다.
 */
async function ex2() {
  // 여기에 작성
}

/* ===== [문제 3] 사용자별 네임스페이스 격리 =====
 * 사용자 "alice" 와 "bob" 이 서로의 메모리를 절대 볼 수 없도록
 * StoreBackend 의 namespace 를 구성하세요.
 * 같은 store 인스턴스를 공유하되 네임스페이스만 분리해야 합니다.
 * alice 로 뭔가 저장한 뒤 bob 으로 물어봤을 때 모른다고 답하는지 확인하세요.
 * 힌트: namespace 는 문자열 배열을 반환하는 팩토리 함수입니다.
 */
async function ex3() {
  // 여기에 작성
}

/* ===== [문제 4] createMemoryMiddleware 직접 쓰기 =====
 * memory: [...] 옵션 대신 createMemoryMiddleware 를 직접 붙이세요.
 *   - sources 는 /memories/AGENTS.md 와 /memories/STYLE.md 두 개
 *   - Anthropic 프롬프트 캐싱이 걸리도록 설정
 * 힌트: 미들웨어에도 backend 를 넘겨야 합니다. 에이전트와 같은 인스턴스를 쓰세요.
 */
async function ex4() {
  // 여기에 작성
}

/* ===== [문제 5] SKILL.md 작성하기 =====
 * "커밋 메시지 작성" 스킬의 SKILL.md 를 문자열로 작성하세요.
 *   - frontmatter 에 name 과 description 이 있어야 합니다
 *   - name 은 소문자·하이픈이고 부모 디렉터리 이름과 같아야 합니다
 *   - description 에는 "언제 이 스킬을 켜야 하는지" 활성화 키워드가 들어가야 합니다
 *   - 본문에는 절차를 번호 매겨 적으세요
 * 그리고 이 스킬을 files 로 주입해 에이전트가 쓰게 하세요.
 * 힌트: 경로는 /skills/{name}/SKILL.md 여야 합니다.
 */
const COMMIT_SKILL = `
// 여기에 작성
`;

async function ex5() {
  // 여기에 작성
}

/* ===== [문제 6] 스킬 vs 도구 판별 =====
 * 아래 세 가지 요구사항을 스킬 / 도구 / 서브에이전트 중 무엇으로 구현해야 할지
 * 고르고, 그 이유를 주석으로 적으세요. 그리고 하나를 골라 실제로 구현하세요.
 *
 *   (a) 현재 시각을 조회한다
 *   (b) 우리 팀의 PR 리뷰 절차(5단계)를 따르게 한다
 *   (c) 50개 파일을 각각 읽고 요약해 최종 리포트를 만든다
 *
 * 답:
 *   (a) → ?  이유:
 *   (b) → ?  이유:
 *   (c) → ?  이유:
 */
async function ex6() {
  // 여기에 작성
}

/* ===== [문제 7] 스킬을 읽기 전용으로 잠그기 =====
 * 에이전트가 /skills 아래를 읽을 수는 있지만 절대 수정할 수 없게 permissions 를 거세요.
 * /memories 와 /workspace 는 읽기·쓰기 모두 허용해야 합니다.
 * 그 외 경로는 전부 금지하세요.
 * 힌트: Step 09 의 first-match-wins 와 "마지막 빗장" 을 떠올리세요.
 */
async function ex7() {
  // 여기에 작성
}

/* ===== [문제 8] grep RAG =====
 * 벡터 DB 없이 내장 grep/glob 만으로 문서를 뒤져 답하는 에이전트를 만드세요.
 * files 로 /docs 아래에 문서 3개를 넣고, 그중 하나에만 있는 사실을 물어보세요.
 * 힌트: systemPrompt 로 "grep 으로 직접 뒤져라" 를 지시해야 합니다.
 *       files 값은 문자열이 아니라 FileData 객체입니다 — textFile() 을 쓰세요.
 */
async function ex8() {
  // 여기에 작성
}

async function main() {
  await ex1();
  await ex2();
  await ex3();
  await ex4();
  await ex5();
  await ex6();
  await ex7();
  await ex8();
}

main().catch(console.error);

/**
 * Step 10 — 장기 메모리와 스킬 · 정답과 해설
 * 실행: npx tsx docs/reference/deepagent/step-10-memory-skills/solution.ts
 *
 * exercise.ts 를 먼저 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";
import {
  createDeepAgent,
  createMemoryMiddleware,
  CompositeBackend,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
import { tool } from "langchain";
import * as z from "zod";

const MODEL = "anthropic:claude-sonnet-4-6";

/** state 의 files 에 넣을 FileData 객체를 만드는 헬퍼. */
function textFile(content: string) {
  const now = new Date().toISOString();
  return { content, mimeType: "text/markdown", created_at: now, modified_at: now };
}

/* ===== [정답 1] 영속되는 메모리 구성하기 =====
 * 핵심은 "memory 옵션이 영속을 만들어주지 않는다" 는 것입니다.
 * memory: ["/memories/AGENTS.md"] 는 그냥 "이 경로의 파일을 시스템 프롬프트에 넣어라" 일 뿐입니다.
 * 그 경로가 실제로 어디에 저장되는지는 backend 가 정합니다.
 *
 * StateBackend 만 쓰면 파일이 그래프 state 에 들어가고, state 는 thread_id 에 묶입니다.
 * 스레드가 바뀌면 state 도 새것이라 파일이 없습니다 — memory 옵션을 줬는데도 아무것도 안 떠오릅니다.
 * 에러는 안 납니다. 그냥 조용히 빈 메모리로 동작합니다.
 *
 * 그래서 CompositeBackend 로 /memories/ 만 StoreBackend 로 라우팅해야 합니다.
 * Store 는 thread 바깥에 있으므로 스레드가 바뀌어도 남습니다.
 */
function makeMemoryAgent(store: InMemoryStore, userId = "demo-user") {
  const backend = new CompositeBackend(
    new StateBackend(), // 기본: 스레드 안에서만 사는 작업 공간
    {
      "/memories/": new StoreBackend({ namespace: () => ["users", userId, "memories"] }),
    },
  );

  return createDeepAgent({
    model: MODEL,
    backend,
    store, // StoreBackend 를 쓰면 store 를 반드시 넘겨야 합니다
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"],
    systemPrompt: `너는 사용자를 기억하는 도우미다.

## 메모리 규칙
- 사용자가 "기억해", "앞으로" 라고 말하면 /memories/AGENTS.md 에 저장해라.
- 저장 전에 read_file 로 현재 내용을 먼저 읽어라.
- 기존 내용을 덮어쓰지 말고 edit_file 로 항목을 추가해라.`,
  });
}

async function sol1() {
  console.log("\n===== [정답 1] =====");
  const store = new InMemoryStore();
  const agent = await makeMemoryAgent(store);
  const r = await agent.invoke(
    { messages: [{ role: "user", content: "안녕" }] },
    { configurable: { thread_id: "sol-1" } },
  );
  console.log("응답:", r.messages.at(-1)?.text);
}

/* ===== [정답 2] 스레드를 넘는 기억 확인 =====
 * 이 문제의 포인트는 "대화 기록" 과 "메모리" 가 완전히 다른 것이라는 점입니다.
 *
 * - 대화 기록(checkpointer): thread_id 에 묶임. 스레드 B 는 A 의 대화를 전혀 모릅니다.
 * - 메모리(store): thread 바깥. 스레드 B 도 읽습니다.
 *
 * 그래서 스레드 B 는 "우리가 그런 얘기를 했다" 는 건 모르지만
 * "이 사용자는 다크 모드를 쓴다" 는 사실은 압니다. 이 구분이 장기 메모리의 본질입니다.
 *
 * 함정: 모델이 저장을 안 하면 아무 일도 안 일어납니다. memory 옵션은 "읽기" 만 자동이고
 * "쓰기" 는 모델이 write_file/edit_file 을 불러야 합니다. systemPrompt 에 저장 규칙이
 * 없으면 모델은 그냥 "알겠습니다" 하고 넘어갑니다 — 그리고 다음 스레드에서 아무것도 모릅니다.
 */
async function sol2() {
  console.log("\n===== [정답 2] =====");
  const store = new InMemoryStore();
  const agent = await makeMemoryAgent(store);

  // 스레드 A: 알려주고 저장시킨다
  await agent.invoke(
    { messages: [{ role: "user", content: "나는 다크 모드를 쓴다. 기억해줘." }] },
    { configurable: { thread_id: "sol-2-A" } },
  );

  // 스레드 B: 완전히 새 대화. 대화 기록은 공유되지 않는다.
  const rB = await agent.invoke(
    { messages: [{ role: "user", content: "내 테마 취향이 뭐였지?" }] },
    { configurable: { thread_id: "sol-2-B" } },
  );
  console.log("스레드 B 응답:", rB.messages.at(-1)?.text);

  // store 에 실제로 저장된 것 확인
  const items = await store.search(["users", "demo-user", "memories"]);
  console.log("저장된 키:", items.map((i) => i.key));
}

/* ===== [정답 3] 사용자별 네임스페이스 격리 =====
 * namespace 팩토리가 반환하는 배열이 곧 저장 위치의 계층 경로입니다.
 * userId 를 그 경로에 넣으면 alice 와 bob 의 파일이 물리적으로 다른 곳에 저장됩니다.
 *
 * ⚠️ 이게 이 스텝에서 가장 위험한 지점입니다.
 * namespace: () => ["memories"] 처럼 사용자 구분 없이 고정 문자열을 쓰면,
 * 모든 사용자가 같은 /memories/AGENTS.md 를 공유합니다.
 * alice 가 "내 계좌번호는 ..." 이라고 저장하면 bob 의 에이전트가 그걸 시스템 프롬프트로 읽습니다.
 * 에러도 경고도 없습니다. 데모에서는 사용자가 하나뿐이라 절대 발견되지 않고,
 * 프로덕션에 올라가서 두 번째 사용자가 생기는 순간 정보가 샙니다.
 *
 * 그리고 userId 는 반드시 "서버가 인증으로 확인한 값" 이어야 합니다.
 * 클라이언트가 보낸 값을 그대로 쓰면 남의 네임스페이스를 지목할 수 있습니다.
 */
async function sol3() {
  console.log("\n===== [정답 3] =====");
  const store = new InMemoryStore(); // store 는 공유. 네임스페이스만 분리.

  const alice = await makeMemoryAgent(store, "alice");
  const bob = await makeMemoryAgent(store, "bob");

  await alice.invoke(
    { messages: [{ role: "user", content: "내 사번은 A-1234야. 기억해줘." }] },
    { configurable: { thread_id: "sol-3-alice" } },
  );

  const rBob = await bob.invoke(
    { messages: [{ role: "user", content: "내 사번이 뭐였지?" }] },
    { configurable: { thread_id: "sol-3-bob" } },
  );
  // bob 은 alice 의 메모리를 볼 수 없으므로 모른다고 답해야 합니다
  console.log("bob 응답:", rBob.messages.at(-1)?.text);

  console.log("alice 네임스페이스:", (await store.search(["users", "alice", "memories"])).length);
  console.log("bob 네임스페이스:", (await store.search(["users", "bob", "memories"])).length);
}

/* ===== [정답 4] createMemoryMiddleware 직접 쓰기 =====
 * memory: [...] 옵션은 내부적으로 이 미들웨어를 붙여주는 축약형입니다.
 * 직접 붙이면 addCacheControl 을 켤 수 있습니다.
 *
 * addCacheControl 이 중요한 이유: 메모리는 "매 턴 똑같이 붙는 큰 덩어리" 입니다.
 * 캐싱을 안 걸면 매 턴 전체 메모리를 다시 토큰으로 계산해서 비용을 냅니다.
 * 메모리가 커질수록 이 비용이 선형으로 커집니다.
 *
 * 주의: 미들웨어에 넘기는 backend 는 에이전트의 backend 와 같은 인스턴스여야 합니다.
 * 다른 인스턴스를 주면 미들웨어는 엉뚱한 곳에서 파일을 찾고, 조용히 빈 메모리를 주입합니다.
 */
async function sol4() {
  console.log("\n===== [정답 4] =====");
  const store = new InMemoryStore();

  // backend 를 변수로 빼서 에이전트와 미들웨어가 같은 인스턴스를 쓰게 합니다
  const backend = new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ namespace: () => ["users", "demo-user", "memories"] }),
  });

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    middleware: [
      createMemoryMiddleware({
        backend, // ← 에이전트와 같은 인스턴스
        sources: ["/memories/AGENTS.md", "/memories/STYLE.md"], // 순서대로 주입
        addCacheControl: true, // Anthropic 프롬프트 캐싱
      }),
    ],
  });

  console.log("createMemoryMiddleware 직접 구성 완료 (sources 2개, 캐싱 on)");
  return agent;
}

/* ===== [정답 5] SKILL.md 작성하기 =====
 * frontmatter 의 description 이 이 파일에서 가장 중요한 한 줄입니다.
 * 이유: 모델은 평소에 SKILL.md 본문을 안 봅니다. name 과 description 만 봅니다
 * (progressive disclosure). 즉 description 이 "이 스킬을 켤지 말지" 를 결정하는
 * 유일한 정보입니다.
 *
 * 그래서 description 에는 "무엇을 하는가" 만 쓰면 안 되고
 * "언제 켜야 하는가" 를 활성화 키워드와 함께 써야 합니다.
 * "커밋 메시지를 잘 쓴다" (X) → 모델이 언제 켤지 모릅니다.
 * "커밋 메시지를 작성할 때 사용한다. commit, 커밋, PR 제목 요청에 활성화된다" (O)
 *
 * name 은 소문자·하이픈이고 부모 디렉터리 이름과 같아야 합니다.
 * /skills/commit-message/SKILL.md 면 name: commit-message 여야 합니다.
 */
const COMMIT_SKILL = `---
name: commit-message
description: 커밋 메시지를 작성할 때 사용한다. commit, 커밋, 커밋 메시지 작성, PR 제목 요청에 활성화된다.
---

# 커밋 메시지 작성 절차

1. git diff 로 실제 변경 내용을 확인한다. 추측하지 마라.
2. 변경의 종류를 정한다: feat / fix / docs / refactor / test / chore
3. 아래 형식으로 작성한다.

   <type>: <한 줄 요약 50자 이내, 한국어, 마침표 없음>

   <본문: 왜 이 변경이 필요했는지. 무엇을 바꿨는지가 아니라 왜인지를 쓴다>

4. 한 커밋에 여러 종류의 변경이 섞여 있으면 커밋을 나누라고 제안한다.
5. 비밀값이나 개인정보가 diff 에 있으면 커밋을 만들지 말고 경고한다.
`;

async function sol5() {
  console.log("\n===== [정답 5] =====");

  const agent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    skills: ["/skills/"],
  });

  const result = await agent.invoke(
    {
      messages: [{ role: "user", content: "커밋 메시지를 써줘. 로그인 버그를 고쳤어." }],
      files: {
        // 경로의 디렉터리 이름(commit-message)과 frontmatter 의 name 이 일치해야 합니다
        "/skills/commit-message/SKILL.md": textFile(COMMIT_SKILL),
      },
    },
    { configurable: { thread_id: "sol-5" } },
  );

  console.log("응답:", result.messages.at(-1)?.text);
}

/* ===== [정답 6] 스킬 vs 도구 판별 =====
 *
 * (a) 현재 시각 조회 → 도구
 *     이유: 모델이 "알" 수 없는 외부 사실이고, 결정적인 코드 실행이 필요합니다.
 *     절차서로는 시각을 알 수 없습니다. 스킬로 "시각을 알아내라" 고 써봐야 모델은 못 합니다.
 *
 * (b) 팀의 PR 리뷰 절차 5단계 → 스킬
 *     이유: 새로운 능력이 아니라 "이미 할 수 있는 일(읽기·분석)을 우리 방식대로 하는 법" 입니다.
 *     코드로 강제할 필요도 없고, 강제할 수도 없습니다(판단이 필요하니까).
 *     도구로 만들면 각 단계를 함수로 쪼개야 하는데 그건 절차가 아니라 파이프라인입니다.
 *
 * (c) 50개 파일 각각 요약 → 서브에이전트
 *     이유: 컨텍스트 격리가 목적입니다. 50개 파일 본문을 부모 컨텍스트에 다 넣으면
 *     컨텍스트가 터집니다. 서브에이전트에게 파일 하나씩 주고 "요약만" 받아오면
 *     부모는 요약 50개만 갖습니다. 병렬 실행 이득도 있습니다.
 *
 * 아래는 (a) 를 도구로 구현한 것입니다.
 */
const getCurrentTime = tool(
  async ({ timezone }) => new Date().toLocaleString("ko-KR", { timeZone: timezone }),
  {
    name: "get_current_time",
    description: "지정한 시간대의 현재 시각을 반환한다.",
    schema: z.object({ timezone: z.string().describe("IANA 시간대. 예: Asia/Seoul") }),
  },
);

async function sol6() {
  console.log("\n===== [정답 6] =====");
  const agent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    tools: [getCurrentTime],
  });

  const r = await agent.invoke(
    { messages: [{ role: "user", content: "서울 지금 몇 시야?" }] },
    { configurable: { thread_id: "sol-6" } },
  );
  console.log("응답:", r.messages.at(-1)?.text);
}

/* ===== [정답 7] 스킬을 읽기 전용으로 잠그기 =====
 * 스킬을 왜 잠가야 하나? 스킬은 "모델이 따라야 할 규칙" 인데,
 * 모델이 그 규칙 파일을 수정할 수 있다면 규칙이 아닙니다.
 * 모델이 절차가 귀찮아서 SKILL.md 를 고쳐버리는 일은 실제로 일어납니다.
 * 그리고 다음 세션부터 그 잘못된 스킬이 영구히 적용됩니다.
 *
 * Step 09 의 규칙 그대로입니다: first-match-wins, 기본은 allow, 마지막 빗장 필수.
 * write deny 를 read allow 보다 먼저 둡니다.
 *
 * 참고: 공식 문서 일부에 permissions 의 mode 로 "interrupt" 가 나오지만,
 * deepagents 1.11.0 의 PermissionMode 는 "allow" | "deny" 뿐입니다.
 * 스킬 수정에 사람 승인을 걸고 싶으면 interruptOn: { write_file: true } 를 쓰세요.
 */
async function sol7() {
  console.log("\n===== [정답 7] =====");
  const store = new InMemoryStore();

  const backend = new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({ namespace: () => ["users", "demo-user", "memories"] }),
    "/skills/": new StoreBackend({ namespace: () => ["shared", "skills"] }),
  });

  const agent = await createDeepAgent({
    model: MODEL,
    backend,
    store,
    checkpointer: new MemorySaver(),
    memory: ["/memories/AGENTS.md"],
    skills: ["/skills/"],
    permissions: [
      // 1) 스킬 쓰기 금지 — read allow 보다 먼저 와야 의도가 명확합니다
      { operations: ["write"], paths: ["/skills/**"], mode: "deny" },
      { operations: ["read"], paths: ["/skills/**"], mode: "allow" },
      // 2) 메모리와 작업공간은 읽기·쓰기 허용
      { operations: ["read", "write"], paths: ["/memories/**"], mode: "allow" },
      { operations: ["read", "write"], paths: ["/workspace/**"], mode: "allow" },
      // 3) 마지막 빗장 — 없으면 나머지가 전부 기본 allow 로 열립니다
      { operations: ["read", "write"], paths: ["/**"], mode: "deny" },
    ],
  });

  console.log("스킬 읽기 전용 / 메모리·작업공간 읽기쓰기 / 나머지 금지 구성 완료");
  return agent;
}

/* ===== [정답 8] grep RAG =====
 * 벡터 DB 도, 임베딩도, 인덱싱 파이프라인도 없습니다. 내장 grep/glob 이 전부입니다.
 *
 * 이게 되는 이유: Deep Agent 는 여러 턴을 돌 수 있습니다.
 * 한 번의 유사도 검색으로 정답을 맞혀야 하는 단발성 RAG 와 달리,
 * 에이전트는 grep 해보고 → 아니면 다른 키워드로 다시 grep 하고 → 파일을 읽고 → 또 뒤집니다.
 * 사람이 코드베이스에서 뭔가 찾는 방식과 같습니다.
 *
 * 한계: grep 은 정확한 문자열 매칭이라 "인증" 을 찾을 때 "로그인" 이라고 적힌 문서를 못 찾습니다.
 * 어휘가 갈리는 코퍼스나 문서가 수천 개면 벡터 검색이 낫습니다.
 * 반대로 문서가 수십 개고 용어가 통제돼 있으면 grep 이 더 정확하고 훨씬 쌉니다.
 *
 * 함정: files 값은 문자열이 아니라 FileData 객체입니다.
 * "/docs/a.md": "내용" 이라고 쓰면 타입 에러가 납니다.
 */
async function sol8() {
  console.log("\n===== [정답 8] =====");

  const agent = await createDeepAgent({
    model: MODEL,
    backend: new StateBackend(),
    checkpointer: new MemorySaver(),
    systemPrompt: `질문에 답하려면 /docs 안을 직접 뒤져라.

1. glob 으로 문서 목록을 본다.
2. grep 으로 키워드를 찾는다. 첫 검색이 실패하면 다른 표현으로 다시 시도해라.
3. 찾은 파일을 read_file 로 읽고 근거를 인용해 답한다.
4. 문서에 없으면 "문서에 없다" 고 답해라. 지어내지 마라.`,
  });

  const result = await agent.invoke(
    {
      messages: [{ role: "user", content: "배포 롤백은 어떻게 해?" }],
      files: {
        "/docs/auth.md": textFile("# 인증\n\nAPI 키를 ANTHROPIC_API_KEY 환경변수에 넣으세요."),
        "/docs/deploy.md": textFile(
          "# 배포\n\ndocker build 로 이미지를 만듭니다.\n\n## 롤백\n\n`kubectl rollout undo deployment/app` 으로 직전 버전으로 되돌립니다.",
        ),
        "/docs/style.md": textFile("# 코드 스타일\n\n들여쓰기는 스페이스 2칸."),
      },
    },
    { configurable: { thread_id: "sol-8" } },
  );

  // /docs/deploy.md 에만 있는 kubectl rollout undo 를 찾아내야 정답입니다
  console.log("응답:", result.messages.at(-1)?.text);
}

async function main() {
  await sol1();
  await sol2();
  await sol3();
  await sol4();
  await sol5();
  await sol6();
  await sol7();
  await sol8();
}

main().catch(console.error);