nine-hundred 0.0.1

package/dist/agent/permission/util/detect-language-interpreter.js

@@ -0,0 +1,66 @@
+// Matches python / python2 / python3 / python3.11, and the pypy family.
+// `py` (Windows launcher) is handled separately.
+const PYTHON_INTERPRETER = /^(?:python[23]?(\.\d+)?|pypy[23]?(\.\d+)?|py)$/;
+// JavaScript / TypeScript runtimes. Each entry is a recognized first-token
+// that should be redirected to `run_js_tool`.
+const JS_TS_INTERPRETERS = new Set(['node', 'nodejs', 'ts-node', 'tsx', 'deno', 'bun']);
+// Other language runtimes / compilers. These do not have a dedicated tool,
+// so the caller only needs the language name for the error message.
+const OTHER_LANGUAGE_INTERPRETERS = {
+    java: 'Java',
+    javac: 'Java',
+    go: 'Go',
+    ruby: 'Ruby',
+    irb: 'Ruby',
+    rustc: 'Rust',
+    cargo: 'Rust',
+    dotnet: 'C#/.NET',
+    mono: 'C#/.NET',
+    php: 'PHP',
+    perl: 'Perl',
+    lua: 'Lua',
+    rscript: 'R',
+    scala: 'Scala',
+    kotlin: 'Kotlin',
+    groovy: 'Groovy',
+    swift: 'Swift',
+    dart: 'Dart',
+    elixir: 'Elixir',
+    julia: 'Julia',
+};
+/**
+ * Check whether a shell command string invokes an interpreter for a
+ * non-shell language. The first token of each chain segment is compared
+ * against known interpreter names. Python / JS / TS hits also carry a
+ * `tool` field pointing to the suggested dedicated tool.
+ *
+ * Shell and shell-script invocations (`bash script.sh`, `sh script.sh`,
+ * `zsh script.zsh`) are not flagged. Package managers (`npm install`,
+ * `cargo build`, `go build`) are likewise allowed because the first token
+ * is not a direct interpreter — but note that `go run`, `cargo run`,
+ * `npm test` etc. ARE flagged because they execute code under the hood
+ * and the LLM should be redirected to the dedicated tool when possible.
+ */
+export function detectLanguageInterpreter(command) {
+    const segments = command.split(/&&|\|\||;|\||&/);
+    for (const raw of segments) {
+        const segment = raw.trim();
+        if (!segment)
+            continue;
+        const firstTokenMatch = segment.match(/^([^\s"']+)/);
+        if (!firstTokenMatch)
+            continue;
+        const firstToken = firstTokenMatch[1];
+        if (PYTHON_INTERPRETER.test(firstToken)) {
+            return { found: true, lang: 'Python', tool: 'run_py_tool', segment };
+        }
+        if (JS_TS_INTERPRETERS.has(firstToken)) {
+            return { found: true, lang: 'JavaScript/TypeScript', tool: 'run_js_tool', segment };
+        }
+        const otherLang = OTHER_LANGUAGE_INTERPRETERS[firstToken];
+        if (otherLang) {
+            return { found: true, lang: otherLang, segment };
+        }
+    }
+    return { found: false };
+}

package/dist/agent/permission/util/detect-safe-command.js

@@ -0,0 +1,61 @@
+// Single-token safe commands. Compared case-insensitively so that
+// PowerShell's mixed-case forms (`Get-ChildItem`) match.
+//
+// Cross-platform: POSIX (Linux / macOS), Windows CMD, and PowerShell
+// aliases are all listed together.
+//
+// Note: `ls` etc. with sensitive-path arguments (e.g. `ls /etc/shadow`)
+// are NOT filtered here. The risk surface is metadata only and the
+// dangerous-op check still catches content reads via `cat`/`Get-Content`.
+const SAFE_COMMANDS = new Set([
+    // POSIX (Linux / macOS)
+    'ls', 'pwd', 'cat', 'head', 'tail', 'grep', 'find', 'echo', 'date', 'whoami',
+    // Windows CMD
+    'dir', 'type', 'findstr',
+    // PowerShell (canonical + common aliases, all lowercased)
+    'get-childitem', 'gci',
+    'get-location', 'gl', 'pwd', // `pwd` doubles as a PowerShell alias for Get-Location
+    'get-content', 'gc', 'cat', 'type',
+    'select-string', 'sls',
+    'get-item', 'gi',
+    'write-output',
+    'get-date',
+]);
+// Git subcommands the user can run without confirmation. Each entry is
+// compared as the second token of a `git ...` segment, lowercased.
+// Only read-only subcommands are listed — anything that mutates the
+// working tree (checkout, commit, push, pull, reset, clean, merge,
+// rebase) or touches the network (fetch, clone) falls through to ask.
+const SAFE_GIT_SUBCOMMANDS = new Set(['status', 'diff', 'log']);
+/**
+ * Check whether a shell command string consists entirely of safe
+ * read-only commands. Every chain segment must independently qualify
+ * (first token in `SAFE_COMMANDS`, or `git` paired with a subcommand in
+ * `SAFE_GIT_SUBCOMMANDS`) for the whole command to be considered safe.
+ *
+ * The caller is expected to run this AFTER the dangerous-op check, so
+ * chains like `ls && rm -rf /` are already short-circuited and never
+ * reach this function as a candidate for `allow`.
+ */
+export function detectSafeCommand(command) {
+    const segments = command.split(/&&|\|\||;|\||&/);
+    for (const raw of segments) {
+        const segment = raw.trim();
+        if (!segment)
+            continue;
+        const firstTokenMatch = segment.match(/^([^\s"']+)/);
+        if (!firstTokenMatch)
+            continue;
+        const firstToken = firstTokenMatch[1].toLowerCase();
+        if (SAFE_COMMANDS.has(firstToken))
+            continue;
+        if (firstToken === 'git') {
+            const subMatch = segment.match(/^git\s+(\S+)/);
+            const sub = subMatch?.[1]?.toLowerCase();
+            if (sub && SAFE_GIT_SUBCOMMANDS.has(sub))
+                continue;
+        }
+        return { safe: false };
+    }
+    return { safe: true };
+}

package/dist/agent/permission/util/index.js

@@ -0,0 +1,16 @@
+// Public surface of the `util/` folder. Each scanner / helper below
+// lives in its own file; this module re-exports the union so existing
+// callers can keep importing from `./util.js`.
+// ============= Path access =============
+export { isDangerousPath } from './is-dangerous-path.js';
+export { isInsideCwd } from './is-inside-cwd.js';
+// ============= Shell command scanners =============
+export { commandChangesDirectory } from './command-changes-directory.js';
+export { detectLanguageInterpreter } from './detect-language-interpreter.js';
+// ============= Dangerous operations =============
+export { detectDangerousOperation } from './detect-dangerous-operation.js';
+// ============= Safe commands =============
+export { detectSafeCommand } from './detect-safe-command.js';
+// ============= Network safety =============
+export { isSafeDomain } from './is-safe-domains.js';
+export { SAFE_DOMAINS } from './is-safe-domains.js';

package/dist/agent/permission/util/is-dangerous-path.js

@@ -0,0 +1,98 @@
+import { homedir, platform } from 'node:os';
+import { isAbsolute, posix, win32 } from 'node:path';
+import dangerousPathsData from './dangerous-path.json' with { type: 'json' };
+const dangerousPaths = dangerousPathsData;
+const platformToOs = {
+    darwin: 'macos',
+    linux: 'linux',
+    win32: 'windows',
+};
+/**
+ * Determine whether a given filesystem path should be treated as dangerous,
+ * i.e. a path the agent is not allowed to read or write without explicit user
+ * confirmation. The set of dangerous paths is loaded from
+ * `dangerous-path.json` and selected by the current operating system.
+ *
+ * The input path may be expressed in any of the following forms:
+ *   - absolute path   (`/etc/passwd`, `C:\Windows\System32`)
+ *   - relative path   (`./.ssh/id_rsa`) — resolved against `cwd`
+ *   - tilde-expanded  (`~/.ssh`, `~/Documents`)
+ *   - env-var form    (`%USERPROFILE%\.ssh`, `%APPDATA%\Slack`)
+ *
+ * A path matches a dangerous entry when it equals that entry, lives inside
+ * that entry as a directory, or matches a wildcard entry (`*` in the entry
+ * matches any characters except the path separator).
+ */
+export function isDangerousPath(input, options = {}) {
+    const osName = platformToOs[options.platform ?? platform()];
+    if (!osName)
+        return false;
+    const home = options.homeDir ?? homedir();
+    const env = options.env ?? process.env;
+    const cwd = options.cwd ?? process.cwd();
+    const isWindows = osName === 'windows';
+    const normalizedInput = normalizePath(input, home, env, cwd, isWindows);
+    const entries = dangerousPaths[osName];
+    for (const entry of entries) {
+        const normalizedEntry = normalizePath(entry, home, env, cwd, isWindows);
+        if (matches(normalizedInput, normalizedEntry, isWindows)) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizePath(raw, home, env, cwd, isWindows) {
+    let p = raw;
+    // Expand Windows-style environment variables. %USERPROFILE% is always
+    // treated as the home directory even when not present in `env` so the
+    // dangerous-path list stays portable.
+    p = p.replace(/%([A-Z_][A-Z0-9_]*)%/gi, (match, name) => {
+        if (name === 'USERPROFILE')
+            return home;
+        return env[name] ?? match;
+    });
+    // Expand a leading tilde to the home directory.
+    if (p === '~') {
+        p = home;
+    }
+    else if (p.startsWith('~/') || p.startsWith('~\\')) {
+        p = home + p.slice(1);
+    }
+    // Normalize path separators so the same path can be compared regardless
+    // of whether the user wrote forward or backward slashes.
+    if (isWindows) {
+        p = p.replace(/\//g, '\\');
+    }
+    else {
+        p = p.replace(/\\/g, '/');
+    }
+    // Resolve relative paths against cwd using the platform-appropriate
+    // resolver so non-Windows tests can still exercise Windows-style inputs.
+    if (!isAbsolute(p)) {
+        p = isWindows ? win32.resolve(cwd, p) : posix.resolve(cwd, p);
+        if (!isWindows)
+            p = p.replace(/\\/g, '/');
+    }
+    // Windows filesystems are case-insensitive, so case-fold both sides
+    // before comparing.
+    if (isWindows)
+        p = p.toLowerCase();
+    return p;
+}
+function matches(input, dangerous, isWindows) {
+    const sep = isWindows ? '\\' : '/';
+    if (input === dangerous)
+        return true;
+    if (input.startsWith(dangerous + sep))
+        return true;
+    if (dangerous.includes('*')) {
+        const sepClass = isWindows ? '\\\\' : '/';
+        const escaped = dangerous
+            .split('*')
+            .map((part) => part.replace(/[.+^${}()|[\]\\]/g, '\\$&'))
+            .join(`[^${sepClass}]*`);
+        const regex = new RegExp(`^${escaped}$`, isWindows ? 'i' : '');
+        return regex.test(input);
+    }
+    return false;
+}

package/dist/agent/permission/util/is-inside-cwd.js

@@ -0,0 +1,83 @@
+import { realpath } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+function getAllowedRoot() {
+    return path.join(os.homedir(), '.900');
+}
+async function resolveExistingPrefix(p) {
+    let dir = path.dirname(p);
+    while (true) {
+        try {
+            const realDir = await realpath(dir);
+            const remaining = path.relative(dir, p);
+            return path.join(realDir, remaining);
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                return null;
+            }
+            dir = parent;
+        }
+    }
+}
+async function isInsideResolvedRoot(target, root, allowMissingAncestors = false) {
+    let realTarget;
+    try {
+        realTarget = await realpath(target);
+    }
+    catch {
+        if (allowMissingAncestors) {
+            const resolved = await resolveExistingPrefix(path.resolve(root, target));
+            if (!resolved) {
+                realTarget = path.resolve(root, target);
+            }
+            else {
+                realTarget = resolved;
+            }
+        }
+        else {
+            try {
+                const realParent = await realpath(path.dirname(path.resolve(root, target)));
+                realTarget = path.join(realParent, path.basename(target));
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    let realRoot;
+    try {
+        realRoot = await realpath(root);
+    }
+    catch {
+        if (allowMissingAncestors) {
+            realRoot = path.resolve(root);
+        }
+        else {
+            return false;
+        }
+    }
+    const relative = path.relative(realRoot, realTarget);
+    if (relative === '')
+        return true;
+    return !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+/**
+ * Determine whether `target` lives inside `cwd` or inside the global
+ * `~/.900` directory (after symlink resolution).
+ *
+ * Used by the read / write permission checkers to decide whether a path
+ * is safe to auto-allow.
+ *
+ * If the target does not exist (e.g. a write creating a new file), the
+ * parent directory is resolved instead so a missing leaf can still be
+ * recognized as inside the allowed root.
+ */
+export async function isInsideCwd(target, cwd) {
+    if (await isInsideResolvedRoot(target, cwd)) {
+        return true;
+    }
+    const absoluteTarget = path.isAbsolute(target) ? target : path.resolve(cwd, target);
+    return isInsideResolvedRoot(absoluteTarget, getAllowedRoot(), true);
+}

package/dist/agent/permission/util/is-safe-domains.js

@@ -0,0 +1,47 @@
+// Public safe-domain allowlist for the network tool permission check.
+// A hostname is considered safe when it equals one of these entries, or
+// is an immediate subdomain of one (e.g. `api.github.com` matches via
+// parent `github.com`). Deeper subdomains do NOT match — `a.b.github.com`
+// is not covered by `github.com`.
+//
+// Match is case-insensitive. Wildcards are not supported; add explicit
+// entries instead.
+// Code hosting & package registries
+//   github.com          — repos, API, gists
+//   raw.githubusercontent.com — direct raw file fetch (separate apex)
+//   npmjs.com           — npm package metadata
+//   pypi.org            — Python package index
+// Documentation & reference
+//   developer.mozilla.org — MDN web docs
+//   stackoverflow.com   — Q&A
+//   wikipedia.org       — general knowledge
+export const SAFE_DOMAINS = [
+    'github.com',
+    'raw.githubusercontent.com',
+    'npmjs.com',
+    'pypi.org',
+    'developer.mozilla.org',
+    'stackoverflow.com',
+    'wikipedia.org',
+];
+const SAFE_DOMAIN_SET = new Set(SAFE_DOMAINS.map((d) => d.toLowerCase()));
+/**
+ * Check whether a hostname matches one of the safe domains. Comparison
+ * is case-insensitive. Only the immediate parent domain is consulted, so
+ * `api.github.com` matches via `github.com`, but `raw.githubusercontent.com`
+ * (different apex) needs its own entry.
+ */
+export function isSafeDomain(hostname) {
+    if (!hostname)
+        return false;
+    const lower = hostname.toLowerCase();
+    if (SAFE_DOMAIN_SET.has(lower))
+        return true;
+    const firstDot = lower.indexOf('.');
+    if (firstDot > 0) {
+        const parent = lower.slice(firstDot + 1);
+        if (SAFE_DOMAIN_SET.has(parent))
+            return true;
+    }
+    return false;
+}

package/dist/agent/permission/write.js

@@ -0,0 +1,31 @@
+import { isDangerousPath, isInsideCwd, } from './util/index.js';
+/**
+ * Decide whether a write tool call should be auto-allowed, blocked, or sent to
+ * the human-in-the-loop interrupt.
+ *
+ *   - no `filePath` in args → `allow`
+ *   - `filePath` resolves inside cwd → `allow`
+ *   - `filePath` matches a dangerous-path entry → `block` with a message
+ *     that is returned to the LLM
+ *   - otherwise (outside cwd, not dangerous) → `ask` (fall through to interrupt)
+ */
+export async function checkWritePermission(args, options = {}) {
+    const filePath = args.filePath;
+    if (typeof filePath !== 'string' || filePath.length === 0) {
+        return { action: 'allow' };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    if (await isInsideCwd(filePath, cwd)) {
+        return { action: 'allow' };
+    }
+    if (isDangerousPath(filePath)) {
+        return {
+            action: 'block',
+            message: `⚠️ 路径 \`${filePath}\` 是危险路径,不允许访问。` +
+                `危险路径包含 ~/.ssh、~/.aws、~/.gnupg、/etc、/var 等敏感目录,` +
+                `以及 Windows 上的 %APPDATA%、C:\\Windows\\System32 等。` +
+                `请改用工作目录内的其他文件。`,
+        };
+    }
+    return { action: 'ask' };
+}

package/dist/agent/prompt/index.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import * as os from 'node:os';
+import path from 'node:path';
+import { formatSkillCreationInstructions, formatSkillsForSystemPrompt } from '../../agent/skills.js';
+const baseSystemPrompt = 'You are a helpful assistant. Your name is Argos.';
+const skillCreationInstructions = formatSkillCreationInstructions();
+const skillsPrompt = formatSkillsForSystemPrompt();
+function loadProfileInfo() {
+    const profilePath = path.join(os.homedir(), '.900', '.data', 'profile.md');
+    if (!fs.existsSync(profilePath)) {
+        return '';
+    }
+    const content = fs.readFileSync(profilePath, 'utf8').trim();
+    return content;
+}
+const profileInfo = loadProfileInfo();
+const profilePrompt = `用户画像模板（当记忆中有对应信息时，可据此构建用户画像）：
+<profile_template>
+- 基本身份：姓名，昵称，性别，年龄、地区、语言
+- 外貌：身高 体重 肤色 胖瘦
+- 性格与沟通偏好
+- 兴趣爱好
+- 技能
+- 工作
+</profile_template>
+
+<profile_info>
+${profileInfo}
+</profile_info>`;
+const memoryPrompt = `记忆操作规则：
+- 删除记忆：必须先通过 memory_retrieve_tool 查询并确认具体的记忆 id，然后再调用 memory_delete_tool 删除。如果查询不到相关记忆，应友好地提示用户。
+- 更新记忆：先调用 memory_delete_tool 删除旧记忆，再调用 memory_create_tool 插入新记忆。
+- 当一个信息符合 <profile_template> 内容和范围时，不要作为 memory 记录，它会被记录在 profile 文件中。`;
+export const systemPrompt = [
+    baseSystemPrompt,
+    skillCreationInstructions,
+    skillsPrompt,
+    profilePrompt,
+    memoryPrompt,
+]
+    .filter(Boolean)
+    .join('\n\n');

package/dist/agent/skills/planner/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: planner
+description: 帮用户创建 todo list、任务清单、日程计划或项目计划。当用户提到"待办"、"todo"、"计划"、"任务清单"、"日程"、"schedule"、"plan"、"任务分解"、"行程"时触发此 skill。即使用户只是说"帮我列一下要做的事"或"我想规划一下"，也应使用此 skill。
+---
+
+# Planner
+
+帮助用户创建结构清晰、可执行的 todo list 或计划。
+
+## 核心原则
+
+- **具体可执行**：每个任务应清晰到可以直接行动，避免模糊表述
+- **合理分组**：将相关任务归类，方便用户聚焦
+- **优先级明确**：区分紧急/重要，帮助用户知道从哪里开始
+- **时间感知**：有 deadline 时给出时间节点，无 deadline 时建议大致耗时
+
+---
+
+## 输出格式
+
+根据用户需求选择合适格式：
+
+### 简单 Todo List
+
+适用于：日常任务、购物清单、零散待办
+
+```
+## ✅ 今日待办
+
+### 🔴 优先处理
+- [ ] 任务 A（预计 30 分钟）
+- [ ] 任务 B
+
+### 🟡 今天内完成
+- [ ] 任务 C
+- [ ] 任务 D
+
+### 🟢 有空再做
+- [ ] 任务 E
+```
+
+### 项目计划
+
+适用于：多步骤目标、有时间跨度的任务
+
+```
+## 📋 项目：[项目名]
+
+**目标**：一句话说清楚要达成什么
+**周期**：起止时间或预计时长
+
+### 阶段一：[名称]（第 1-3 天）
+- [ ] 子任务 1
+- [ ] 子任务 2
+
+### 阶段二：[名称]（第 4-7 天）
+- [ ] 子任务 3
+```
+
+### 日程安排
+
+适用于：某一天或某段时间的时间表
+
+```
+## 🗓️ [日期] 日程
+
+| 时间 | 事项 | 备注 |
+|------|------|------|
+| 09:00 | 任务 A | |
+| 10:30 | 任务 B | 需提前准备材料 |
+```
+
+---
+
+## 操作步骤
+
+1. **理解需求**：从用户描述中提取目标、时间范围、资源限制
+2. **补充信息**（如有必要）：若信息太少，问 1 个最关键的问题（不要问多个）
+3. **选择格式**：根据任务性质选择上方合适的模板
+4. **生成计划**：输出结构化内容，加入适当 emoji 提升可读性
+5. **给出建议**：末尾可简短说明"从哪里开始"或注意事项
+
+---
+
+## 注意事项
+
+- 用户若未指定语言，跟随用户语言（中文输入→中文输出）
+- 任务数量控制在合理范围：单日 todo 不超过 10 项，项目计划不超过 5 个阶段
+- 若用户提供的目标过于宏大（如"学会编程"），主动拆解为近期可执行的第一步
+- 允许用户说"太多了"或"再简单一点"，灵活调整粒度

package/dist/agent/skills/programmer-resume/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: programmer-resume
+description: 指导程序员撰写简历的技巧、格式、内容结构和注意事项。当用户提到"写简历"、"简历格式"、"程序员简历"、"求职简历"、"简历内容"、"简历怎么写"、"resume"、"CV"，或者询问如何展示技术经验、项目经历、技术栈等求职相关问题时，必须使用此 skill。即使用户只是问"简历要写什么"这类模糊问题，也应触发此 skill。
+---
+
+# 程序员简历撰写指南
+
+## 核心原则
+
+- **一页为主**：工作经验 < 5 年用一页，资深工程师可扩展至两页
+- **量化成果**：每条经历尽量附上数据（如"性能提升 40%"、"日活用户 10万+"）
+- **针对性定制**：根据目标 JD（职位描述）调整关键词，通过 ATS（简历筛选系统）
+- **简洁清晰**：避免花哨设计，使用标准字体（Arial、Calibri），留白充足
+
+---
+
+## 简历结构（推荐顺序）
+
+### 1. 基本信息
+
+- 姓名（大号加粗）、手机、邮箱、所在城市
+- GitHub 链接、个人博客/Portfolio（加分项）
+- **不需要**：照片、年龄、婚姻状况、政治面貌（国内除外）
+
+### 2. 技术技能（Technical Skills）
+
+按类别列出，勿堆砌，只写**真正熟悉**的：
+
+```
+编程语言：Python, Go, TypeScript
+框架/库：FastAPI, React, Spring Boot
+数据库：PostgreSQL, Redis, MongoDB
+工具/平台：Docker, Kubernetes, AWS, Git
+```
+
+### 3. 工作经历（Work Experience）
+
+格式：`公司名 | 职位 | 时间段（年/月）`
+
+每条经历用 **STAR 法则** 描述（Situation → Task → Action → Result）：
+
+- ✅ "重构订单服务，将 P99 延迟从 800ms 降至 120ms，支撑大促期间 5 万 QPS"
+- ❌ "负责订单系统的开发和维护工作"
+
+### 4. 项目经历（Projects）
+
+适用于经验不足或有亮眼个人项目的候选人：
+
+- 项目名 + 一句话介绍
+- 技术栈（加粗关键词）
+- 核心贡献 + 可量化结果
+- 附 GitHub/线上地址
+
+### 5. 教育背景（Education）
+
+- 学校、专业、学历、毕业年份
+- GPA（3.5+）、奖学金、竞赛获奖可列出
+
+### 6. 其他（可选）
+
+- 开源贡献（列出 PR 或 Star 数）
+- 技术文章/演讲
+- 证书（AWS、CKA 等含金量高的优先）
+
+---
+
+## 常见错误 ❌
+
+| 错误                         | 正确做法                               |
+| ---------------------------- | -------------------------------------- |
+| 写"熟悉 Java"但答不上问题    | 只写真实掌握的技术                     |
+| 职责描述用"负责…"            | 改用动词开头："设计、优化、实现、主导" |
+| 简历有错别字/格式错乱        | 导出前检查 PDF 渲染效果                |
+| 同一份简历投所有岗位         | 根据 JD 调整技能和关键词               |
+| 写"工作认真负责、团队合作好" | 删掉，用事实说话                       |
+
+---
+
+## 针对不同经验阶段的建议
+
+### 应届生 / 实习生
+
+- 项目经历 > 工作经历，校园项目、毕设、开源贡献都可以写
+- 突出技术广度和学习能力
+- 如有知名实习经历（大厂、独角兽），放在最显眼位置
+
+### 1–3 年经验
+
+- 工作经历为主，重点写**独立交付**的模块或功能
+- 展示技术深度：不只写"用了 Redis"，要写"用 Redis 实现分布式锁解决超卖问题"
+
+### 5 年以上 / 高级工程师
+
+- 突出**架构设计、技术决策、团队带领**
+- 用数据体现影响力（团队规模、系统规模、业务指标）
+- 可附架构图或技术方案链接
+
+---
+
+## 格式工具推荐
+
+- **在线模板**：Overleaf（LaTeX，适合外企）、超级简历、职徒简历
+- **本地工具**：Word / Pages 导出 PDF
+- **程序员专属**：[jsonresume.org](https://jsonresume.org)、用 Markdown 生成简历
+
+---
+
+## 投递注意事项
+
+1. **文件命名**：`姓名_岗位_简历.pdf`，勿命名为 `简历1.pdf`
+2. **格式**：统一发 PDF，避免 Word 格式错乱
+3. **投递渠道**：内推 > 官网 > Boss直聘/LinkedIn > 招聘平台
+4. **跟进**：投递 1 周未回音可发邮件礼貌跟进一次