diff --git a/docs/superpowers/plans/2026-03-25-continuity-readme-entry-polish.md b/docs/superpowers/plans/2026-03-25-continuity-readme-entry-polish.md
new file mode 100644
index 0000000..c88f43a
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-25-continuity-readme-entry-polish.md
@@ -0,0 +1,117 @@
+# Continuity README Entry Polish Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make the long-task continuity docs feel friendlier and faster for first-time users while preserving package boundaries and bilingual alignment.
+
+**Architecture:** Rework the `skills/` index into a true decision entry page, then reshape the four continuity package READMEs into landing pages that lead with use cases, outputs, and natural-language Codex prompts. Keep shell commands available, but push them below the first-screen newcomer path.
+
+**Tech Stack:** Markdown docs, Python `unittest` contract tests
+
+---
+
+### Task 1: Lock the New Entry-Page Contract
+
+**Files:**
+- Modify: `skills/skill-context-keeper/tests/test_package_contract.py`
+- Modify: `skills/skill-phase-gate/tests/test_package_contract.py`
+- Modify: `skills/skill-handoff-summary/tests/test_package_contract.py`
+- Modify: `skills/skill-task-continuity/tests/test_docs_contract.py`
+
+- [ ] **Step 1: Add failing assertions for the new README entry structure**
+
+Add tests that require:
+- a quick-pick continuity block in `skills/README.md` and `skills/README.zh-CN.md`
+- newcomer-first headings in the four README files
+- natural-language install wording near the top
+- explicit “what file gets created or updated” wording
+
+- [ ] **Step 2: Run the targeted docs-contract tests and verify they fail**
+
+Run: `python3 -m unittest skills/skill-context-keeper/tests/test_package_contract.py skills/skill-phase-gate/tests/test_package_contract.py skills/skill-handoff-summary/tests/test_package_contract.py skills/skill-task-continuity/tests/test_docs_contract.py -v`
+Expected: FAIL because the current README files still use the older structure.
+
+### Task 2: Rewrite the Skills Index as a True Entry Page
+
+**Files:**
+- Modify: `skills/README.md`
+- Modify: `skills/README.zh-CN.md`
+
+- [ ] **Step 1: Add a quick continuity decision block near the top**
+
+Write a short “pick the right continuity skill” guide that maps:
+- stale task state -> `skill-context-keeper`
+- risky or multi-file change -> `skill-phase-gate`
+- pause or handoff -> `skill-handoff-summary`
+- first-time suite setup -> `skill-task-continuity`
+
+- [ ] **Step 2: Keep the package table, but demote it to second-level detail**
+
+Retain the published package table and package conventions, but make the fast decision guide the first thing new users read.
+
+### Task 3: Reshape the Three Atomic README Pages
+
+**Files:**
+- Modify: `skills/skill-context-keeper/README.md`
+- Modify: `skills/skill-context-keeper/README.zh-CN.md`
+- Modify: `skills/skill-phase-gate/README.md`
+- Modify: `skills/skill-phase-gate/README.zh-CN.md`
+- Modify: `skills/skill-handoff-summary/README.md`
+- Modify: `skills/skill-handoff-summary/README.zh-CN.md`
+
+- [ ] **Step 1: Move each README to a faster landing-page flow**
+
+Use a newcomer-friendly order that leads with:
+- when to use the package
+- what the user will get
+- what file or artifact usually changes
+- what to say to Codex first
+- related skills
+
+Keep “don’t use this when” and boundary wording, but move it below the first-screen orientation.
+
+- [ ] **Step 2: Keep install guidance natural-language first**
+
+Show the natural-language install prompt in the main install section.
+Keep the exact shell install command available, but lower on the page so first-time users can start without hunting for script paths.
+
+### Task 4: Reposition `skill-task-continuity` as the Beginner Entry Package
+
+**Files:**
+- Modify: `skills/skill-task-continuity/README.md`
+- Modify: `skills/skill-task-continuity/README.zh-CN.md`
+
+- [ ] **Step 1: Rewrite the opening as a first-time setup page**
+
+Lead with language like:
+- start here for first-time setup
+- what gets created in the repo
+- fastest setup
+- which skill to use next
+
+Move terms such as atomic package boundaries or maintainer-style design notes lower on the page.
+
+- [ ] **Step 2: Keep full-suite install easy without implying hidden auto-install**
+
+Preserve the explicit one-command full-suite install path and the statement that `skill-task-continuity` does not auto-install the atomic packages.
+Lead with natural-language prompts first, and keep the exact CLI command available later.
+
+### Task 5: Verify the New Entry Experience
+
+**Files:**
+- Verify: `skills/README.md`
+- Verify: `skills/README.zh-CN.md`
+- Verify: the four package README files
+
+- [ ] **Step 1: Re-run the targeted docs-contract tests**
+
+Run: `python3 -m unittest skills/skill-context-keeper/tests/test_package_contract.py skills/skill-phase-gate/tests/test_package_contract.py skills/skill-handoff-summary/tests/test_package_contract.py skills/skill-task-continuity/tests/test_docs_contract.py -v`
+Expected: PASS
+
+- [ ] **Step 2: Re-read the edited README files for tone and symmetry**
+
+Check that:
+- English and Chinese pages stay aligned
+- first-screen wording is user-friendly
+- commands are no longer the first thing a newcomer sees
+- package boundaries still remain clear
diff --git a/skills/README.md b/skills/README.md
index 1ca8337..6a9a25f 100644
--- a/skills/README.md
+++ b/skills/README.md
@@ -4,11 +4,25 @@
 
 This directory contains the installable skill packages published by `codex-skill-library`.
 
+## Pick the Right Continuity Skill
+
+Use this quick guide first:
+
+- I paused a task and need to rebuild the current picture.
+  Start with `skill-context-keeper`.
+- I am about to make a risky or multi-file change.
+  Start with `skill-phase-gate`.
+- I need to stop now and leave a durable restart note.
+  Start with `skill-handoff-summary`.
+- I want to set up the whole continuity workflow in a repo for the first time.
+  Start with `skill-task-continuity`.
+
 ## How To Use This Index
 
-1. Scan the table below to find the skill that matches your task.
-2. Open the package README in your preferred language.
-3. Use the package reference pages for boundary notes now, and later for examples or prompt wording.
+1. Start with the quick picker above if you are working on continuity setup or continuity workflow tasks.
+2. Scan the table below to find the package that matches your next action.
+3. Open the package README in your preferred language.
+4. Use the package reference pages for examples, prompt wording, and deeper boundary notes when needed.
 
 ## Published Packages
 
diff --git a/skills/README.zh-CN.md b/skills/README.zh-CN.md
index a01f424..bf0762d 100644
--- a/skills/README.zh-CN.md
+++ b/skills/README.zh-CN.md
@@ -4,11 +4,25 @@
 
 这个目录存放 `codex-skill-library` 中可安装、可发布的 skill 包。
 
+## 选择合适的连续性技能
+
+先看这份快速指南：
+
+- 我暂停了一个任务，现在需要重新拼出当前图景。
+  先用 `skill-context-keeper`。
+- 我马上要做一个高风险或多文件改动。
+  先用 `skill-phase-gate`。
+- 我现在要停下来，并留下一个可以直接续做的重启说明。
+  先用 `skill-handoff-summary`。
+- 我第一次想在仓库里装好整套连续性工作流。
+  先用 `skill-task-continuity`。
+
 ## 如何使用这个索引页
 
-1. 先看下面的表格，找到与你任务最匹配的 skill。
-2. 打开该包对应语言的 README。
-3. 现在先看包内参考页了解边界说明，后续阶段再继续使用其中补充的示例、提示词或更细说明。
+1. 如果你处理的是连续性工作流或连续性搭建问题，先看上面的快速选型块。
+2. 再看下面的表格，找到与你下一步动作最匹配的包。
+3. 打开该包对应语言的 README。
+4. 当你需要示例、提示词或更细的边界说明时，再去看包里的 `references/` 页面。
 
 ## 已发布包
 
diff --git a/skills/skill-context-keeper/README.md b/skills/skill-context-keeper/README.md
index 47e7d4e..24e4a32 100644
--- a/skills/skill-context-keeper/README.md
+++ b/skills/skill-context-keeper/README.md
@@ -4,67 +4,56 @@
 
 ## Overview
 
-`skill-context-keeper` is the focused package for recovering and refreshing structured task state during long-running coding work.
-It helps the next turn start from the best verified picture of the task without expanding into checkpoints, workflow control, or final handoff writing.
+`skill-context-keeper` is the focused package for refreshing structured task state during long-running coding work.
+Use it when the task is still ongoing, but the working context is stale.
 
-## Core Capabilities
+## Start Here In 30 Seconds
 
-`skill-context-keeper` is designed for one job: keeping ongoing task state trustworthy and resumable.
+- Use this when: the task is still active, but the current picture is stale, scattered, or partially trusted.
+- You'll get: a compact, verified task snapshot that separates facts, assumptions, decisions, risks, and next actions.
+- Typical output: updates `.agent-state/TASK_STATE.md`.
 
-- rebuild the current task picture from verified repository facts
-- keep facts, assumptions, decisions, risks, and next actions clearly separated
-- refresh compact downstream state files such as `.agent-state/TASK_STATE.md`
-- preserve just enough continuity for the next turn without turning into a full workflow package
+If you want to tell Codex exactly what to do:
 
-Use this skill when the main problem is stale or scattered task context rather than workflow control.
+Try this first:
 
-## Best For
-
-- resuming a paused task after the working context has drifted
-- resuming a task after an interruption or stale summary
-- rebuilding the current state before making more code changes
-- rebuilding the last known task state before new work continues
-- refreshing open TODOs, assumptions, and recent changes in one place
-- reconciling what the thread believes with what the repository now shows
-
-If you are picking an entry point, start here when the main problem is stale or scattered task context.
-
-## What It Is Not For
-
-- breaking a task into staged execution phases
-- deciding checkpoint rules or phase exit criteria
-- writing a final pause or transfer handoff for another agent
-- bootstrapping the full long-task continuity suite
-
-This package does not own workflow gating and does not own final handoffs.
+- `Use skill-context-keeper to refresh the current task state from the repository before we continue.`
 
 ## Install
 
-To install `skill-context-keeper`, use the standard published package path in this repository and choose the release or ref that fits your workflow.
-
 You can ask Codex in natural language:
 
 - `Use skill-installer to install skill-context-keeper from Golden-Promise/codex-skill-library at skills/skill-context-keeper.`
 - `Use skill-installer to install skill-context-keeper from Golden-Promise/codex-skill-library at skills/skill-context-keeper using ref v0.6.1.`
 
-For trigger examples and prompt wording, see [references/use-cases.md](references/use-cases.md).
+If you want the exact shell command, jump to [Install Details](#install-details).
 
-## Common Paths
+## What File Will This Create Or Update?
 
-Start with one of these three paths:
+The typical downstream file is `.agent-state/TASK_STATE.md`.
 
-1. Resume a paused task after the working picture has drifted.
-2. Refresh task state before more implementation work.
-3. Reconcile facts, open issues, and the next action in `.agent-state/TASK_STATE.md`.
+Use this package when you want to refresh or rewrite that task-state file so the next turn can resume from a trusted summary of:
 
-If you want ready-to-paste prompts, see [references/prompt-templates.en.md](references/prompt-templates.en.md).
+- the current objective
+- current repository facts
+- completed work
+- open issues and risks
+- the next recommended action
 
-## Direct Codex Usage
+## Don't Use This When
 
-If you want to tell Codex exactly what to do, say:
+- you need a preflight or postflight checkpoint around a risky change
+- you need a durable pause or transfer handoff
+- you are setting up the full continuity workflow in a repo for the first time
+- you want generic workflow control instead of state refresh
 
-- `Use skill-context-keeper to refresh the current task state from the repository before we continue.`
-- `Use skill-context-keeper to rebuild the last known task state and rewrite .agent-state/TASK_STATE.md.`
+This package does not own workflow gating and does not own final handoffs.
+
+## Related Skills
+
+- `skill-phase-gate` for meaningful preflight and postflight checkpoints
+- `skill-handoff-summary` for pause and transfer notes
+- `skill-task-continuity` for first-time continuity setup and suite-level guidance
 
 ## Documentation
 
@@ -74,3 +63,14 @@ If you want to tell Codex exactly what to do, say:
 - Prompt templates: [references/prompt-templates.en.md](references/prompt-templates.en.md)
 - Chinese prompt templates: [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)
 - Task-state template: [assets/TASK_STATE.template.md](assets/TASK_STATE.template.md)
+
+## Install Details
+
+Replace `/path/to/install-skill-from-github.py` with the actual path to your local `skill-installer` checkout.
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-context-keeper \
+  --ref v0.6.1
+```
diff --git a/skills/skill-context-keeper/README.zh-CN.md b/skills/skill-context-keeper/README.zh-CN.md
index 59f5242..e3fde48 100644
--- a/skills/skill-context-keeper/README.zh-CN.md
+++ b/skills/skill-context-keeper/README.zh-CN.md
@@ -4,61 +4,56 @@
 
 ## 概述
 
-`skill-context-keeper` 是一个专注型包，专门用于在长时间编码任务中恢复和刷新结构化任务状态。
-它帮助下一轮从当前最可信、已验证的任务图景继续，而不会扩展成检查点、流程控制或最终交接说明。
+`skill-context-keeper` 是一个专注型包，用于在长时间编码任务中刷新结构化任务状态。
+当任务还没结束，但你手上的任务图景已经变旧、变散或不再完全可信时，就该用它。
 
-## 核心能力
+## 30 秒快速开始
 
-`skill-context-keeper` 只聚焦一件事：让进行中的任务状态保持可信、可续做。
+- 什么时候用：任务仍在继续，但当前上下文已经陈旧、分散，或者可信度不够。
+- 你会得到什么：一个紧凑、可信的任务快照，把事实、假设、决策、风险和下一步动作分清楚。
+- 典型产物：更新 `.agent-state/TASK_STATE.md`。
 
-- 根据已验证的仓库事实重建当前任务图景
-- 清楚区分事实、假设、决策、风险和下一步动作
-- 刷新诸如 `.agent-state/TASK_STATE.md` 的紧凑下游状态文件
-- 只保留下一轮继续执行所需的连续性，不膨胀成整套工作流包
+如果你想直接告诉 Codex 怎么做：
 
-## 适用场景
+先这样对 Codex 说：
 
-- 任务暂停后重新进入，且上下文已经开始漂移
-- 在继续改代码前先重建当前任务状态
-- 用一个稳定入口刷新待办、假设和最近变更
-- 对齐线程认知与仓库现状，避免带着旧前提继续推进
-
-如果你在几个连续性包之间做选择，而当前主要问题是“任务状态过时或散落”，优先从这个包开始。
-
-## 不适用场景
-
-- 把任务拆成分阶段执行
-- 决定检查点规则或阶段退出条件
-- 为另一个执行者撰写暂停或转交说明
-- 启动整套长任务连续性套件
+- `请用 skill-context-keeper 根据仓库现状刷新当前任务状态。`
 
 ## 安装
 
-安装 `skill-context-keeper` 时，请使用本仓库中的标准发布路径，并按你的工作流选择 release 或 ref。
-
-你也可以直接这样对 Codex 说：
+你可以直接这样对 Codex 说：
 
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-context-keeper 安装 skill-context-keeper。`
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-context-keeper 安装 skill-context-keeper，并使用 ref v0.6.1。`
 
-关于触发示例和提示词措辞，可查看 [references/use-cases.zh-CN.md](references/use-cases.zh-CN.md)。
+如果你想看精确的 shell 命令，可以直接跳到后面的 [安装细节](#安装细节)。
 
-## 常用路径
+## 会创建或更新什么文件？
 
-可以先从下面三条路径开始：
+最典型的下游文件是 `.agent-state/TASK_STATE.md`。
 
-1. 在任务暂停一段时间后恢复上下文。
-2. 在继续实现前刷新当前任务状态。
-3. 把事实、未决问题和下一步动作收敛到 `.agent-state/TASK_STATE.md`。
+当你希望刷新或重写这个任务状态文件，让下一轮可以从一个可信摘要继续时，就该用这个包。它通常会帮助你整理：
 
-如果你想直接套用提示词模板，请查看 [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)。
+- 当前目标
+- 仓库里的已验证事实
+- 已完成工作
+- 开放问题和风险
+- 下一步推荐动作
 
-## 直接告诉 Codex 怎么做
+## 不适合什么时候用
 
-如果你想直接用自然语言告诉 Codex，可以这样说：
+- 你需要为高风险改动加 preflight 或 postflight 检查点
+- 你需要写一份可交接、可暂停的 handoff
+- 你是第一次在仓库里搭建整套连续性工作流
+- 你想要的是泛化的流程控制，而不是状态刷新
 
-- `请用 skill-context-keeper 根据仓库现状刷新当前任务状态。`
-- `请用 skill-context-keeper 重建最近一次可信任务状态，并重写 .agent-state/TASK_STATE.md。`
+这个包不负责 workflow gating，也不负责 final handoffs。
+
+## 相关技能
+
+- `skill-phase-gate`：适合高价值的 preflight / postflight 检查点
+- `skill-handoff-summary`：适合暂停或转交时写 handoff
+- `skill-task-continuity`：适合第一次搭建整套连续性流程
 
 ## 文档
 
@@ -68,3 +63,14 @@
 - 中文提示词模板：[references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)
 - English prompt templates: [references/prompt-templates.en.md](references/prompt-templates.en.md)
 - 任务状态模板：[assets/TASK_STATE.template.md](assets/TASK_STATE.template.md)
+
+## 安装细节
+
+把 `/path/to/install-skill-from-github.py` 换成你本地 `skill-installer` 仓库里的实际脚本路径。
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-context-keeper \
+  --ref v0.6.1
+```
diff --git a/skills/skill-context-keeper/tests/test_package_contract.py b/skills/skill-context-keeper/tests/test_package_contract.py
index 4c1bd11..c17a39a 100644
--- a/skills/skill-context-keeper/tests/test_package_contract.py
+++ b/skills/skill-context-keeper/tests/test_package_contract.py
@@ -53,6 +53,36 @@ def test_readme_includes_direct_natural_language_usage(self):
         self.assertIn("if you want to tell codex exactly what to do", text)
         self.assertIn("use skill-context-keeper to refresh the current task state", text)
 
+    def test_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.md").read_text(encoding="utf-8")
+        for heading in [
+            "## Start Here In 30 Seconds",
+            "## Install",
+            "## What File Will This Create Or Update?",
+            "## Don't Use This When",
+            "## Related Skills",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("Typical output:", text)
+        self.assertIn(".agent-state/TASK_STATE.md", text)
+        self.assertIn("Try this first:", text)
+        self.assertIn("Use skill-context-keeper", text)
+
+    def test_chinese_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.zh-CN.md").read_text(encoding="utf-8")
+        for heading in [
+            "## 30 秒快速开始",
+            "## 安装",
+            "## 会创建或更新什么文件？",
+            "## 不适合什么时候用",
+            "## 相关技能",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("典型产物：", text)
+        self.assertIn(".agent-state/TASK_STATE.md", text)
+        self.assertIn("先这样对 Codex 说：", text)
+        self.assertIn("请用 skill-context-keeper", text)
+
     def test_reference_indexes_point_to_published_files(self):
         english = (ROOT / "references" / "README.md").read_text(encoding="utf-8")
         chinese = (ROOT / "references" / "README.zh-CN.md").read_text(encoding="utf-8")
diff --git a/skills/skill-handoff-summary/README.md b/skills/skill-handoff-summary/README.md
index 5512790..91fa612 100644
--- a/skills/skill-handoff-summary/README.md
+++ b/skills/skill-handoff-summary/README.md
@@ -4,64 +4,59 @@
 
 ## Overview
 
-`skill-handoff-summary` is the focused package for writing continuation-oriented pause or transfer summaries when long-running coding work needs to stop and resume later.
-It turns status, blockers, preserved constraints, and the exact next action into a compact restart note so the next session does not have to reconstruct intent from scattered thread history.
+`skill-handoff-summary` is the focused package for writing continuation-oriented pause or transfer notes.
 It is for compact downstream artifacts such as `.agent-state/HANDOFF.md`, not whole-project documentation.
 
-## Core Capabilities
+## Start Here In 30 Seconds
 
-`skill-handoff-summary` specializes in one narrow outcome: a handoff that is short, trusted, and immediately reusable.
+- Use this when: work is about to pause, switch owners, or cross into a new session.
+- You'll get: a compact restart note with current status, hard constraints, open problems, and the exact next action.
+- Typical output: updates `.agent-state/HANDOFF.md`.
 
-- write concise downstream artifacts such as `.agent-state/HANDOFF.md`
-- preserve current status, open problems, hard constraints, and the exact next action
-- include a reusable resume prompt for the next thread or session
-- stay focused on continuation instead of expanding into whole-project documentation
+Need a durable restart note? Use this.
+Just need a quick status update in chat? Don't use this.
 
-## Best For
+If you want to tell Codex exactly what to do:
 
-- pausing work at the end of a session with open tasks still pending
-- transferring a task to another agent that needs a trusted restart note
-- capturing blockers, decisions, and next actions before context goes stale
-- reducing the cost of resuming a thread after a handoff
+Try this first:
 
-If you already know the work is about to pause or change hands, this package is the right starting point.
-
-## What It Is Not For
-
-- rebuilding the current task state before work continues
-- deciding whether a task needs staged phases or checkpoints
-- coordinating the atomic packages as one suite-level workflow
-- maintaining long-term state across the whole task
-- producing whole-project documentation or repository tours
-- replacing the final user-facing answer when no handoff is needed
+- `Use skill-handoff-summary to write a compact continuation-oriented handoff before we pause.`
 
 ## Install
 
-To install `skill-handoff-summary`, use the standard published package path in this repository and choose the release or ref that fits your workflow.
-
 You can ask Codex in natural language:
 
 - `Use skill-installer to install skill-handoff-summary from Golden-Promise/codex-skill-library at skills/skill-handoff-summary.`
 - `Use skill-installer to install skill-handoff-summary from Golden-Promise/codex-skill-library at skills/skill-handoff-summary using ref v0.6.1.`
 
-For direct trigger examples and prompt wording, see [references/use-cases.md](references/use-cases.md).
+If you want the exact shell command, jump to [Install Details](#install-details).
 
-## Common Paths
+## What File Will This Create Or Update?
 
-Start with one of these three paths:
+The typical downstream file is `.agent-state/HANDOFF.md`.
 
-1. Pause a session while important work is still open.
-2. Transfer a task to another agent and preserve the restart context.
-3. Write `.agent-state/HANDOFF.md` with the exact next action and a reusable resume prompt.
+Use this package when you want that file to preserve:
 
-If you want ready-to-paste prompts, see [references/prompt-templates.en.md](references/prompt-templates.en.md).
+- task summary
+- current status
+- what changed in the current session
+- hard constraints to preserve
+- open problems
+- the exact next action
+- a reusable resume prompt
 
-## Direct Codex Usage
+## Don't Use This When
 
-If you want to tell Codex exactly what to do, say:
+- you need to rebuild the current task state before more work continues
+- you need a checkpoint around a risky or multi-file change
+- you only need a quick status note inside the current chat
+- you want whole-project documentation instead of a continuation-oriented handoff
 
-- `Use skill-handoff-summary to write a compact continuation-oriented handoff before we pause.`
-- `Use skill-handoff-summary to write .agent-state/HANDOFF.md with the exact next action and a reusable resume prompt.`
+## Related Skills
+
+- `skill-context-keeper` for refreshing `.agent-state/TASK_STATE.md`
+- `skill-phase-gate` for preflight and postflight checkpoints
+- `skill-task-continuity` for first-time continuity setup and routing
 
 ## Documentation
 
@@ -72,3 +67,14 @@ If you want to tell Codex exactly what to do, say:
 - Prompt templates: [references/prompt-templates.en.md](references/prompt-templates.en.md)
 - Chinese prompt templates: [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)
 - Handoff template: [assets/HANDOFF.template.md](assets/HANDOFF.template.md)
+
+## Install Details
+
+Replace `/path/to/install-skill-from-github.py` with the actual path to your local `skill-installer` checkout.
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-handoff-summary \
+  --ref v0.6.1
+```
diff --git a/skills/skill-handoff-summary/README.zh-CN.md b/skills/skill-handoff-summary/README.zh-CN.md
index fd6f767..c1bebcf 100644
--- a/skills/skill-handoff-summary/README.zh-CN.md
+++ b/skills/skill-handoff-summary/README.zh-CN.md
@@ -4,63 +4,59 @@
 
 ## 概述
 
-`skill-handoff-summary` 是一个专注型包，用于在长时间编码任务需要暂停或转交时，生成面向续做的简洁交接摘要。
-它把状态、阻塞点、需保留的硬约束，以及“下一步到底做什么”整理成紧凑的重启说明，避免下一位执行者从零翻线程历史。
+`skill-handoff-summary` 是一个专注型包，用于写出面向续做的暂停说明或转交说明。
+它服务的是诸如 `.agent-state/HANDOFF.md` 这样的紧凑下游产物，而不是整项目文档。
 
-## 核心能力
+## 30 秒快速开始
 
-`skill-handoff-summary` 只专注一个结果：写出短小、可信、可直接复用的交接。
+- 什么时候用：工作马上要暂停、换人，或者切进新的会话。
+- 你会得到什么：一份紧凑的重启说明，里面有当前状态、硬约束、开放问题和精确下一步。
+- 典型产物：更新 `.agent-state/HANDOFF.md`。
 
-- 写入诸如 `.agent-state/HANDOFF.md` 的紧凑下游产物
-- 保留当前状态、开放问题、硬约束，以及精确的下一步动作
-- 给下一次线程或会话附上一段可直接复用的 resume prompt
-- 聚焦续做，而不是膨胀成整项目文档
+如果你需要一份耐用的重启说明，就用它。
+如果你只是想在聊天里快速同步状态，就不要用它。
 
-## 适用场景
+如果你想直接告诉 Codex 怎么做：
 
-- 一次工作结束时还有未完成事项，需要先暂停
-- 把任务交给另一位执行者，并提供可信的重启说明
-- 在上下文继续变旧之前，先记录阻塞点、已做决定和下一步动作
-- 降低长线程在交接后的恢复成本
+先这样对 Codex 说：
 
-如果你已经确定工作即将暂停或换人，这个包就是更合适的入口。
-
-## 不适用场景
-
-- 在继续工作前重建当前任务状态
-- 决定一个任务是否需要分阶段或检查点
-- 以套件级工作流统筹多个原子包
-- 维护覆盖整个任务的长期状态
-- 生成整项目说明或仓库导览
-- 在根本不需要交接时替代最终用户答复
+- `请用 skill-handoff-summary 在暂停前写一个紧凑、面向续做的交接摘要。`
 
 ## 安装
 
-安装 `skill-handoff-summary` 时，请使用本仓库中的标准发布路径，并按你的工作流选择 release 或 ref。
-
-你也可以直接这样对 Codex 说：
+你可以直接这样对 Codex 说：
 
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-handoff-summary 安装 skill-handoff-summary。`
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-handoff-summary 安装 skill-handoff-summary，并使用 ref v0.6.1。`
 
-关于触发示例和提示词措辞，可查看 [references/use-cases.zh-CN.md](references/use-cases.zh-CN.md)。
+如果你想看精确的 shell 命令，可以直接跳到后面的 [安装细节](#安装细节)。
 
-## 常用路径
+## 会创建或更新什么文件？
 
-可以先从下面三条路径开始：
+最典型的下游文件是 `.agent-state/HANDOFF.md`。
 
-1. 在一次会话结束时暂停仍未完成的工作。
-2. 把任务转交给另一位执行者，并保留重启上下文。
-3. 在 `.agent-state/HANDOFF.md` 中写下精确下一步和可复用的 resume prompt。
+当你希望这个文件帮你保留下列信息时，就该用这个包：
 
-如果你想直接套用提示词模板，请查看 [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)。
+- 任务摘要
+- 当前状态
+- 本次会话改了什么
+- 需要保留的硬约束
+- 开放问题
+- 精确下一步动作
+- 一段可复用的 resume prompt
 
-## 直接告诉 Codex 怎么做
+## 不适合什么时候用
 
-如果你想直接用自然语言告诉 Codex，可以这样说：
+- 你需要在继续工作前先重建当前任务状态
+- 你需要给高风险或多文件改动加检查点
+- 你只是想在当前聊天里快速同步一下状态
+- 你要写的是整项目说明，而不是 continuation-oriented handoff
 
-- `请用 skill-handoff-summary 在暂停前写一个紧凑、面向续做的交接摘要。`
-- `请用 skill-handoff-summary 把交接写到 .agent-state/HANDOFF.md，并附上下一次会话可复用的 resume prompt。`
+## 相关技能
+
+- `skill-context-keeper`：适合刷新 `.agent-state/TASK_STATE.md`
+- `skill-phase-gate`：适合 preflight / postflight 检查点
+- `skill-task-continuity`：适合第一次搭建流程和做套件级路由
 
 ## 文档
 
@@ -71,3 +67,14 @@
 - 中文提示词模板：[references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)
 - English prompt templates: [references/prompt-templates.en.md](references/prompt-templates.en.md)
 - 交接模板：[assets/HANDOFF.template.md](assets/HANDOFF.template.md)
+
+## 安装细节
+
+把 `/path/to/install-skill-from-github.py` 换成你本地 `skill-installer` 仓库里的实际脚本路径。
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-handoff-summary \
+  --ref v0.6.1
+```
diff --git a/skills/skill-handoff-summary/tests/test_package_contract.py b/skills/skill-handoff-summary/tests/test_package_contract.py
index 637e36b..5a5ad22 100644
--- a/skills/skill-handoff-summary/tests/test_package_contract.py
+++ b/skills/skill-handoff-summary/tests/test_package_contract.py
@@ -73,6 +73,38 @@ def test_chinese_references_use_natural_resume_prompt_wording(self):
             text = path.read_text(encoding="utf-8")
             self.assertIn("请从 .agent-state/HANDOFF.md 继续这个任务。", text)
 
+    def test_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.md").read_text(encoding="utf-8")
+        for heading in [
+            "## Start Here In 30 Seconds",
+            "## Install",
+            "## What File Will This Create Or Update?",
+            "## Don't Use This When",
+            "## Related Skills",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("Typical output:", text)
+        self.assertIn(".agent-state/HANDOFF.md", text)
+        self.assertIn("Try this first:", text)
+        self.assertIn("Use skill-handoff-summary", text)
+        self.assertIn("Just need a quick status update in chat?", text)
+
+    def test_chinese_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.zh-CN.md").read_text(encoding="utf-8")
+        for heading in [
+            "## 30 秒快速开始",
+            "## 安装",
+            "## 会创建或更新什么文件？",
+            "## 不适合什么时候用",
+            "## 相关技能",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("典型产物：", text)
+        self.assertIn(".agent-state/HANDOFF.md", text)
+        self.assertIn("先这样对 Codex 说：", text)
+        self.assertIn("请用 skill-handoff-summary", text)
+        self.assertIn("如果你只是想在聊天里快速同步状态", text)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/skills/skill-phase-gate/README.md b/skills/skill-phase-gate/README.md
index 55bed1d..358ec02 100644
--- a/skills/skill-phase-gate/README.md
+++ b/skills/skill-phase-gate/README.md
@@ -5,70 +5,52 @@
 ## Overview
 
 `skill-phase-gate` adds compact preflight and postflight checkpoints around meaningful coding work.
-It keeps risky execution intentional without taking over long-term task state, generic planning, or final handoffs.
+If the checkpoint itself adds value, use this skill.
 
-## Core Capabilities
+## Start Here In 30 Seconds
 
-`skill-phase-gate` focuses on making high-value checkpoints crisp and repeatable.
+- Use this when: you are about to make a risky, multi-file, or otherwise meaningful change.
+- You'll get: a compact checkpoint that makes scope, constraints, verification, and remaining risk explicit.
+- Typical outputs: a preflight note shaped like `assets/PREFLIGHT.template.md` and a postflight note shaped like `assets/POSTFLIGHT.template.md`.
 
-- define a preflight checkpoint around goal, constraints, scope, and verification
-- capture a postflight checkpoint around actual changes, validations, and remaining risks
-- make checkpoint use explicit for meaningful edits instead of every small action
-- leave long-term state to `skill-context-keeper` and handoffs to `skill-handoff-summary`
+If you want to tell Codex exactly what to do:
 
-## Best For
+Try this first:
 
-- preflight before a refactor, migration, or other multi-file change
-- postflight after a meaningful edit when you want to verify what actually changed
-- risky edits where expected files, explicit non-goals, and a verification plan should be clear
-- pre-commit checkpoints when the work deserves one more deliberate pass
-
-If the value comes from pausing to confirm scope and validation, this package is the right fit.
-
-## Checkpoint Bar
-
-Use this package when the checkpoint itself is valuable:
-
-- good fit: refactors, multi-file changes, risky edits, or pre-commit checkpoints
-- bad fit: typo fixes, tiny one-line changes, pure explanation tasks, or generic planning requests
-
-## What It Is Not For
-
-- not for trivial one-line edits
-- not for pure explanation tasks
-- reconstructing stale or missing task context
-- summarizing the current state after an interruption
-- writing a pause note or transfer package for another agent
-- owning long-term state that belongs to `skill-context-keeper`
-- orchestrating the whole long-task continuity suite
+- `Use skill-phase-gate to create a preflight gate before this risky multi-file change.`
 
 ## Install
 
-To install `skill-phase-gate`, use the standard published package path in this repository and choose the release or ref that fits your workflow.
-
 You can ask Codex in natural language:
 
 - `Use skill-installer to install skill-phase-gate from Golden-Promise/codex-skill-library at skills/skill-phase-gate.`
 - `Use skill-installer to install skill-phase-gate from Golden-Promise/codex-skill-library at skills/skill-phase-gate using ref v0.6.1.`
 
-For direct trigger examples and prompt wording, see [references/use-cases.md](references/use-cases.md).
+If you want the exact shell command, jump to [Install Details](#install-details).
 
-## Common Paths
+## What File Will This Create Or Update?
 
-Start with one of these three paths:
+This package usually creates or refreshes a preflight checkpoint note, a postflight checkpoint note, or both.
 
-1. Run a preflight before a refactor, migration, or risky multi-file change.
-2. Run a postflight after meaningful implementation work.
-3. Add a deliberate pre-commit checkpoint when the change deserves one.
+Use the shipped templates as the starting shape:
 
-If you want ready-to-paste prompts, see [references/prompt-templates.en.md](references/prompt-templates.en.md).
+- [assets/PREFLIGHT.template.md](assets/PREFLIGHT.template.md)
+- [assets/POSTFLIGHT.template.md](assets/POSTFLIGHT.template.md)
 
-## Direct Codex Usage
+## Don't Use This When
 
-If you want to tell Codex exactly what to do, say:
+- the change is a trivial one-line edit
+- the work is a pure explanation task
+- the main problem is stale task state rather than checkpoint value
+- you need a pause or transfer handoff instead of a workflow checkpoint
 
-- `Use skill-phase-gate to create a preflight gate before this risky multi-file change.`
-- `Use skill-phase-gate to create a postflight gate for this meaningful edit before I commit.`
+This package is not for trivial one-line edits and is not for pure explanation tasks.
+
+## Related Skills
+
+- `skill-context-keeper` for rebuilding task state before or after meaningful work
+- `skill-handoff-summary` for pause and transfer notes
+- `skill-task-continuity` for first-time setup and suite-level routing
 
 ## Documentation
 
@@ -80,3 +62,14 @@ If you want to tell Codex exactly what to do, say:
 - Chinese prompt templates: [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)
 - Preflight checklist: [assets/PREFLIGHT.template.md](assets/PREFLIGHT.template.md)
 - Postflight checklist: [assets/POSTFLIGHT.template.md](assets/POSTFLIGHT.template.md)
+
+## Install Details
+
+Replace `/path/to/install-skill-from-github.py` with the actual path to your local `skill-installer` checkout.
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-phase-gate \
+  --ref v0.6.1
+```
diff --git a/skills/skill-phase-gate/README.zh-CN.md b/skills/skill-phase-gate/README.zh-CN.md
index caa415b..d4ddc02 100644
--- a/skills/skill-phase-gate/README.zh-CN.md
+++ b/skills/skill-phase-gate/README.zh-CN.md
@@ -5,70 +5,52 @@
 ## 概述
 
 `skill-phase-gate` 用于在有分量的编码工作前后加入紧凑的 preflight / postflight 检查点。
-它帮助高风险执行保持清晰，但不会接管长期任务状态、泛化规划或最终交接。
+如果“加一道检查点”这件事本身就有价值，就该用它。
 
-## 核心能力
+## 30 秒快速开始
 
-`skill-phase-gate` 聚焦的是把高价值检查点做得清楚、可重复。
+- 什么时候用：你马上要做高风险、多文件，或其他明显有分量的改动。
+- 你会得到什么：一个紧凑的检查点，把范围、约束、验证方式和剩余风险说清楚。
+- 典型产物：一个按 `assets/PREFLIGHT.template.md` 组织的 preflight 说明，以及一个按 `assets/POSTFLIGHT.template.md` 组织的 postflight 说明。
 
-- 围绕目标、约束、范围和验证计划定义 preflight 检查点
-- 围绕实际改动、实际验证和剩余风险记录 postflight 检查点
-- 只在有分量的改动中显式使用检查点，而不是给每个小动作都加门
-- 把长期状态交给 `skill-context-keeper`，把交接交给 `skill-handoff-summary`
+如果你想直接告诉 Codex 怎么做：
 
-## 适用场景
+先这样对 Codex 说：
 
-- 在重构、迁移或多文件改动前做 preflight
-- 在完成一次有分量的修改后做 postflight，核对实际改动和验证结果
-- 对高风险编辑先明确预期修改范围、明确不改动的范围以及验证计划
-- 在提交前增加一次有意义的检查点
-
-如果价值主要来自“先停下来确认范围和验证方式”，这个包就是更合适的入口。
-
-## 检查点门槛
-
-只有当“加一道检查点”本身有价值时才适合使用：
-
-- 适合：重构、多文件修改、高风险编辑、提交前检查点
-- 不适合：typo 修复、极小的一行改动、纯说明类请求、泛化规划
-
-## 不适用场景
-
-- 不适合琐碎的一行改动
-- 不适合纯解释或纯讲解任务
-- 重建过时或缺失的任务上下文
-- 在中断后刷新当前状态
-- 为另一个执行者撰写暂停或转交说明
-- 持有本应由 `skill-context-keeper` 维护的长期状态
-- 统筹整套长任务连续性套件
+- `请用 skill-phase-gate 在这次高风险多文件修改前生成一个 preflight gate。`
 
 ## 安装
 
-安装 `skill-phase-gate` 时，请使用本仓库中的标准发布路径，并按你的工作流选择 release 或 ref。
-
-你也可以直接这样对 Codex 说：
+你可以直接这样对 Codex 说：
 
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-phase-gate 安装 skill-phase-gate。`
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-phase-gate 安装 skill-phase-gate，并使用 ref v0.6.1。`
 
-关于触发示例和提示词措辞，可查看 [references/use-cases.zh-CN.md](references/use-cases.zh-CN.md)。
+如果你想看精确的 shell 命令，可以直接跳到后面的 [安装细节](#安装细节)。
 
-## 常用路径
+## 会创建或更新什么文件？
 
-可以先从下面三条路径开始：
+这个包通常会创建或刷新一份 preflight 检查点说明、一份 postflight 检查点说明，或者两者都写。
 
-1. 在重构、迁移或高风险多文件改动前做 preflight。
-2. 在完成有分量的实现后做 postflight。
-3. 在提交前为重要改动增加一次有意识的检查点。
+它自带的两个模板就是最直接的起点：
 
-如果你想直接套用提示词模板，请查看 [references/prompt-templates.zh-CN.md](references/prompt-templates.zh-CN.md)。
+- [assets/PREFLIGHT.template.md](assets/PREFLIGHT.template.md)
+- [assets/POSTFLIGHT.template.md](assets/POSTFLIGHT.template.md)
 
-## 直接告诉 Codex 怎么做
+## 不适合什么时候用
 
-如果你想直接用自然语言告诉 Codex，可以这样说：
+- 这次改动只是一个琐碎的一行编辑
+- 这次工作只是纯解释、纯说明
+- 当前真正的问题是任务状态过旧，而不是检查点缺失
+- 你需要的是暂停或转交 handoff，而不是流程检查点
 
-- `请用 skill-phase-gate 在这次高风险多文件修改前生成一个 preflight gate。`
-- `请用 skill-phase-gate 在我提交前为这次有分量的改动生成一个 postflight gate。`
+这个包不适合 trivial one-line edits，也不适合 pure explanation tasks。
+
+## 相关技能
+
+- `skill-context-keeper`：适合在重要工作前后重建任务状态
+- `skill-handoff-summary`：适合暂停或转交时写 handoff
+- `skill-task-continuity`：适合第一次搭建整套流程和做套件级路由
 
 ## 文档
 
@@ -80,3 +62,14 @@
 - English prompt templates: [references/prompt-templates.en.md](references/prompt-templates.en.md)
 - preflight 清单：[assets/PREFLIGHT.template.md](assets/PREFLIGHT.template.md)
 - postflight 清单：[assets/POSTFLIGHT.template.md](assets/POSTFLIGHT.template.md)
+
+## 安装细节
+
+把 `/path/to/install-skill-from-github.py` 换成你本地 `skill-installer` 仓库里的实际脚本路径。
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-phase-gate \
+  --ref v0.6.1
+```
diff --git a/skills/skill-phase-gate/tests/test_package_contract.py b/skills/skill-phase-gate/tests/test_package_contract.py
index af4f006..4f01309 100644
--- a/skills/skill-phase-gate/tests/test_package_contract.py
+++ b/skills/skill-phase-gate/tests/test_package_contract.py
@@ -54,6 +54,38 @@ def test_readme_includes_direct_natural_language_usage(self):
         self.assertIn("if you want to tell codex exactly what to do", text)
         self.assertIn("use skill-phase-gate to create a preflight gate", text)
 
+    def test_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.md").read_text(encoding="utf-8")
+        for heading in [
+            "## Start Here In 30 Seconds",
+            "## Install",
+            "## What File Will This Create Or Update?",
+            "## Don't Use This When",
+            "## Related Skills",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("Typical outputs:", text)
+        self.assertIn("PREFLIGHT.template.md", text)
+        self.assertIn("POSTFLIGHT.template.md", text)
+        self.assertIn("Try this first:", text)
+        self.assertIn("Use skill-phase-gate", text)
+
+    def test_chinese_readme_has_fast_entry_sections(self):
+        text = (ROOT / "README.zh-CN.md").read_text(encoding="utf-8")
+        for heading in [
+            "## 30 秒快速开始",
+            "## 安装",
+            "## 会创建或更新什么文件？",
+            "## 不适合什么时候用",
+            "## 相关技能",
+        ]:
+            self.assertIn(heading, text)
+        self.assertIn("典型产物：", text)
+        self.assertIn("PREFLIGHT.template.md", text)
+        self.assertIn("POSTFLIGHT.template.md", text)
+        self.assertIn("先这样对 Codex 说：", text)
+        self.assertIn("请用 skill-phase-gate", text)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/skills/skill-task-continuity/README.md b/skills/skill-task-continuity/README.md
index 16c8982..e3fa095 100644
--- a/skills/skill-task-continuity/README.md
+++ b/skills/skill-task-continuity/README.md
@@ -4,112 +4,80 @@
 
 ## Overview
 
-`skill-task-continuity` is the suite entry point for long-task continuity.
-It explains how the continuity packages fit together and ships a bootstrap helper that copies downstream templates into a consumer repository.
-It does not replace the atomic skills.
+`skill-task-continuity` is the beginner entry package for the long-task continuity suite.
+Start here if you are setting up the continuity workflow in a project for the first time.
 
-## Core Capabilities
+## Start Here In 30 Seconds
 
-`skill-task-continuity` focuses on composition and downstream setup.
+- Use this when: you want to set up the continuity workflow in a repo, understand the suite, or decide which continuity skill to use next.
+- You'll get: starter files for a downstream repo, a simple long-task loop, and a clear route to the atomic skills.
+- Typical output: a downstream `AGENTS.md` plus `.agent-state/` starter files.
 
-- explain how `skill-context-keeper`, `skill-phase-gate`, and `skill-handoff-summary` fit together
-- bootstrap downstream files such as `AGENTS.md` and `.agent-state/*.md`
-- route suite-shaped requests to the atomic package that owns the next action
-- keep the public-package boundary explicit so templates remain downstream assets, not live repo-root runtime files
+If you want to tell Codex exactly what to do:
 
-## Best For
+Try this first:
 
-- adopting the continuity workflow in a downstream repository for the first time
-- setting up downstream templates before long-running work starts
-- deciding which atomic package should own the next action
-- teaching maintainers or downstream users how the suite composes without blurring package boundaries
-
-## What It Is Not For
-
-- replacing `skill-context-keeper` for ordinary state refresh work
-- replacing `skill-phase-gate` for a normal checkpoint
-- replacing `skill-handoff-summary` for a simple pause or transfer note
-- turning this public library checkout into a consumer repo
+- `Use skill-task-continuity to bootstrap the long-task continuity starter files into /path/to/downstream-repo. Preview the file operations first, then apply them if the preview looks correct. Do not overwrite existing files unless I explicitly ask.`
 
 ## Install
 
-Choose one of these install paths:
-
-- install only `skill-task-continuity` when you want the suite entry docs and downstream bootstrap helper first
-- install the full suite in one command when you want all four continuity packages available immediately
-
-Installing `skill-task-continuity` does not auto-install the three atomic packages.
-Use the full-suite install command when you want all four packages together without running four separate installer commands.
+For most newcomers, natural-language installation is the easiest path.
 
-You can ask Codex in natural language:
+You can ask Codex to install only this package:
 
 - `Use skill-installer to install skill-task-continuity from Golden-Promise/codex-skill-library at skills/skill-task-continuity.`
-- `Use skill-installer to install skill-task-continuity from Golden-Promise/codex-skill-library at skills/skill-task-continuity using ref v0.6.1.`
-- `Use skill-installer to install the full long-task continuity suite from Golden-Promise/codex-skill-library at skills/skill-context-keeper, skills/skill-phase-gate, skills/skill-handoff-summary, and skills/skill-task-continuity.`
 
-If you want the direct command for the full suite, install all four packages in one command:
+You can also ask Codex to install the full suite:
 
-```bash
-python3 <path-to-skill-installer>/scripts/install-skill-from-github.py \
-  --repo Golden-Promise/codex-skill-library \
-  --path \
-    skills/skill-context-keeper \
-    skills/skill-phase-gate \
-    skills/skill-handoff-summary \
-    skills/skill-task-continuity
-```
-
-Add `--ref v0.6.1` when you want to pin the current published release.
+- `Use skill-installer to install the full long-task continuity suite from Golden-Promise/codex-skill-library at skills/skill-context-keeper, skills/skill-phase-gate, skills/skill-handoff-summary, and skills/skill-task-continuity.`
 
-For downstream bootstrap walkthroughs and prompt wording, see [references/install-playbook.md](references/install-playbook.md).
+Installing `skill-task-continuity` does not auto-install the atomic packages.
+If you want all four packages at once, install the full suite in one command or use the full-suite natural-language prompt above.
 
-## Recommended Downstream Layout
+If you want the exact shell commands, jump to [Install Details](#install-details).
 
-```text
-AGENTS.md
-.agent-state/
-  TASK_STATE.md
-  HANDOFF.md
-  DECISIONS.md
-  RUN_LOG.md
-```
+## What Gets Created In Your Repo
 
-`TASK_STATE.md` and `HANDOFF.md` are duplicated copies of the atomic package templates for downstream convenience.
-The atomic packages remain the source of truth for their behavior and wording.
+The bootstrap helper prepares downstream starter files such as:
 
-## Common Paths
+- `AGENTS.md`
+- `.agent-state/TASK_STATE.md`
+- `.agent-state/HANDOFF.md`
+- `.agent-state/DECISIONS.md`
+- `.agent-state/RUN_LOG.md`
 
-Start with one of these three paths:
+`TASK_STATE.md` and `HANDOFF.md` are convenience copies of the atomic package templates so a downstream repo can start quickly.
 
-1. Bootstrap a downstream repository with `AGENTS.md` and `.agent-state/` templates.
-2. Read the composition guide and decide which atomic package owns the next action.
-3. Add thin repo-local wrappers only when a downstream repository truly needs them.
+## Fastest Setup
 
-The bootstrap helper requires an explicit target and refuses to bootstrap inside this public skill library checkout.
+After installation, the fastest setup path is:
 
-If you want Codex to handle bootstrap in natural language, say:
+1. Ask Codex to bootstrap the starter files into your downstream repo.
+2. Review the created `AGENTS.md` and `.agent-state/` files.
+3. Start the first real task by calling the atomic package that owns the next action.
 
-- `Use skill-task-continuity to bootstrap the long-task continuity starter files into /path/to/downstream-repo. Preview the file operations first, then apply them if the preview looks correct. Do not overwrite existing files unless I explicitly ask.`
+If you need exact CLI control instead, use `python3 skills/skill-task-continuity/scripts/bootstrap_suite.py --target /path/to/downstream-repo --dry-run` first, then rerun without `--dry-run` to apply.
 
-If you want exact CLI control instead, use `python3 skills/skill-task-continuity/scripts/bootstrap_suite.py --target /path/to/downstream-repo --dry-run` to preview changes, then rerun without `--dry-run` to apply them.
+## Which Skill To Use Next
 
-## How The Suite Composes
+- Use `skill-context-keeper` when the task is active but the state picture is stale.
+- Use `skill-phase-gate` when the next step is a risky or multi-file change.
+- Use `skill-handoff-summary` when you are about to pause or transfer the work.
 
-Use the atomic skills directly in downstream work:
+## Don't Use This When
 
-- `Use $skill-context-keeper to refresh .agent-state/TASK_STATE.md before more implementation work.`
-- `Use $skill-phase-gate for a preflight before this risky multi-file change.`
-- `Use $skill-handoff-summary to write .agent-state/HANDOFF.md before we pause.`
+- you only need one atomic package for one immediate action
+- you only need to refresh task state
+- you only need a checkpoint around a meaningful change
+- you only need a pause or transfer note
 
-The recommended long-task loop is:
+This package does not replace the three atomic skills and does not turn this public library checkout into a consumer repo.
 
-1. Read the state files before resuming.
-2. Gate meaningful changes when the checkpoint adds value.
-3. Refresh task state after meaningful work.
-4. Write a handoff when pausing or transferring ownership.
+## Related Skills
 
-Repo-local `.agents/skills/` wrappers or examples are optional.
-If you add them, keep them thin and point back to the atomic skills instead of replacing them.
+- `skill-context-keeper` for `.agent-state/TASK_STATE.md`
+- `skill-phase-gate` for preflight and postflight checkpoints
+- `skill-handoff-summary` for `.agent-state/HANDOFF.md`
 
 ## Documentation
 
@@ -119,3 +87,29 @@ If you add them, keep them thin and point back to the atomic skills instead of r
 - Install playbook: [references/install-playbook.md](references/install-playbook.md)
 - Chinese install playbook: [references/install-playbook.zh-CN.md](references/install-playbook.zh-CN.md)
 - Downstream templates copied by the bootstrap helper: `assets/`
+
+## Install Details
+
+Replace `/path/to/install-skill-from-github.py` with the actual path to your local `skill-installer` checkout.
+
+Install only this package:
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-task-continuity \
+  --ref v0.6.1
+```
+
+Install the full suite in one command:
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path \
+    skills/skill-context-keeper \
+    skills/skill-phase-gate \
+    skills/skill-handoff-summary \
+    skills/skill-task-continuity \
+  --ref v0.6.1
+```
diff --git a/skills/skill-task-continuity/README.zh-CN.md b/skills/skill-task-continuity/README.zh-CN.md
index 463e239..ee3b261 100644
--- a/skills/skill-task-continuity/README.zh-CN.md
+++ b/skills/skill-task-continuity/README.zh-CN.md
@@ -4,112 +4,80 @@
 
 ## 概述
 
-`skill-task-continuity` 是长任务连续性套件的入口包。
-它负责解释各个连续性包如何组合，并提供一个启动脚本，把下游仓库需要的模板复制进去。
-它不会取代原子技能包。
+`skill-task-continuity` 是长任务连续性套件面向新手的入口包。
+如果你是第一次想在一个项目里搭好连续性工作流，就从这里开始。
 
-## 核心能力
+## 30 秒快速开始
 
-`skill-task-continuity` 聚焦的是组合说明和下游初始化。
+- 什么时候用：你想把连续性工作流装进一个仓库、理解整套工具链，或者判断下一步该用哪个连续性技能。
+- 你会得到什么：一组下游启动文件、一个简单的长任务循环，以及通往三个原子技能的清晰入口。
+- 典型产物：下游仓库里的 `AGENTS.md` 和 `.agent-state/` 启动文件。
 
-- 解释 `skill-context-keeper`、`skill-phase-gate`、`skill-handoff-summary` 三个原子包如何组合
-- 为下游仓库启动 `AGENTS.md` 与 `.agent-state/*.md` 等文件
-- 在套件级请求中，把工作路由到真正拥有下一步动作的原子包
-- 明确公共包边界，让模板保持为下游资产，而不是仓库根目录里的运行时文件
+如果你想直接告诉 Codex 怎么做：
 
-## 适用场景
+先这样对 Codex 说：
 
-- 第一次在下游仓库中采用连续性工作流
-- 在长任务开始前为下游仓库准备模板
-- 判断下一步到底该由哪个原子包负责
-- 向维护者或下游用户解释整套连续性流程，而不打乱包边界
-
-## 不适用场景
-
-- 用来替代 `skill-context-keeper` 的普通状态刷新
-- 用来替代 `skill-phase-gate` 的常规检查点
-- 用来替代 `skill-handoff-summary` 的简单暂停或转交说明
-- 把这个公共技能库工作区改造成消费者仓库
+- `请用 skill-task-continuity 把长任务连续性启动文件引导到 /path/to/downstream-repo。先预览文件操作，确认无误后再正式写入；除非我明确要求，否则不要覆盖已有文件。`
 
 ## 安装
 
-安装时可以走下面两条路径之一：
+对于第一次使用的人来说，最轻松的方式是直接用自然语言让 Codex 安装。
 
-- 只安装 `skill-task-continuity`，适合先获得套件入口说明和下游 bootstrap 能力
-- 用一条命令安装整套工具链，适合一开始就把 4 个连续性包全部装好
-
-安装 `skill-task-continuity` 本身不会自动把另外三个原子包一起装上。
-如果你想一次拿到 4 个包，应该显式使用“整套安装”的命令，而不是分别跑 4 次安装器。
-
-你也可以直接这样对 Codex 说：
+你可以先只安装这个入口包：
 
 - `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-task-continuity 安装 skill-task-continuity。`
-- `请用 skill-installer 从 Golden-Promise/codex-skill-library 的 skills/skill-task-continuity 安装 skill-task-continuity，并使用 ref v0.6.1。`
-- `请用 skill-installer 从 Golden-Promise/codex-skill-library 一次安装整套长任务连续性工具链，包括 skills/skill-context-keeper、skills/skill-phase-gate、skills/skill-handoff-summary 和 skills/skill-task-continuity。`
 
-如果你想直接执行命令，可以用一条命令安装整套工具链：
+你也可以让 Codex 直接安装整套工具链：
 
-```bash
-python3 <path-to-skill-installer>/scripts/install-skill-from-github.py \
-  --repo Golden-Promise/codex-skill-library \
-  --path \
-    skills/skill-context-keeper \
-    skills/skill-phase-gate \
-    skills/skill-handoff-summary \
-    skills/skill-task-continuity
-```
+- `请用 skill-installer 从 Golden-Promise/codex-skill-library 一次安装整套长任务连续性工具链，包括 skills/skill-context-keeper、skills/skill-phase-gate、skills/skill-handoff-summary 和 skills/skill-task-continuity。`
 
-如果你要固定到当前发布版本，再补上 `--ref v0.6.1` 即可。
+安装 `skill-task-continuity` 本身不会自动把另外三个原子包一起装上。
+如果你想一次拿到 4 个包，应该显式安装整套；你可以用上面的自然语言提示，也可以在后面的安装细节里用一条命令完成。
 
-关于下游启动流程和提示词措辞，可查看 [references/install-playbook.zh-CN.md](references/install-playbook.zh-CN.md)。
+如果你想看精确的 shell 命令，可以直接跳到后面的 [安装细节](#安装细节)。
 
-## 推荐的下游布局
+## 你的仓库里会创建什么
 
-```text
-AGENTS.md
-.agent-state/
-  TASK_STATE.md
-  HANDOFF.md
-  DECISIONS.md
-  RUN_LOG.md
-```
+bootstrap helper 会为下游仓库准备这些启动文件：
 
-`TASK_STATE.md` 与 `HANDOFF.md` 是从原子包复制过来的重复模板，目的是方便下游仓库一次性完成启动。
-它们的真实来源和行为边界仍然属于对应的原子包。
+- `AGENTS.md`
+- `.agent-state/TASK_STATE.md`
+- `.agent-state/HANDOFF.md`
+- `.agent-state/DECISIONS.md`
+- `.agent-state/RUN_LOG.md`
 
-## 常用路径
+其中 `TASK_STATE.md` 和 `HANDOFF.md` 是从原子包模板复制来的便利副本，目的是让下游仓库更快起步。
 
-可以先从下面三条路径开始：
+## 最快的开始方式
 
-1. 为下游仓库启动 `AGENTS.md` 和 `.agent-state/` 模板。
-2. 先读组合说明，再决定下一步该交给哪个原子包。
-3. 只有在下游仓库确实需要时，才补充轻量的 repo-local wrapper。
+安装之后，最快的起步路径是：
 
-启动脚本要求显式传入目标路径，并且会拒绝在这个公共技能库工作区内执行。
+1. 让 Codex 把启动文件 bootstrap 到你的下游仓库。
+2. 查看生成的 `AGENTS.md` 和 `.agent-state/` 文件。
+3. 真正开始做任务时，直接调用拥有“下一步动作”的原子技能。
 
-如果你想直接用自然语言让 Codex 帮你完成初始化，可以这样说：
+如果你想精确控制 CLI，也可以先运行 `python3 skills/skill-task-continuity/scripts/bootstrap_suite.py --target /path/to/downstream-repo --dry-run` 预览，再去掉 `--dry-run` 正式应用。
 
-- `请用 skill-task-continuity 把长任务连续性启动文件引导到 /path/to/downstream-repo。先预览文件操作，确认无误后再正式写入；除非我明确要求，否则不要覆盖已有文件。`
+## 下一步该用哪个技能
 
-如果你想自己精确执行命令，则可以先运行 `python3 skills/skill-task-continuity/scripts/bootstrap_suite.py --target /path/to/downstream-repo --dry-run` 预览变更，再去掉 `--dry-run` 正式应用。
+- 当任务还在继续，但状态图景已经变旧时，用 `skill-context-keeper`。
+- 当下一步是高风险或多文件改动时，用 `skill-phase-gate`。
+- 当你即将暂停或转交工作时，用 `skill-handoff-summary`。
 
-## 套件如何组合
+## 不适合什么时候用
 
-在下游工作中，仍然直接调用原子技能：
+- 你只需要某一个原子技能来完成一个立即动作
+- 你只需要刷新任务状态
+- 你只需要给重要改动加一个检查点
+- 你只需要写一份暂停或转交说明
 
-- `Use $skill-context-keeper to refresh .agent-state/TASK_STATE.md before more implementation work.`
-- `Use $skill-phase-gate for a preflight before this risky multi-file change.`
-- `Use $skill-handoff-summary to write .agent-state/HANDOFF.md before we pause.`
+这个包不会替代三个原子技能，也不会把这个公共技能库工作区变成消费者仓库。
 
-推荐的长任务循环如下：
+## 相关技能
 
-1. 恢复工作前先读取状态文件。
-2. 当检查点本身有价值时，为重要改动加上 gate。
-3. 完成有意义的工作后刷新任务状态。
-4. 暂停或转交时写出 handoff。
-
-仓库本地的 `.agents/skills/` 包装或示例是可选的。
-如果使用，建议保持轻量，并继续回指原子技能，而不是自行替代它们。
+- `skill-context-keeper`：处理 `.agent-state/TASK_STATE.md`
+- `skill-phase-gate`：处理 preflight / postflight 检查点
+- `skill-handoff-summary`：处理 `.agent-state/HANDOFF.md`
 
 ## 文档
 
@@ -119,3 +87,29 @@ AGENTS.md
 - 下游仓库启动流程：[references/install-playbook.zh-CN.md](references/install-playbook.zh-CN.md)
 - English install playbook: [references/install-playbook.md](references/install-playbook.md)
 - 启动脚本复制的下游模板：`assets/`
+
+## 安装细节
+
+把 `/path/to/install-skill-from-github.py` 换成你本地 `skill-installer` 仓库里的实际脚本路径。
+
+只安装这个入口包：
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path skills/skill-task-continuity \
+  --ref v0.6.1
+```
+
+用一条命令安装整套工具链：
+
+```bash
+python3 /path/to/install-skill-from-github.py \
+  --repo Golden-Promise/codex-skill-library \
+  --path \
+    skills/skill-context-keeper \
+    skills/skill-phase-gate \
+    skills/skill-handoff-summary \
+    skills/skill-task-continuity \
+  --ref v0.6.1
+```
diff --git a/skills/skill-task-continuity/tests/test_docs_contract.py b/skills/skill-task-continuity/tests/test_docs_contract.py
index 08a449f..cc10ece 100644
--- a/skills/skill-task-continuity/tests/test_docs_contract.py
+++ b/skills/skill-task-continuity/tests/test_docs_contract.py
@@ -6,6 +6,25 @@
 
 
 class SkillTaskContinuityDocsContractTests(unittest.TestCase):
+    def test_skills_index_includes_quick_continuity_picker(self):
+        english = ROOT.parents[0] / "README.md"
+        chinese = ROOT.parents[0] / "README.zh-CN.md"
+
+        english_text = english.read_text(encoding="utf-8")
+        chinese_text = chinese.read_text(encoding="utf-8")
+
+        self.assertIn("## Pick the Right Continuity Skill", english_text)
+        self.assertIn("skill-context-keeper", english_text)
+        self.assertIn("skill-phase-gate", english_text)
+        self.assertIn("skill-handoff-summary", english_text)
+        self.assertIn("skill-task-continuity", english_text)
+
+        self.assertIn("## 选择合适的连续性技能", chinese_text)
+        self.assertIn("skill-context-keeper", chinese_text)
+        self.assertIn("skill-phase-gate", chinese_text)
+        self.assertIn("skill-handoff-summary", chinese_text)
+        self.assertIn("skill-task-continuity", chinese_text)
+
     def test_english_readme_mentions_full_suite_install(self):
         text = (ROOT / "README.md").read_text(encoding="utf-8")
         lowered = text.lower()
@@ -52,6 +71,35 @@ def test_chinese_install_playbook_prefers_natural_language_bootstrap(self):
         self.assertIn("--dry-run", text)
         self.assertIn("--force", text)
 
+    def test_bilingual_readme_has_beginner_entry_sections(self):
+        english = (ROOT / "README.md").read_text(encoding="utf-8")
+        chinese = (ROOT / "README.zh-CN.md").read_text(encoding="utf-8")
+
+        for heading in [
+            "## Start Here In 30 Seconds",
+            "## What Gets Created In Your Repo",
+            "## Fastest Setup",
+            "## Which Skill To Use Next",
+            "## Install",
+            "## Related Skills",
+        ]:
+            self.assertIn(heading, english)
+
+        for heading in [
+            "## 30 秒快速开始",
+            "## 你的仓库里会创建什么",
+            "## 最快的开始方式",
+            "## 下一步该用哪个技能",
+            "## 安装",
+            "## 相关技能",
+        ]:
+            self.assertIn(heading, chinese)
+
+        self.assertIn("Try this first:", english)
+        self.assertIn("Use skill-task-continuity", english)
+        self.assertIn("先这样对 Codex 说：", chinese)
+        self.assertIn("请用 skill-task-continuity", chinese)
+
 
 if __name__ == "__main__":
     unittest.main()