// 摘自 claude-code-rev/src/constants/prompts.ts
export function getSystemPrompt(context: SystemContext): string {
  return [
    getSimpleIntroSection(),
    getUsingYourToolsSection(context.enabledTools),
    // === BOUNDARY MARKER - DO NOT MOVE OR REMOVE ===
    SYSTEM_PROMPT_DYNAMIC_BOUNDARY,
    ...resolvedDynamicSections,
  ].filter(s => s !== null).join('

')
}

// 动态装配过程示例 (getSessionSpecificGuidanceSection)
function getSessionSpecificGuidanceSection(context: SystemContext): string {
  const guidance = [];
  if (context.enabledFeatures.includes('tengu_scratch')) {
    guidance.push(`Scratchpad is enabled at ${context.scratchpadDir}. Use it for durable notes.`);
  }
  if (isNonInteractive(context)) {
    guidance.push(`You are in non-interactive mode. Do NOT use AskUserQuestion.`);
  }
  return guidance.join('
');
}

// 摘自 claude-code-rev/src/constants/prompts.ts
/**
 * Boundary marker separating static (cross-org cacheable) content from dynamic content.
 * Everything BEFORE this marker in the system prompt array can use scope: 'global'.
 * Everything AFTER contains user/session-specific content and should not be cached.
 *
 * WARNING: Do not remove or reorder this marker without updating cache logic...
 */
export const SYSTEM_PROMPT_DYNAMIC_BOUNDARY = '__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__'

// 组装逻辑：
...(shouldUseGlobalCacheScope() ? [SYSTEM_PROMPT_DYNAMIC_BOUNDARY] : []),
// --- Dynamic content (registry-managed) ---
...resolvedDynamicSections,

// 摘自 claude-code-rev/src/constants/prompts.ts
function getSimpleDoingTasksSection(): string {
  const codeStyleSubitems = [
    `Don't add features, refactor code, or make "improvements" beyond what was asked.`,
    `A bug fix doesn't need surrounding code cleaned up.`,
    `Don't add error handling, fallbacks, or validation for scenarios that can't happen.`,
    `If an approach fails, diagnose why before switching tactics—read the error, check your assumptions...`,
    `In general, do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first.`
  ];
  return [`# Doing tasks`, ...prependBullets(codeStyleSubitems)].join(`
`);
}

// 摘自 claude-code-rev/src/tools/AgentTool/built-in/exploreAgent.ts
export const EXPLORE_AGENT: BuiltInAgentDefinition = {
  agentType: 'explorer',
  whenToUse: 'When you need to search and explore a codebase without making changes.',
  tools: [
    FILE_READ_TOOL_NAME,
    GLOB_TOOL_NAME,
    GREP_TOOL_NAME,
    BASH_TOOL_NAME,
  ],
  // 物理移除了 Edit 和 Write 工具
  disallowedTools: [FILE_EDIT_TOOL_NAME, FILE_WRITE_TOOL_NAME],
}

// 摘自 exploreAgent.ts  提示词
=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
- Creating new files (no Write, touch, or file creation of any kind)
- Modifying existing files (no Edit operations)

// 摘自 claude-code-rev/src/services/tools/toolExecution.ts
export async function* runToolUse(toolUse, assistantMessage, ...) {
  const toolName = toolUse.name;
  let tool = findToolByName(toolUseContext.options.tools, toolName);

  // 第一道关卡：别名降级匹配
  if (!tool) {
    const fallbackTool = findToolByName(getAllBaseTools(), toolName);
    if (fallbackTool && fallbackTool.aliases?.includes(toolName)) {
      tool = fallbackTool;
    }
  }
  
  // 未找到直接遣返
  if (!tool) {
    yield { message: createToolUseErrorMessage(`No such tool available: ${toolName}`) };
    return;
  }

  // 极具实战价值的 Hint 注入
  const hint = buildSchemaNotSentHint(tool, toolUseContext.messages, ...);
  if (hint) {
    // 引导模型使用 ToolSearch 工具自愈
  }
  
  // 进入 7 步流水线
  for await (const update of streamedCheckPermissionsAndCallTool(...)) {
     yield update;
  }
}

// 摘自 claude-code-rev/src/services/tools/toolHooks.ts
export async function* runPreToolUseHooks(
  toolUseContext: ToolUseContext,
  tool: Tool,
  processedInput: Record
): AsyncGenerator<
  | { type: 'hookPermissionResult'; hookPermissionResult: PermissionResult }
  | { type: 'hookUpdatedInput'; updatedInput: Record }
  | { type: 'preventContinuation'; shouldPreventContinuation: boolean }
  | { type: 'stopReason'; stopReason: string }
  | { type: 'stop' }
> {
  // 执行拦截逻辑...
}

// 摘自 claude-code-rev/src/services/tools/toolHooks.ts
export function resolveHookPermissionDecision(
  hookResult: HookPermissionResult,
  toolDef: Tool,
): PermissionDecision {
  // 1. Hook 否决绝对优先
  if (hookResult.behavior === 'deny') return 'deny';
  
  // 2. 强制升维：如果工具本身需要交互，而 Hook 只是投了 allow
  if (toolDef.requiresInteraction && hookResult.behavior === 'allow') {
    if (!hookResult.updatedInput) {
       return 'ask'; // 机器不能替人类签免责声明
    }
  }
  
  // 3. 遵从 Hook 或系统默认
  return hookResult.behavior;
}

// 逻辑还原：推测性执行与分类器
const riskLevel = calculateRiskLevel(command);
if (riskLevel === 'CRITICAL_RISK') {
  // 识别高危特征：sudo, rm -rf, iptables 等
  triggerHumanInTheLoop(command);
}

// Explore Agent 环境下的 Bash 物理阉割
const BASH_READONLY_MODE = true;
if (BASH_READONLY_MODE && isMutatingCommand(command)) {
  throw new Error("Read-only environment violation. You cannot write files in Explorer mode.");
}

// 逻辑还原：PostToolUseFailure Hooks 的异常捕获与注入
if (error instanceof ENOENT) {
  return {
    type: 'tool_result',
    content: `Error: ENOENT: no such file or directory, open '${file}'.`,
    additionalContext: `[System Hint]: Do not guess the file path again. Use the GlobTool to search for the file in the current directory first.`
  };
}

if (isDependencyError(error)) {
  return {
    type: 'tool_result',
    content: truncateError(error, 500),
    additionalContext: `[System Hint]: A dependency error occurred. Check if there is an nvmrc or package.json engines field before attempting to fix the dependencies.`
  };
}

// 摘自 claude-code-rev/src/services/agent/AgentCoordinator.ts
const MAX_SPAWN_DEPTH = 3; // 硬限制：最大派生深度，防止递归爆炸

export class AgentCoordinator {
  private spawnDepth: number;

  constructor(depth = 0) {
    this.spawnDepth = depth;
    if (this.spawnDepth > MAX_SPAWN_DEPTH) {
      throw new SpawnDepthExceededError(
        `Agent spawn depth ${depth} exceeds limit ${MAX_SPAWN_DEPTH}`
      );
    }
  }

  async delegateTask(task: TaskContext, strategy: DelegationStrategy) {
    if (strategy === 'parallel') {
      // 并行派生：同时召唤 N 个 Explorer 特工，覆盖 N 个子路径
      const explorers = task.subPaths.map(path =>
        this.spawnSubAgent(EXPLORE_AGENT, { path }, this.spawnDepth + 1)
      );
      const reports = await Promise.all(explorers);
      return this.synthesizeReports(reports); // 压缩 N*5000 token -> 几十行摘要
    } else if (strategy === 'sequential') {
      // 串行派生：先规划，再执行，保证依赖顺序
      const plan = await this.spawnSubAgent(PLANNER_AGENT, task, this.spawnDepth + 1);
      return this.spawnSubAgent(EXECUTION_AGENT, plan, this.spawnDepth + 1);
    }
  }
}

// 摘自 claude-code-rev/src/services/compact/autoCompact.ts
export async function autoCompactContext(session: SessionMemory) {
  const currentTokens = session.getEstimatedTokens();
  if (currentTokens > CRITICAL_THRESHOLD) {
    // 触发五层压缩管线
    const compressor = new ContextCompressor(session);
    await compressor.runPipeline([
      snipHistory,           // 裁剪无关的闲聊历史
      collapseFileReads,     // 折叠过长的大文件读取记录
      summarizeToolCalls,    // 将工具调用的海量日志变成精简摘要
      reactiveMicroCompact   // 在关键决策点进行高维语义压缩
    ]);
  }
}

// 逻辑还原：语义压缩机制
async function reactiveMicroCompact(history: Message[]) {
  // 提取一段复杂的重构尝试历史
  const complexHistory = extractHeavySubtask(history);
  
  // 召唤一个专用的小模型，让它“提纯”这段记忆
  const summary = await callSummarizerModel({
    prompt: `You are an expert summarizer. The following is a log of an agent attempting to refactor a class. 
    Compress this log into a tight, factual summary. Keep all critical file paths, error codes, and decisions made. 
    DISCARD all conversational filler and intermediate failed attempts that were eventually recovered.`
  });

  // 用这段提纯后的高维摘要，替换掉原本占用上万 Token 的原始消息
  return replaceWithSummary(history, summary);
}

// Agent Tool 的 isolation 参数
interface AgentToolParams {
  prompt: string;
  isolation?: "worktree";  // 启用 worktree 隔离
  subagent_type?: string;
}

// EnterWorktree 工具：创建隔离副本
async function enterWorktree(branchName: string) {
  // 1. git worktree add /tmp/worktree-{uuid} -b {branch}
  // 2. 切换 CWD 到新 worktree
  // 3. Agent 的所有文件操作都发生在隔离副本中
  return { worktreePath, branch };
}

// ExitWorktree：清理或保留
async function exitWorktree(worktree: WorktreeContext) {
  if (worktree.hasChanges) {
    // 有改动：保留 worktree，返回路径和分支名
    return { path: worktree.path, branch: worktree.branch };
  } else {
    // 无改动：自动清理
    exec(`git worktree remove ${worktree.path}`);
  }
}

// 流式工具执行的核心模式：AsyncGenerator
export async function* streamedCheckPermissionsAndCallTool(
  toolUse: ToolUseBlock,
  tool: Tool,
  context: ToolUseContext
): AsyncGenerator<ToolUpdate> {

  // 阶段1：流入的同时进行 Zod 校验（零等待）
  const parsed = tool.inputSchema.safeParse(toolUse.input);
  if (!parsed.success) {
    yield { type: 'error', message: formatZodError(parsed.error) };
    return;
  }

  // 阶段2：Hook 拦截（与渲染并行）
  for await (const hookResult of runPreToolUseHooks(context, tool, parsed.data)) {
    yield hookResult;
    if (hookResult.type === 'stop') return;
  }

  // 阶段3：真正的底层执行
  const result = await tool.call(parsed.data, context);
  yield { type: 'result', data: result };
}

// CLAUDE.md 加载机制（会话启动时自动注入）
function loadProjectInstructions(projectDir: string): string[] {
  const sources = [
    path.join(os.homedir(), 'CLAUDE.md'),        // 全局级
    path.join(projectDir, 'CLAUDE.md'),           // 项目级
    path.join(os.homedir(), '.claude/CLAUDE.md'),  // 用户级
  ];
  return sources
    .filter(fs.existsSync)
    .map(f => fs.readFileSync(f, 'utf-8'));
}

// Scratchpad（实验性功能）
if (context.enabledFeatures.includes('tengu_scratch')) {
  guidance.push(
    `Scratchpad is enabled at ${context.scratchpadDir}.`,
    `Use it for durable notes that persist across conversations.`
  );
}

// Memory 系统：自动读取 MEMORY.md 索引
// 每个记忆是一个独立的 .md 文件，MEMORY.md 是索引
// 模型通过 Read 工具按需加载具体记忆

// Skill 目录结构
.claude/skills/
  deploy-to-production/
    SKILL.md              // 主文件：触发条件 + 使用规则 + Gotchas
    references/
      api-docs.md         // 详细 API 参考（按需读取）
    scripts/
      validate-env.sh     // 辅助脚本

// SKILL.md 结构示例
---
description: "Use when: deploying to production, running release pipeline.
  Trigger: deploy, release, ship, 上线.
  NOT for: local dev server, staging."
---

# Deploy to Production

## Steps
1. Run pre-flight checks...
2. Build production bundle...

## Gotchas
- NEVER skip the database migration check
- CloudFront cache invalidation takes 5-15 min
- Why: Last time we skipped migration, prod was down 2h

// MCP Server 配置（settings.json）
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "..." }
    }
  }
}

// 启动时：Agent 自动发现 MCP 工具
for (const [name, config] of Object.entries(mcpServers)) {
  const tools = await mcpClient.listTools(name);
  // 注册为 mcp__{server}__{tool} 格式
  // 例如：mcp__github__create_issue
  registeredTools.push(...tools.map(t => wrapAsMcpTool(name, t)));
}

// ToolSearch：按需获取延迟加载的工具 Schema
interface ToolSearchParams {
  query: string;       // "select:mcp__github__create_issue" 或关键词
  max_results?: number; // 默认 5
}

// 系统提示词中的延迟工具声明
`The following deferred tools are available via ToolSearch:
mcp__github__create_issue
mcp__github__search_code
mcp__postgres__query
mcp__slack__send_message
...`

// 当模型调用未加载的工具时，系统注入自愈 Hint
if (isDeferred(toolName)) {
  return buildSchemaNotSentHint(tool);
  // Hint: "This tool's schema hasn't been loaded yet.
  //  Use ToolSearch to fetch it first, then retry."
}

// Agent OS 架构映射（概念对照）

// 内核 = System Prompt（静态规则 + 行为宪法）
getSystemPrompt(context) → "Kernel Boot"

// 系统调用 = 内置工具
tools: [Read, Edit, Write, Bash, Glob, Grep, Agent, ToolSearch]
       → "Syscall Table"

// 用户态程序 = Skills
.claude/skills/* → "Userspace Programs (installable, removable)"

// 设备驱动 = MCP Servers
mcpServers: { github, postgres, slack } → "Device Drivers"

// 进程管理 = Agent Coordinator
AgentTool.spawn(EXPLORE_AGENT)  → "fork() + exec()"
AgentTool.spawn(VERIFY_AGENT)   → "fork() + exec()"
MAX_SPAWN_DEPTH = 3             → "Process Tree Limit"

// 内存管理 = Context Compressor
autoCompactContext()            → "Garbage Collection"
CRITICAL_THRESHOLD = 0.50       → "OOM Killer Threshold"

// 访问控制 = Permission State Machine
resolveHookPermissionDecision() → "ACL Check"
requiresInteraction: true      → "sudo prompt"

// 文件系统 = CLAUDE.md + memory/ + Scratchpad
loadProjectInstructions()       → "/etc/config"
MEMORY.md                       → "/var/log"
Scratchpad                      → "/tmp"