@@ -141,14 +141,18 @@ devcodex profile plan|init
 | 工作区 skill（W 优先） | `.devcodex/workspace/skills/<id>/SKILL.md` |
 | 全局 skill（hidden） | `~/.agents/devcodex/skills/<id>/`（菜单可能不显示，仍可加载） |
 
+**未发布源码候选**：渐进式 Skill 路由会在每轮建立 W + managed G 动态快照，再按 catalog → commit → stage 分页加载正文；全程使用宿主按需启动的本地 stdio MCP 子进程，不监听端口，也不需要服务端。新增或修改 `.devcodex/workspace/skills/<id>/SKILL.md` 会让旧快照失效，并在下一轮重新发现。
+
+Codex/Claude 等宿主自己的 `AGENTS.md`、`CLAUDE.md`、原生个人/项目 Skill 仍由宿主负责发现。DevCodex 不扫描、复制、合并、覆盖或删除这些用户资产；同名也不视为 DevCodex 所有权。Codex 项目指令使用 `AGENTS.md`（不是 `codex.md`），Claude 项目指令使用精确文件名 `CLAUDE.md`，Skill 入口使用精确文件名 `SKILL.md`。
+
 ---
 
 ## 宿主能力（诚实上限）
 
 | 宿主 | 大致能力 |
 |------|----------|
 | Claude Code / Codex / Copilot CLI 等 | Hook 较完整时可硬拦危险命令、Stop 收口 |
-| **Grok** | **Partial**：UserPromptSubmit **不能**可靠注入；靠读 skill + 条件 Stop |
+| **Grok** | **Partial**：UserPromptSubmit **不能**可靠注入；`devcodex grok` 的 exact global-launcher + local-stdio 变体通过新鲜 S15 时可使用渐进式 Skill 路由，其他入口回退 legacy |
 | 仅 Instruction 的 surface | 语义约束，不保证硬拦 |
 
 「adapter 已安装」≠「五宿主能力完全一致」。
@@ -245,7 +249,7 @@ Node：`^20.19 || >=22.12`（仅文档站）。
 ## 用户可见交付与链接兼容
 
 用户可见交付物应带可定位路径（工作区相对路径优先）；宿主证据不足时用 portable 链接，不假装全宿主可点。  
-MCP 侧常见入口含 `profile_load`；工作流技能按意图 **invoke**（按需读取，非整库预载）。  
+MCP 侧先用 `profile_context_plan` 生成有界计划，再由 `profile_load` 完成选定正文；记忆侧先用 `memory_status` 定位，再按需查询。完成状态以绑定的 `ContextReadReceiptV2` 为准，V1 receipt 只作兼容读取。工作流技能按意图 **invoke**（按需读取，非整库预载）。
 用户侧文档 review 聚合见 skill `audit-user-manual`。  
 规范侧：`PromptLongGateListDriftProbe`（V75）。
 
 
@@ -4,6 +4,8 @@
 > **当前**: v1.15.3 已归档到 `changelogs/releases/v1.15.3.md`；本文件仅保留历史锚点索引与镜像供 validate 探针消费。发版后新实现再写入下方「当前未发布」。
 
 ## 当前未发布实现候选
+- **工作区 Skill 意图结构化与渐进路由**：83 个 active Skill 增加 `SkillIntentV1`；运行时构建 W + managed G 动态快照，经单一 `skill_route` MCP Tool 执行 catalog/commit/load_stage/status、0/1 自由选择、依赖闭包、冲突与预算校验、分阶段正文加载、条件重规划、幂等重放、上下文截断恢复和有锁 GC。仅有新鲜能力证据的 exact `grok-cli-single/global-launcher-local-stdio` 可进入 unified；其他宿主 fail-closed 到 legacy。MCP 为宿主按需启动的本地 stdio 子进程，无端口、HTTP、远程服务或常驻 daemon。W 在每轮动态发现；用户原生 `AGENTS.md` / `CLAUDE.md` / `SKILL.md` 与个人 Skill 保持宿主所有权，同名不构成清理或覆盖权限。完整 full `86/86`、profile-deploy、package-release 与真实 tarball global-install 均通过。
+- **公共 README 校验迁移**：以严格 `PublicReadmeContractV1` 替代要求公共 README 罗列内部 Gate/Skill/控制面术语的历史断言；README/client/release/workflow/brand/turn/execution consumers 共用该边界，并用损坏核心安装路径的负向探针防止宽松绕过。
 - **全局验证 skill `skill-load-verify`**：触发「验证技能 / skill load verify」；用户可见仅固定句 `SKILL-LOAD-VERIFY-OK`；Skill 规模 85→**86**（83 active + 3 gray）。
 - **取消用户可见 SkillLoadReceipt 元行**：不再强制/注入 `【DevCodex 技能】…`；加载可见性靠宿主过程时间线 + `skill-load-verify`；Stop 仅 enforce 命中 skill 的 must-reply/body。
 - **技能过程文案**：inject 引导过程侧写「正在加载 <id> 技能」，避免「命中 … 正在读取并按该技能执行」。
@@ -13,7 +15,7 @@
 - **README 用户向重写**：安装、验证 skill、语言诚实、宿主 Partial、仓库边界；去掉 Gate 百科式长清单。
 - **控制面 ImplementStartGate 防过程跳过**：`classifyImplementStartGate` 对控制面 mutation **禁止 unbound 放行**（`implement-start-without-task-binding`）；绑定任务后除 04/05/复审清单外还须 **00/01 + 02 技术方案**（`implement-start-without-design`）；lifecycle PreTool 无任务也 enforce。探针 `test-implement-start-gate.js`。需求：`VSCode全局MCP与五宿主同刷`（过程事故：承诺按流程却直接改码）。
 - **VS Code 全局 MCP 与五宿主同刷**：`global-adapters apply` / 全局安装在 Copilot host 事务中合并写入用户级 `Code/User/mcp.json`（及已存在的 Code - Insiders）的 `servers.devcodex-memory|profile`（stdio→copilot runtime mcp），保留既有 `inputs`/其它 server；测试与边界见 `global-host-target.resolveVscodeUserMcpPaths`。
-- **SkillsDeployModeV1（隐蔽运行时 + PR-1 防假绿）**：默认 `skillsDeployMode=hidden` 将 active skills 部署到 `~/.agents/devcodex/skills`（G_RUNTIME），停写/目录 prune `~/.agents/skills`、`~/.claude/skills`、`~/.copilot/skills` 中的包 managed id；`resolveGlobalSkillsRoot` 随 mode 切换（ENV `DEVCODEX_GLOBAL_SKILLS_ROOT` 仍最高优先）；`global-adapters apply --mode=hidden|legacy` 与 npm lifecycle 透传；receipt 记录 mode。强化 `pr1EvidenceOk`：有 `02` 须独立实质 `03` 复审（长度+blocker=0+实质章节），拒绝 thin open-blocker / sessions-only；改写 stop-gate 负向探针。需求：`全局Skill与插件隐蔽运行时`。
+- **SkillsDeployModeV1（隐蔽运行时 + PR-1 防假绿）**：默认 `skillsDeployMode=hidden` 将 active skills 部署到 `~/.agents/devcodex/skills`（G_RUNTIME），不再写入、扫描、按 ID prune 或覆盖 `~/.agents/skills`、`~/.claude/skills`、`~/.copilot/skills` 等宿主原生根；仅有 committed receipt/marker/digest 完整 ownership proof 的旧受管路径可进入显式清理预览。`resolveGlobalSkillsRoot` 随 mode 切换（ENV `DEVCODEX_GLOBAL_SKILLS_ROOT` 仍最高优先）；`global-adapters apply --mode=hidden|legacy` 与 npm lifecycle 透传；receipt 记录 mode。强化 `pr1EvidenceOk`：有 `02` 须独立实质 `03` 复审（长度+blocker=0+实质章节），拒绝 thin open-blocker / sessions-only；改写 stop-gate 负向探针。需求：`全局Skill与插件隐蔽运行时`。
 - **Runtime 白名单闭包防复发**：新增 `scripts/lib/runtime-dependency-closure.js` 作为统一 runtime require 闭包 Owner；`MCP_RUNTIME_DEPS` / `PROJECT_RUNTIME_SCRIPT_DEPS`（兼容 `CLAUDE_MCP_RUNTIME_SCRIPT_DEPS`）改为派生；Codex project hook 复制到 `.codex/scripts/lib`；`test:mcp-runtime-closure` 覆盖 allowlist-only layout/MCP smoke/负向/packlist；validation 节点 `mcp-runtime-closure` 接入 fast/full/profile-deploy/package-release。需求：`bugs/runtime白名单闭包防复发修复`。
 - **P0-1 工作区意图 + DEVCODEX.md + ImplementStartGate + e2e（Batch1）**：入口 `.devcodex/workspace/DEVCODEX.md`；`workspace-skill-intent` catalog/意图/lifecycle；控制面 mutation 前 04+05+复审清单门闩（`IMPLEMENT_START_WITHOUT_PROCESS`）；全局 skill `workspace-skill-author`；`npm run test:workspace-skill-intent` / `test:workspace-skill-intent-e2e`（E2E-A～J+K）并入 `test:skill-resolve`。**无 e2e 不算 Batch1 完成**。需求：`开源发布前用户面与文档边界收口`。
 - **P0-1 Batch2**：`init`/`ensureRuntimeDirs` 写入 DEVCODEX.md 模板（不覆盖）；CLI `devcodex skill intent <prompt> [--json]`；help 文案同步。
 
@@ -0,0 +1,200 @@
+'use strict'
+
+const crypto = require('crypto')
+const path = require('path')
+const { createDerivedStateStore } = require('./derived-state-store.cjs')
+const { stableDigest, validateContextReadPlan } = require('./context-read-contract.cjs')
+
+const CONTEXT_PLAN_OBSERVATION_SCHEMA = 'ContextPlanObservationV1'
+const CONTEXT_PLAN_OBSERVATION_SLOT_COUNT = 128
+const CONTEXT_PLAN_OBSERVATION_MAX_BYTES = 256 * 1024
+const CONTEXT_PLAN_OBSERVATION_FUTURE_SKEW_MS = 5 * 60 * 1000
+const OBSERVATION_FIELDS = new Set([
+  'schemaVersion',
+  'contextEpochDigest',
+  'contextEpoch',
+  'project',
+  'activeRoot',
+  'observedAt',
+  'planId',
+  'planContentId',
+  'planDigest',
+  'plan'
+])
+
+function portableRoot(value) {
+  const text = String(value || '').trim()
+  return text ? path.resolve(text).replace(/\\/g, '/') : ''
+}
+
+function contextEpochDigest(contextEpoch) {
+  return crypto.createHash('sha256').update(String(contextEpoch || '').trim()).digest('hex')
+}
+
+function contextPlanObservationRelativePath(contextEpoch) {
+  const digest = contextEpochDigest(contextEpoch)
+  const slot = Number.parseInt(digest.slice(0, 8), 16) % CONTEXT_PLAN_OBSERVATION_SLOT_COUNT
+  return path.join(
+    '.runtime-state',
+    'context-plan-observations',
+    'v1',
+    `slot-${String(slot).padStart(3, '0')}.json`
+  )
+}
+
+function buildContextPlanObservation({ activeRoot, project, contextEpoch, plan, nowMs = Date.now() }) {
+  return {
+    schemaVersion: CONTEXT_PLAN_OBSERVATION_SCHEMA,
+    contextEpochDigest: contextEpochDigest(contextEpoch),
+    contextEpoch: String(contextEpoch || '').trim(),
+    project: String(project || '').trim(),
+    activeRoot: portableRoot(activeRoot),
+    observedAt: new Date(nowMs).toISOString(),
+    planId: String(plan?.planId || '').trim(),
+    planContentId: String(plan?.planContentId || '').trim(),
+    planDigest: stableDigest(plan),
+    plan
+  }
+}
+
+function validateContextPlanObservation(value, expected = {}) {
+  const errors = []
+  const observation = value && typeof value === 'object' && !Array.isArray(value) ? value : null
+  if (!observation) return { valid: false, errors: ['observation must be an object'], plan: null }
+
+  const unknown = Object.keys(observation).filter(field => !OBSERVATION_FIELDS.has(field))
+  if (unknown.length) errors.push(`unsupported observation fields: ${unknown.join(', ')}`)
+  if (observation.schemaVersion !== CONTEXT_PLAN_OBSERVATION_SCHEMA) errors.push('invalid observation schema')
+
+  const epoch = String(observation.contextEpoch || '').trim()
+  const project = String(observation.project || '').trim()
+  const activeRoot = portableRoot(observation.activeRoot)
+  if (!epoch || observation.contextEpochDigest !== contextEpochDigest(epoch)) errors.push('invalid context epoch identity')
+  if (!project || !activeRoot) errors.push('observation target is incomplete')
+
+  if (expected.contextEpoch && epoch !== String(expected.contextEpoch).trim()) errors.push('context epoch mismatch')
+  if (expected.project && project !== String(expected.project).trim()) errors.push('project mismatch')
+  if (expected.activeRoot && activeRoot !== portableRoot(expected.activeRoot)) errors.push('active root mismatch')
+
+  const observedAtMs = Date.parse(observation.observedAt)
+  const notBeforeMs = expected.notBefore ? Date.parse(expected.notBefore) : null
+  const nowMs = Number.isFinite(expected.nowMs) ? expected.nowMs : Date.now()
+  if (!Number.isFinite(observedAtMs)) errors.push('invalid observedAt')
+  if (Number.isFinite(notBeforeMs) && observedAtMs < notBeforeMs) errors.push('observation predates the matching tool attempt')
+  if (Number.isFinite(observedAtMs) && observedAtMs > nowMs + CONTEXT_PLAN_OBSERVATION_FUTURE_SKEW_MS) {
+    errors.push('observation timestamp is too far in the future')
+  }
+
+  const planValidation = validateContextReadPlan(observation.plan)
+  if (!planValidation.valid) errors.push(planValidation.error.message)
+  const plan = planValidation.valid ? observation.plan : null
+  if (plan) {
+    if (observation.planDigest !== stableDigest(plan)) errors.push('plan digest mismatch')
+    if (observation.planId !== plan.planId || observation.planContentId !== plan.planContentId) {
+      errors.push('plan identity mirror mismatch')
+    }
+    if (plan.identity.contextEpoch !== epoch ||
+        plan.identity.project !== project ||
+        portableRoot(plan.identity.activeRoot) !== activeRoot) {
+      errors.push('plan target does not match the observation envelope')
+    }
+  }
+
+  return { valid: errors.length === 0, errors, plan }
+}
+
+function observationStore(activeRoot, contextEpoch, maxWrites) {
+  return createDerivedStateStore({
+    root: activeRoot,
+    relativePath: contextPlanObservationRelativePath(contextEpoch),
+    maxBytes: CONTEXT_PLAN_OBSERVATION_MAX_BYTES,
+    lockWaitMs: 2000,
+    maxWrites
+  })
+}
+
+function persistContextPlanObservation(input) {
+  const observation = buildContextPlanObservation(input)
+  const validation = validateContextPlanObservation(observation, {
+    activeRoot: input.activeRoot,
+    project: input.project,
+    contextEpoch: input.contextEpoch,
+    nowMs: input.nowMs
+  })
+  if (!validation.valid) {
+    return {
+      status: 'invalid',
+      errorCode: 'CONTEXT_PLAN_OBSERVATION_INVALID',
+      errors: validation.errors
+    }
+  }
+
+  const store = observationStore(input.activeRoot, input.contextEpoch, 1)
+  const write = store.write(observation)
+  if (write.status !== 'persisted') return write
+
+  const read = store.read()
+  const readValidation = read.status === 'fresh'
+    ? validateContextPlanObservation(read.value, {
+        activeRoot: input.activeRoot,
+        project: input.project,
+        contextEpoch: input.contextEpoch,
+        nowMs: input.nowMs
+      })
+    : { valid: false, errors: [`observation read-back status is ${read.status}`] }
+  if (!readValidation.valid) {
+    return {
+      status: 'invalid',
+      errorCode: 'CONTEXT_PLAN_OBSERVATION_READBACK_INVALID',
+      errors: readValidation.errors,
+      filePath: store.filePath
+    }
+  }
+  return {
+    status: 'persisted',
+    filePath: store.filePath,
+    bytes: write.bytes,
+    planDigest: observation.planDigest
+  }
+}
+
+function readContextPlanObservation({ activeRoot, project, contextEpoch, notBefore, nowMs }) {
+  const store = observationStore(activeRoot, contextEpoch, 0)
+  const read = store.read()
+  if (read.status !== 'fresh') return { ...read, plan: null }
+  const validation = validateContextPlanObservation(read.value, {
+    activeRoot,
+    project,
+    contextEpoch,
+    notBefore,
+    nowMs
+  })
+  if (!validation.valid) {
+    return {
+      status: 'invalid',
+      errorCode: 'CONTEXT_PLAN_OBSERVATION_INVALID',
+      errors: validation.errors,
+      filePath: store.filePath,
+      plan: null
+    }
+  }
+  return {
+    status: 'fresh',
+    filePath: store.filePath,
+    bytes: read.bytes,
+    observation: read.value,
+    plan: validation.plan
+  }
+}
+
+module.exports = {
+  CONTEXT_PLAN_OBSERVATION_SCHEMA,
+  CONTEXT_PLAN_OBSERVATION_SLOT_COUNT,
+  CONTEXT_PLAN_OBSERVATION_MAX_BYTES,
+  buildContextPlanObservation,
+  contextEpochDigest,
+  contextPlanObservationRelativePath,
+  persistContextPlanObservation,
+  readContextPlanObservation,
+  validateContextPlanObservation
+}
@@ -75,7 +75,7 @@ const PLAN_V1_FIELDS = new Set([
 ])
 const PLAN_FIELDS = new Set([
   ...PLAN_V1_FIELDS,
-  'planContentId', 'identityInputs', 'executionOptimization', 'reusePolicy', 'stageTiming', 'cacheDecision'
+  'planContentId', 'contextBinding', 'identityInputs', 'executionOptimization', 'reusePolicy', 'stageTiming', 'cacheDecision'
 ])
 const SEED_FIELDS = new Set([
   'schemaVersion', 'contextEpoch', 'semantic', 'intent', 'targetHint', 'continuationHint',
@@ -423,6 +423,17 @@ function buildPlanIdentityInputs(plan) {
   }
 }
 
+function buildContextReadBinding(plan) {
+  return {
+    schemaVersion: 'ContextReadBindingV1',
+    contextEpoch: plan.identity.contextEpoch,
+    planId: plan.planId,
+    planContentId: plan.planContentId,
+    activeRoot: plan.identity.activeRoot,
+    project: plan.identity.project
+  }
+}
+
 function refreshPlannerResponseBytes(plan) {
   let observed = 0
   for (let attempt = 0; attempt < 4; attempt += 1) {
@@ -883,6 +894,17 @@ function buildContextReadPlan(input = {}, options = {}) {
       finalIntent,
       invocationNonce
     },
+    contextBinding: null,
+    exitCondition: blocked ? 'blocked' : (fullRead ? 'escalated-full' : 'relevant-complete'),
+    profile: {
+      selectedFiles: [...selectedFiles].sort(),
+      configLocalRequested: input.configLocalRequested === true
+    },
+    memory: {
+      requiredQueries: selectedSources.filter(source => source.kind === 'memory').map(source => source.selector).sort()
+    },
+    fullRead,
+    fullReadReason: fullRead ? automaticFullReason : null,
     baselineContext: baseline,
     actionEnvelope: deriveActionEnvelope(finalIntent, changeTypes, seed.riskHint),
     changeTypes,
@@ -915,16 +937,6 @@ function buildContextReadPlan(input = {}, options = {}) {
     },
     escalationTriggers: uniqueSorted(CONTEXT_READ_CONTRACT.escalationTriggers),
     triggeredEscalations: [...triggerSet].sort(),
-    exitCondition: blocked ? 'blocked' : (fullRead ? 'escalated-full' : 'relevant-complete'),
-    profile: {
-      selectedFiles: [...selectedFiles].sort(),
-      configLocalRequested: input.configLocalRequested === true
-    },
-    memory: {
-      requiredQueries: selectedSources.filter(source => source.kind === 'memory').map(source => source.selector).sort()
-    },
-    fullRead,
-    fullReadReason: fullRead ? automaticFullReason : null,
     planningTelemetry: {
       bytes: planningMeasure.bytes,
       chars: planningMeasure.chars,
@@ -952,6 +964,7 @@ function buildContextReadPlan(input = {}, options = {}) {
     contextEpoch: seed.contextEpoch,
     invocationNonce
   }).slice(0, 24)}`
+  plan.contextBinding = buildContextReadBinding(plan)
   refreshPlannerResponseBytes(plan)
   const validation = validateContextReadPlan(plan)
   return validation.valid ? plan : validation.error
@@ -1109,6 +1122,9 @@ function validateContextReadPlan(raw) {
         invocationNonce: identity.invocationNonce
       }).slice(0, 24)}`
       if (raw.planId !== expectedPlanId) errors.push('planId invocation digest mismatch')
+      if (stableDigest(raw.contextBinding) !== stableDigest(buildContextReadBinding(raw))) {
+        errors.push('contextBinding is not derived from plan identity')
+      }
     } catch (error) {
       errors.push(`identityInputs validation failed: ${error.message}`)
     }