# How I Turned My Claude Code Into 24/7 Dev Team (Full Guide + Repos)
**作者**: regent0x
**日期**: 2026-04-29T14:41:38.000Z
**来源**: [https://x.com/regent0x_/status/2049499354323399002](https://x.com/regent0x_/status/2049499354323399002)
---
most people use claude code like a chatbot. i turned mine into a 24/7 dev team that remembers everything and gets smarter every session
bookmark this so as not to forget
i mass used claude code wrong for 3 months
every single session started the same way. "i'm building a react app with typescript, using postgres, deployed on vercel, here's my folder structure..."
the same explanation. over and over. every day
then i'd write the same prompts manually. "review this code." "write tests for this." "fix the CI." typing paragraphs into a terminal that forgot everything the moment i closed it
i tracked it one week. 47 minutes a day wasted on repeating myself to a tool that should already know me
then i rebuilt my entire setup from scratch
now claude code remembers every decision i've ever made. it runs 5 agents in parallel while i sleep. it enforces my coding standards automatically without me asking. and it gets smarter with every session instead of resetting to zero
the whole thing runs on a $20/mo subscription
here's exactly how i built it, step by step
## /part 1 - CLAUDE.md: the foundation that changes everything
this is the file that 90% of users either skip or write wrong
CLAUDE.md lives in your project root. claude code reads it at the start of every session. it's your way of telling claude who you are, what you're building, and how you want things done - once, permanently
most people write something like "this is a react app, please be helpful"
that's useless
here's what actually works:
```
# CLAUDE.md
## project
- stack: next.js 14, typescript, tailwind, postgres via prisma
- deployed on vercel, staging branch auto-deploys
- monorepo: /apps/web, /apps/api, /packages/shared
## conventions
- all components in PascalCase
- API routes return { data, error } format
- no default exports except pages
- tests live next to source files, named *.test.ts
- commits follow conventional commits (feat:, fix:, chore:)
## architecture decisions
- chose prisma over drizzle (dec 2024): type safety priority
- chose zustand over redux (jan 2025): less boilerplate
- auth via clerk, not next-auth: better DX for our team size
## current focus
- migrating payment system from stripe checkout to stripe elements
- performance audit on /dashboard (target: LCP < 2s)
## rules
- never mass edit more than 3 files without showing me the plan first
- always run existing tests before writing new ones
- if a task takes more than 5 steps, create a plan document first
```
the difference is night and day. instead of spending the first 5 minutes of every session explaining your project, claude already knows your stack, your conventions, your architecture decisions, and what you're currently working on
but this is just the beginning. CLAUDE.md is static. it doesn't learn. it doesn't grow. for that you need the next layer
## /part 2 - persistent memory: the setup that never forgets
this is the part that changed everything for me
by default, claude code has zero memory between sessions. every conversation starts from scratch. you explain the same context, make the same corrections, re-discover the same solutions
i fixed this with three tools working together
how memory flows between sessions
obsidian as the knowledge base
i set up an obsidian vault specifically for my dev work. not notes. not bookmarks. a structured wiki that claude code reads and writes to
the structure:
```
/vault
/decisions — every architecture decision with context
/errors — bugs we hit and how we fixed them
/patterns — code patterns that work in our codebase
/sessions — summaries of what happened each day
/stack — documentation for every tool we use
Memory.md — who i am, what i'm building, my preferences
index.md — master index of everything in the vault
```
the idea comes from andrej karpathy's LLM wiki concept - instead of claude re-discovering knowledge from scratch every session, it reads from a persistent wiki that compounds over time
> https://github.com/karpathy/llm-wiki
claude-mem for session persistence
claude-mem adds long-term memory via compression. at the end of each session, it compresses the key decisions and context into a persistent store that carries over to the next session
> https://github.com/thedotmack/claude-mem
the subconscious agent
this one is wild. claude-subconscious runs a background agent that watches your sessions, reads your files, and builds memory over time without you doing anything
it's like having a junior dev sitting behind you, taking notes on everything you do
> https://github.com/0xfurai/claude-subconscious
the result: i open claude code on monday morning, and it already knows that on friday i was debugging a race condition in the payment webhook, that i decided to switch from polling to websockets, and that i still need to update the tests
no explanation needed. it just knows
## /part 3 - skills: turning a generalist into a specialist
out of the box, claude code is a generalist. it can do everything, but nothing exceptionally well
skills change that. they're markdown files that teach claude how to perform specific tasks the way you want them done
the first one everyone should install is superpowers
170k+ github stars. officially in the anthropic plugin marketplace. it transforms claude code from "write code when asked" into a complete development methodology
```
/plugin install superpowers@claude-plugins-official
```
what it actually does: instead of claude jumping straight into writing code, superpowers forces a workflow - brainstorm → spec → plan → TDD → implement → review. claude asks what you're really trying to build, writes a spec for your approval, creates a plan detailed enough for a junior dev to follow, then executes with test-driven development
> https://github.com/obra/superpowers
after superpowers, i added specialized skills:
> trail of bits security skills - real security audit workflows, built by actual security engineers. every PR gets scanned for vulnerabilities before i even look at it
> https://github.com/trailofbits/claude-code-skills
> anthropic's official skills - PDF, DOCX, XLSX generation, data analysis. the canonical reference that everything else builds on
> https://github.com/anthropics/skills
> tdd-guard - automatically blocks commits that skip tests. claude literally can't ship untested code. it explains why the block happened and what tests are needed
> https://github.com/nizos/tdd-guard
you can stack as many skills as you want. they don't conflict. each one makes claude better at one specific thing, and together they create a specialist that knows your exact workflow
## /part 4 - subagents: one claude becomes five
this is where it gets serious
a single claude code session can only do one thing at a time. you ask it to write a feature, then review code, then fix a bug, then write docs - it does each one sequentially, and the context gets polluted by the time you reach task four
subagents split the work. instead of one overloaded claude, you get a team of specialists, each with its own context and a single responsibility
my setup uses five agents:
- architect - handles high-level design decisions, writes specs, plans implementations. never touches code directly
- coder - writes the actual code following the architect's plan. has full tool access
- reviewer - reads every PR with a security-first mindset. flags issues, suggests improvements, checks test coverage
- tester - writes and runs tests. enforces TDD. works closely with tdd-guard to ensure nothing ships without coverage
- ops - handles deployment, CI/CD, infrastructure. monitors builds, fixes failures
each agent gets its own CLAUDE.md with specific instructions, tool permissions, and context boundaries. the coder never sees deployment configs. the reviewer never writes code. clean separation
for ready-made agent collections:
> https://github.com/wshobson/agents - 25k+ stars, production subagents across strategy, dev, security, design
> https://github.com/davepoon/claude-code-subagents-collection - 100+ agents, drop-in for any workflow
## /part 5 - hooks and slash commands: automate the repetitive stuff
every time you catch yourself typing the same instruction for the third time, that's a slash command waiting to happen
i set up these and use them daily:
> /fix-issue 456 - reads the github issue, creates a branch, writes a fix with tests, opens a PR. one command instead of a 10-minute workflow
> https://github.com/claude-commands/command-fix-issue
> /review - triggers the reviewer agent on the current PR with security checks, test coverage analysis, and code quality scoring
> /deploy staging - runs the full deployment pipeline through the ops agent
for a complete collection of 57 production-ready commands:
> https://github.com/wshobson/commands - 1.7k+ stars, 15 workflows + 42 tools
hooks go even further. they trigger automatically at specific moments:
> pre-commit hook - tdd-guard checks that tests exist and pass before any commit goes through
> session start hook - loads memory from obsidian, reads recent session logs, primes context
> pre-push hook - security review runs automatically before code hits the remote
you stop reminding claude of your rules because the rules enforce themselves
## /part 6 - orchestration: agents work while you sleep
this is the final piece. the thing that turns a $20/mo subscription into something that feels like having a dev team
claude-squad is a terminal multiplexer built specifically for running multiple AI agents in parallel. each agent gets its own isolated workspace via git worktrees, so they work on separate branches without conflicts
```
brew install claude-squad
cs
```
that's it. you get a TUI where you can launch, monitor, pause, and resume agents. close the terminal - they keep working. come back in the morning to finished pull requests
> https://github.com/smtg-ai/claude-squad
my nightly workflow
before bed i open claude-squad and spin up three sessions:
- agent 1: "fix all open issues labeled 'bug' in the repo"
- agent 2: "write missing tests for /apps/api/src/services/"
- agent 3: "refactor the dashboard components to use the new design tokens"
i enable auto-accept mode (cs -y) for trusted tasks, switch to plan mode for anything risky
i close the laptop. go to sleep
morning: three PRs waiting for review. each one on its own branch, no conflicts, tests passing
for more advanced orchestration:
> https://github.com/ruvnet/claude-flow - 11.4k+ stars, enterprise-grade multi-agent orchestration with persistent memory
## /part 7 - the full stack and what it costs
here's everything running together:
```
layer 1: CLAUDE.md — free (just a file)
layer 2: obsidian + claude-mem — free (obsidian is free, repos are open source)
layer 3: superpowers + skills — free (all open source, MIT license)
layer 4: subagents — free (markdown files)
layer 5: hooks + commands — free (all open source)
layer 6: claude-squad — free (open source)
total infrastructure cost: $0
claude code subscription: $20/mo (pro plan)
```
everything on this list is open source. the only thing you pay for is the claude subscription itself
and the ROI is not even close. i tracked my productivity for two weeks before and after this setup:
before vs after
the 47 minutes a day i was wasting? gone. but more importantly, the agents are now doing work at 3am that i used to do at 3pm
## /bonus - where to start
you don't need to build all 6 layers today
start with these three. they take one afternoon:
one afternoon setup
this setup took me 3 months to figure out
you can build it in one afternoon
what does your claude code setup look like rn?
follow me @regent0x_ to study and research only fresh alpha
thx for reading. don't forget to bookmark this
## 相关链接
- [regent0x](https://x.com/regent0x_)
- [@regent0x_](https://x.com/regent0x_)
- [130K](https://x.com/regent0x_/status/2049499354323399002/analytics)
- [https://github.com/karpathy/llm-wiki](https://github.com/karpathy/llm-wiki)
- [https://github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
- [https://github.com/0xfurai/claude-subconscious](https://github.com/0xfurai/claude-subconscious)
- [https://github.com/obra/superpowers](https://github.com/obra/superpowers)
- [https://github.com/trailofbits/claude-code-skills](https://github.com/trailofbits/claude-code-skills)
- [https://github.com/anthropics/skills](https://github.com/anthropics/skills)
- [https://github.com/nizos/tdd-guard](https://github.com/nizos/tdd-guard)
- [https://github.com/wshobson/agents](https://github.com/wshobson/agents)
- [https://github.com/davepoon/claude-code-subagents-collection](https://github.com/davepoon/claude-code-subagents-collection)
- [https://github.com/claude-commands/command-fix-issue](https://github.com/claude-commands/command-fix-issue)
- [https://github.com/wshobson/commands](https://github.com/wshobson/commands)
- [https://github.com/smtg-ai/claude-squad](https://github.com/smtg-ai/claude-squad)
- [https://github.com/ruvnet/claude-flow](https://github.com/ruvnet/claude-flow)
- [@regent0x_](https://x.com/@regent0x_)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:41 PM · Apr 29, 2026](https://x.com/regent0x_/status/2049499354323399002)
- [130.5K Views](https://x.com/regent0x_/status/2049499354323399002/analytics)
- [View quotes](https://x.com/regent0x_/status/2049499354323399002/quotes)
---
*导出时间: 2026/5/2 16:52:25*
---
## 中文翻译
# 我如何将我的 Claude Code 变成 7x24 小时开发团队（完整指南 + 仓库）
**作者**: regent0x
**日期**: 2026-04-29T14:41:38.000Z
**来源**: [https://x.com/regent0x_/status/2049499354323399002](https://x.com/regent0x_/status/2049499354323399002)
---
大多数人像使用聊天机器人一样使用 claude code。我把我的变成了一个 7x24 小时的开发团队，它能记住所有事情，并且每次会话都变得越来越聪明
收藏这篇文章以免忘记
我错误地大规模使用 claude code 长达 3 个月
每一次会话都是同样的开场。“我正在构建一个使用 typescript 的 react 应用，使用 postgres，部署在 vercel 上，这是我的文件夹结构……”
同样的解释。一遍又一遍。每天都在
然后我会手动输入同样的指令。“审查这段代码。”“为此写测试。”“修复 CI。”向一个一旦关闭就会忘记一切的终端输入大段文字
我花了一周时间做记录。每天浪费 47 分钟重复向一个本该了解我的工具解释同样的事情
后来我从零开始重建了我的整个设置
现在 claude code 记住我做过的每一个决定。它在我睡觉时并行运行 5 个智能体。它在我甚至还没开口的情况下就自动执行我的代码标准。它随着每次会话变得更聪明，而不是重置为零
整个系统运行在一个 $20/月的订阅上
以下是我构建它的确切步骤，一步步来
## /第 1 部分 - CLAUDE.md：改变一切的基础
这是 90% 的用户要么跳过要么写错的文件
CLAUDE.md 位于你的项目根目录。claude code 在每次会话开始时读取它。这是你告诉 claude 你是谁、你在构建什么以及你希望如何完成任务的方式——一次，永久有效
大多数人写的内容类似“这是一个 react 应用，请提供帮助”
这毫无用处
这是真正有效的方法：
```
# CLAUDE.md
## 项目
- 技术栈：next.js 14, typescript, tailwind, 通过 prisma 使用 postgres
- 部署在 vercel 上，staging 分支自动部署
- 单体仓库：/apps/web, /apps/api, /packages/shared
## 约定
- 所有组件使用 PascalCase 命名
- API 路由返回 { data, error } 格式
- 除了页面以外没有默认导出
- 测试文件位于源文件旁边，命名为 *.test.ts
- 提交遵循约定式提交
## 架构决策
- 选择 prisma 而不是 drizzle（2024 年 12 月）：类型安全优先
- 选择 zustand 而不是 redux（2025 年 1 月）：减少样板代码
- 通过 clerk 进行认证，而非 next-auth：更适合我们团队规模的开发体验
## 当前重点
- 将支付系统从 stripe checkout 迁移到 stripe elements
- 对 /dashboard 进行性能审计（目标：LCP < 2s）
## 规则
- 在向我展示计划之前，永远不要批量编辑超过 3 个文件
- 在编写新测试之前始终运行现有测试
- 如果任务需要超过 5 个步骤，先创建一个计划文档
```
两者的差别天差地别。claude 已经知道了你的技术栈、你的约定、你的架构决策以及你当前的工作内容，你无需在每次会话的前 5 分钟解释你的项目
但这只是开始。CLAUDE.md 是静态的。它不学习。它不成长。为此你需要下一层
## /第 2 部分 - 持久记忆：永不遗忘的设置
这是彻底改变了一切的部分
默认情况下，claude code 在会话之间没有任何记忆。每次对话都从头开始。你解释同样的上下文，做同样的修正，重新发现同样的解决方案
我通过三个协同工作的工具解决了这个问题
记忆如何在会话之间流动
obsidian 作为知识库
我为我的开发工作专门设置了一个 obsidian 库。不是笔记。不是书签。一个结构化的维基，claude code 可以读取并写入其中
结构：
```
/vault
/decisions — 每个架构决策及其上下文
/errors — 我们遇到的错误以及修复方法
/patterns — 在我们代码库中有效的代码模式
/sessions — 每天发生事情的总结
/stack — 我们使用的每个工具的文档
Memory.md — 我是谁，我在构建什么，我的偏好
index.md — 库中所有内容的主索引
```
这个想法来自 andrej karpathy 的 LLM wiki 概念——claude 不是每次会话都从头重新发现知识，而是从一个随时间累积的持久维基中读取
> https://github.com/karpathy/llm-wiki
claude-mem 用于会话持久化
claude-mem 通过压缩增加长期记忆。在每次会话结束时，它将关键决策和上下文压缩到一个持久存储中，并延续到下一次会话
> https://github.com/thedotmack/claude-mem
潜意识智能体
这个很疯狂。claude-subconscious 运行一个后台智能体，它观察你的会话，阅读你的文件，并随着时间推移建立记忆，你无需做任何事
这就像有一个初级开发人员坐在你身后，记录你所做的一切
> https://github.com/0xfurai/claude-subconscious
结果：我在周一早上打开 claude code，它已经知道周五我正在调试支付 webhook 中的竞态条件，我决定从轮询切换到 websockets，以及我仍然需要更新测试
无需解释。它就是知道
## /第 3 部分 - 技能：将通才变成专才
开箱即用，claude code 是个通才。它什么都能做，但没有一样做得特别出色
技能改变了这一点。它们是 markdown 文件，教导 claude 如何按照你想要的方式执行特定任务
每个人都应该安装的第一个是 superpowers
17 万+ github 星标。正式入驻 anthropic 插件市场。它将 claude code 从“被要求时写代码”转变为一种完整的开发方法论
```
/plugin install superpowers@claude-plugins-official
```
它的实际作用：superpowers 强制执行一个工作流程——头脑风暴 → 规格 → 计划 → TDD → 实现 → 审查，而不是 claude 直接跳进写代码。claude 会问你到底想构建什么，为你编写一个规格以供批准，创建一个详细到初级开发人员可以遵循的计划，然后通过测试驱动开发执行
> https://github.com/obra/superpowers
在 superpowers 之后，我添加了专业技能：
> trail of bits security skills - 真正的安全审计工作流程，由真正的安全工程师构建。每个 PR 在我查看之前都会被扫描漏洞
> https://github.com/trailofbits/claude-code-skills
> anthropic's official skills - PDF、DOCX、XLSX 生成、数据分析。其他所有内容所基于的权威参考
> https://github.com/anthropics/skills
> tdd-guard - 自动阻止跳过测试的提交。claude 字面上无法发布未经测试的代码。它会解释阻止发生的原因以及需要什么测试
> https://github.com/nizos/tdd-guard
你可以堆叠任意多的技能。它们不冲突。每一个都让 claude 在某一特定事情上做得更好，它们共同创造了一个了解你确切工作流程的专才
## /第 4 部分 - 子智能体：一个 claude 变成五个
这里是认真的地方
单个 claude code 会话一次只能做一件事。你让它写一个功能，然后审查代码，然后修复 bug，然后写文档——它按顺序做每一件事，当你到达第四个任务时上下文已经被污染了
子智能体分割工作。你得到的不是一个超负荷的 claude，而是一个专家团队，每个都有自己的上下文和单一职责
我的设置使用了五个智能体：
- architect - 处理高级设计决策，编写规格，规划实现。从不直接接触代码
- coder - 按照 architect 的计划编写实际代码。拥有完整的工具访问权限
- reviewer - 以安全第一的心态阅读每个 PR。标记问题，建议改进，检查测试覆盖率
- tester - 编写和运行测试。强制执行 TDD。与 tdd-guard 密切合作，确保没有未经测试的代码发布
- ops - 处理部署、CI/CD、基础设施。监控构建，修复故障
每个智能体都有自己的 CLAUDE.md，包含具体的指令、工具权限和上下文边界。coder 永远看不到部署配置。reviewer 永远不写代码。干净的分离
对于现成的智能体集合：
> https://github.com/wshobson/agents - 2.5 万+ 星标，跨越策略、开发、安全、设计的生产级子智能体
> https://github.com/davepoon/claude-code-subagents-collection - 100+ 智能体，即插即用于任何工作流程
## /第 5 部分 - 钩子和斜杠命令：自动化重复性工作
每当你发现自己第三次输入同样的指令时，那就是一个等待发生的斜杠命令
我设置了这些并每天使用：
> /fix-issue 456 - 读取 github issue，创建分支，编写带有测试的修复，打开 PR。一个命令代替 10 分钟的工作流程
> https://github.com/claude-commands/command-fix-issue
> /review - 在当前 PR 上触发 reviewer 智能体，进行安全检查、测试覆盖率分析和代码质量评分
> /deploy staging - 通过 ops 智能体运行完整的部署管道
对于包含 57 个生产就绪命令的完整集合：
> https://github.com/wshobson/commands - 1.7k+ 星标，15 个工作流程 + 42 个工具
钩子更进一步。它们在特定时刻自动触发：
> pre-commit hook - tdd-guard 在任何提交通过之前检查测试是否存在并通过
> session start hook - 从 obsidian 加载记忆，读取最近的会话日志，准备上下文
> pre-push hook - 安全审查在代码到达远程之前自动运行
你停止提醒 claude 你的规则，因为规则会自动执行
## /第 6 部分 - 编排：智能体在你睡觉时工作
这是最后一块拼图。它将 $20/月的订阅变成了感觉像拥有一个开发团队的东西
claude-squad 是一个专门为并行运行多个 AI 智能体而构建的终端多路复用器。每个智能体通过 git worktrees 获得自己的隔离工作区，因此它们在不同的分支上工作而不会发生冲突
```
brew install claude-squad
cs
```
就是这样。你会得到一个 TUI，你可以在其中启动、监控、暂停和恢复智能体。关闭终端——它们继续工作。早上回来面对完成的 pull request
> https://github.com/smtg-ai/claude-squad
我的夜间工作流程
睡前我打开 claude-squad 并启动三个会话：
- 智能体 1：“修复仓库中所有标记为‘bug’的开放 issue”
- 智能体 2：“为 /apps/api/src/services/ 编写缺失的测试”
- 智能体 3：“重构 dashboard 组件以使用新的设计令牌”
对于受信任的任务，我启用自动接受模式，对于任何有风险的任务切换到计划模式
我合上笔记本电脑。去睡觉
早上：三个 PR 等待审查。每个都在自己的分支上，没有冲突，测试通过
对于更高级的编排：
> https://github.com/ruvnet/claude-flow - 1.14 万+ 星标，企业级多智能体编排，具有持久记忆
## /第 7 部分 - 全栈及其成本
这里是所有一起运行的内容：
```
layer 1: CLAUDE.md — 免费（只是一个文件）
layer 2: obsidian + claude-mem — 免费
layer 3: superpowers + skills — 免费（所有开源，MIT 许可证）
layer 4: subagents — 免费（markdown 文件）
layer 5: hooks + commands — 免费（所有开源）
layer 6: claude-squad — 免费（开源）
总基础设施成本：$0
claude code 订阅：$20/月（专业计划）
```
这个列表上的所有东西都是开源的。你唯一支付的是 claude 订阅本身
而且投资回报率甚至无法相提并论。我在这个设置之前和之后追踪了两周的生产力：
之前 vs 之后
我每天浪费的 47 分钟？没了。但更重要的是，智能体现在在凌晨 3 点做我过去在下午 3 点做的工作
## /奖励 - 从哪里开始
你不需要今天构建所有 6 层
从这三个开始。它们需要一个下午：
一个下午的设置
这个设置花了我 3 个月时间才弄清楚
你可以在一个下午内构建它
你的 claude code 设置现在看起来是什么样的？
关注我 @regent0x_ 以研究和仅限新鲜的 alpha
感谢阅读。不要忘记收藏这个
## 相关链接
- [regent0x](https://x.com/regent0x_)
- [@regent0x_](https://x.com/regent0x_)
- [130K](https://x.com/regent0x_/status/2049499354323399002/analytics)
- [https://github.com/karpathy/llm-wiki](https://github.com/karpathy/llm-wiki)
- [https://github.com/thedotmack/claude-mem](https://github.com/thedotmack/claude-mem)
- [https://github.com/0xfurai/claude-subconscious](https://github.com/0xfurai/claude-subconscious)
- [https://github.com/obra/superpowers](https://github.com/obra/superpowers)
- [https://github.com/trailofbits/claude-code-skills](https://github.com/trailofbits/claude-code-skills)
- [https://github.com/anthropics/skills](https://github.com/anthropics/skills)
- [https://github.com/nizos/tdd-guard](https://github.com/nizos/tdd-guard)
- [https://github.com/wshobson/agents](https://github.com/wshobson/agents)
- [https://github.com/davepoon/claude-code-subagents-collection](https://github.com/davepoon/claude-code-subagents-collection)
- [https://github.com/claude-commands/command-fix-issue](https://github.com/claude-commands/command-fix-issue)
- [https://github.com/wshobson/commands](https://github.com/wshobson/commands)
- [https://github.com/smtg-ai/claude-squad](https://github.com/smtg-ai/claude-squad)
- [https://github.com/ruvnet/claude-flow](https://github.com/ruvnet/claude-flow)
- [@regent0x_](https://x.com/@regent0x_)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:41 PM · Apr 29, 2026](https://x.com/regent0x_/status/2049499354323399002)
- [130.5K Views](https://x.com/regent0x_/status/2049499354323399002/analytics)
- [View quotes](https://x.com/regent0x_/status/2049499354323399002/quotes)
---
*导出时间: 2026/5/2 16:52:25*