@c4a/context-cli 0.6.7 → 0.6.9

package/docs/quickstart.md

@@ -1,103 +1,90 @@
-# CLI Quickstart
+# Start Context through an Agent
 
-This file is shipped with the installed CLI at `dist/docs/quickstart.md`.
-It is for users who have installed the `context` executable and need the next
-step before an agent plugin or project workspace is ready.
+[简体中文](./quickstart.zh-CN.md)
 
-## 1. Install Agent Plugin Entry Points
+This file ships with the installed runtime. Context is designed to be used from
+its Agent entry: the user states a knowledge goal, and the Agent follows the
+current workflow Route. The low-level CLI exists to execute that workflow; it
+is not the first interface users need to learn.
 
-Install the bundled agent plugin first:
+## 1. Install the Agent integration
 
 ```bash
+npm install -g @c4a/context-cli@latest
 context plugin install
 ```
 
-The plugin adds the user-facing agent entries for workspace initialization and
-continuation. Exact command names depend on the host agent, but the intended
-flow is:
+Restart or refresh the Agent host so it discovers the installed entry.
 
-- initialize a Context workspace through the plugin entry when available;
-- continue work through the plugin entry after a workspace exists;
-- let the agent follow `context status`, CLI diagnostics, and human gates.
+## 2. Invoke the single entry
 
-If the host agent has not loaded the plugin yet, restart or refresh that agent
-after installation.
+Use `/c4a:context` for both new and existing workspaces. Describe the source
+material, intended audience, and desired output in normal language:
 
-## 2. Create a Project Workspace
-
-Create a standalone workspace:
-
-```bash
-context init context
+```text
+/c4a:context Build a traceable Agent knowledge package from the Markdown in
+docs/ and the exported APIs in packages/example. Ask me before approving the
+knowledge structure.
 ```
 
-Choose the generated workspace and starter-template language explicitly when
-needed; the CLI does not infer it from terminal locale or conversation text:
+The entry first runs the read-only `context entry --format json` resolver. It
+will either:
 
-```bash
-context init context --language zh-CN
-```
+- propose initialization at a concrete project path;
+- relocate into an existing Context workspace; or
+- return the current `workflow.current` Route.
 
-Then enter it and install dependencies:
+Initialization writes a new workspace and therefore remains explicit. Entering
+or evaluating an existing workspace is read-only and does not need a second
+confirmation.
 
-```bash
-cd context
-bun install
-```
-
-After initialization, read the workspace guidance:
+## 3. Follow the conversation
 
-```text
-AGENTS.md
-```
+The Agent will guide the knowledge production round through source permission,
+capture or code extraction, structure design, candidate compilation, review,
+close, verification, and package output. At each step it should explain:
 
-`AGENTS.md` explains the current project, SDK references, installed Agent
-entry, and safe workflow contract. It is the project-local starting point after
-`context init`.
+- what has already been established from workspace facts;
+- what decision is needed now and what that decision changes;
+- which evidence or report supports the decision;
+- what will happen after confirmation.
 
-## 3. Work Through an Agent
+The Agent reads Route-selected resources and executes exact Route-selected
+commands. Users should not need to translate placeholders such as `<phase-id>`
+or `<collection>` into internal CLI arguments.
 
-Inside the workspace, ask the installed agent plugin to continue the workflow.
-The agent should:
+## 4. Choose a conversation mode
 
-1. read `AGENTS.md`;
-2. run `context status --format json`;
-3. treat `workflow.current` as the current-step authority, read each
-   `resources.required` item, and execute only the returned command or
-   configuration action;
-4. at a Gate, load an `inspection_action` Skill or Schema only for
-   pre-decision inspection and a `resolution_action` Skill or Schema only
-   after confirmation;
-5. stop at human gates such as source scope, structure confirmation, review,
-   and package decisions.
+Ordinary mode is the default. It exposes review decisions and HTML inspection
+reports so the user can adjust intermediate content.
 
-The CLI performs mechanical work such as source registration, capture,
-validation, review application, verify, close, and build. The agent performs
-semantic judgment only when the workflow asks for it.
+Fully managed mode must be explicitly authorized in the current conversation.
+It lets the Agent collapse deterministic work and delegated review surfaces,
+while preserving permissions, evidence checks, validation, and verification.
+The Agent still stops whenever it needs semantic reading, project
+configuration, external authority, or diagnostic repair.
 
-When the user explicitly requests fully managed operation, the Agent starts with
-`context run --managed --until blocked-or-complete --format json` to collapse
-consecutive deterministic routes. The CLI re-evaluates every revision and
-stops before semantic reads, configuration, missing authority, diagnostics, or
-multiple commands.
+## 5. Understand the workspace
 
-## 4. Manual Orientation
+After initialization, the project-local `AGENTS.md` is the entry contract for
+the Agent. `src/index.ts` declares the project; `sources/` keeps captured
+evidence; `knowledge/` keeps approved knowledge; `dist/` contains reproducible
+outputs; `.tmp/context-runtime/` contains disposable runtime state.
 
-When operating without an agent plugin, start with:
+Do not edit CLI-owned lifecycle files to force progress. If work is blocked,
+the current Route or diagnostic provides the canonical recovery action.
 
-```bash
-context status
-```
+## Maintainer orientation
 
-If the command reports that no workspace exists, run `context init` first. If a
-workspace exists, prefer the next action reported by `context status` instead of
-guessing lower-level phase commands.
+If an Agent integration is unavailable, `context status --format json` exposes
+the same current Route for manual inspection. Use `context <command> --help`
+for exact flags, and prefer commands returned by `workflow.current` over
+examples copied from documentation.
 
-Project-local SDK documentation is installed under:
+The SDK reference installed in a workspace starts at:
 
 ```text
 node_modules/@c4a/context/docs/README.md
 ```
 
-Use those SDK docs when editing `src/index.ts` or package templates. For normal
-workflow operation, prefer the agent plugin and the workspace `AGENTS.md`.
+Use it when a Route asks for project configuration or package-template work.

package/docs/quickstart.zh-CN.md

@@ -0,0 +1,79 @@
+# 通过 Agent 开始使用 Context
+
+[English](./quickstart.md)
+
+本文件随安装后的运行时一起发布。Context 的设计入口是 Agent：用户说明知识目标，
+Agent 跟随当前工作流 Route。底层 CLI 用于执行这套工作流，不是普通用户首先需要
+学习的界面。
+
+## 1. 安装 Agent 接入
+
+```bash
+npm install -g @c4a/context-cli@latest
+context plugin install
+```
+
+重启或刷新 Agent 宿主，使其发现新安装的入口。
+
+## 2. 调用唯一入口
+
+无论创建新工作区还是继续已有工作区，都使用 `/c4a:context`。直接用自然语言说明
+来源资料、目标读者和期望产物：
+
+```text
+/c4a:context 请把 docs/ 下的 Markdown 和 packages/example 的导出 API 整理成
+可追溯的 Agent 知识包，知识结构批准前先让我确认。
+```
+
+入口首先运行只读的 `context entry --format json` 解析器，并返回以下一种结果：
+
+- 提议在明确的项目路径初始化；
+- 进入已经存在的 Context 工作区；
+- 返回当前 `workflow.current` Route。
+
+初始化会写入新工作区，因此必须保持显式。进入或求值已有工作区是只读动作，不需要
+第二次确认。
+
+## 3. 跟随对话完成知识生产
+
+Agent 会引导本轮流程完成来源权限、采集或代码提取、结构设计、候选编译、审核、
+close、验证和知识包产出。每个步骤都应该说明：
+
+- 工作区事实已经确认了什么；
+- 现在需要做什么决定，以及该决定影响什么；
+- 哪些证据或报告支持这个决定；
+- 确认后会发生什么。
+
+Agent 读取 Route 选择的资源，并执行 Route 返回的精确命令。用户不需要把
+`<phase-id>`、`<collection>` 等占位符翻译成内部 CLI 参数。
+
+## 4. 选择对话模式
+
+普通模式是默认模式，会展示审核决定和 HTML 检查报告，方便用户调整中间内容。
+
+全托管模式必须由用户在当前对话中明确授权。它允许 Agent 合并确定性工作并跳过
+可 delegated 的审核界面，但仍保留权限、证据检查、校验和验证。遇到语义阅读、
+项目配置、外部权限或诊断修复时，Agent 仍会停止。
+
+## 5. 理解工作区
+
+初始化后，项目内 `AGENTS.md` 是 Agent 的入口契约。`src/index.ts` 声明项目，
+`sources/` 保存采集证据，`knowledge/` 保存正式知识，`dist/` 保存可重复构建的
+产物，`.tmp/context-runtime/` 保存可丢弃运行状态。
+
+不要通过编辑 CLI-owned 生命周期文件强行推进流程。遇到阻塞时，当前 Route 或诊断
+会给出权威恢复动作。
+
+## 维护者参考
+
+如果 Agent 接入不可用，可以用 `context status --format json` 手工查看同一条当前
+Route。精确参数以 `context <command> --help` 为准，并优先执行
+`workflow.current` 返回的命令，而不是复制文档示例。
+
+工作区安装后的 SDK 参考入口是：
+
+```text
+node_modules/@c4a/context/docs/README.md
+```
+
+当 Route 要求配置项目或修改知识包模板时再读取对应手册。

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@c4a/context-cli",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "type": "module",
-  "description": "Local CLI for capturing, compiling, and governing knowledge workspaces",
+  "description": "Local runtime and Agent integration for traceable knowledge production",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,8 +23,8 @@
     "context": "cli.js"
   },
   "dependencies": {
-    "@c4a/agent-graph": "0.2.5",
-    "@c4a/context": "0.6.7",
+    "@c4a/agent-graph": "0.2.6",
+    "@c4a/context": "0.6.9",
     "commander": "^11.0.0",
     "fast-xml-parser": "^5.10.1",
     "handlebars": "^4.7.8",

package/plugins/.agents/plugins/marketplace.json

@@ -5,7 +5,7 @@
   },
   "plugins": [
     {
-      "name": "context",
+      "name": "c4a",
       "source": {
         "source": "local",
         "path": "./codex"

package/plugins/.claude-plugin/marketplace.json

@@ -5,9 +5,9 @@
   },
   "plugins": [
     {
-      "name": "context",
+      "name": "c4a",
       "source": "./claude",
-      "description": "Local knowledge workspace. Initialize a project and use next-step guidance to maintain it."
+      "description": "Start or continue a local knowledge workspace through one graph-routed entry."
     }
   ]
 }

package/plugins/.cursor-plugin/marketplace.json

@@ -9,9 +9,9 @@
   },
   "plugins": [
     {
-      "name": "context",
+      "name": "c4a",
       "source": "./cursor",
-      "description": "Maintain a project-local knowledge workspace through init and continue-step guidance."
+      "description": "Start or continue a project-local knowledge workspace through one graph-routed entry."
     }
   ]
 }

package/plugins/README.md

@@ -1,100 +1,113 @@
-# Context Plugin
+# Context Agent Integration
 
-> [中文版本](./README_CN.md)
+[简体中文](./README_CN.md)
 
-<p align="center"><img src="./assets/logo.svg" alt="C4A Context" width="180"/></p>
+<p align="center"><img src="./assets/logo.svg" alt="Context" width="180"/></p>
 
-Context provides a thin Agent entry for project-local knowledge workspaces. The
-plugin does not embed the whole workflow in one prompt. It starts from current
-workspace facts, then Context CLI selects the legal route, commands, gates, and
-Markdown/schema resources for that step.
+This plugin is the conversational entry to the Context knowledge production
+workflow. It lets users describe a knowledge goal to an Agent, then connects
+that conversation to the local Context runtime, current workspace facts, and
+Route-selected procedures.
+
+The plugin deliberately exposes one thin public entry instead of separate
+commands for initialization, source capture, review, and build. The detailed
+workflow stays in the runtime's Provider bundle, where it can be selected by
+current facts, validated, tested, and updated without turning the entry into a
+large prompt.
+
+## User experience
+
+After the integration is installed and the Agent host is refreshed, invoke the
+Context entry and describe the desired knowledge:
+
+```text
+/c4a:context Build a searchable Agent knowledge package from our architecture
+documents and this repository. Preserve source evidence and show me the final
+structure before approval.
+```
+
+The same entry can initialize a requested workspace, locate an existing one,
+or continue its current production round. The Agent explains user decisions in
+the conversation and uses the runtime for mechanical state transitions. Users
+do not need to select low-level lifecycle commands themselves.
 
 ## Install
 
+The plugin is bundled with the Context runtime:
+
 ```bash
-npm i -g @c4a/context-cli
+npm install -g @c4a/context-cli@latest
 context plugin install
 ```
 
-For a source checkout, build the CLI and plugin first:
+For a source checkout, build first and install the development projection:
 
 ```bash
 bun run --filter @c4a/context-cli build
 context plugin install --dev
 ```
 
-Use `context plugin install --dry-run` to inspect installation and
-`context plugin path` to locate the bundled marketplace.
+Use `context plugin install --dry-run` to inspect the host projections and
+`context plugin status` to diagnose an installation. Refresh the Agent host
+after changing or reinstalling the plugin.
 
-## Agent entry
+## Entry contract
 
-The public host surface stays small:
+The maintained source is [`commands/context.md`](./commands/context.md). Its
+bootstrap flow is:
 
-- `init` creates a Context workspace;
-- `continue` observes and advances an existing workspace.
+1. run the read-only `context entry --language <language> --format json`;
+2. execute only its returned `next_action.command`;
+3. after workspace setup, treat `workflow.current` as the current-step
+   authority;
+4. read every required Route resource completely;
+5. execute only the selected action or configuration change;
+6. evaluate the workspace again.
 
-Continuation starts with:
+The entry does not infer workspace state from surrounding files. Initialization
+is executed only when explicitly requested or confirmed; entering and
+evaluating an existing workspace is read-only. There is no `context continue`
+primitive and no stage-specific public Skill.
 
-```bash
-context status --format json
-```
+## Progressive workflow context
 
-`workflow.current` is the current-step authority. The Agent reads every required
-resource marked `read_state: read-required`, executes only returned commands,
-preserves revision and authority flags, and reevaluates status after each
-action. Current-conversation read receipts may be passed back through
-`context status --resource-receipts @<file>` so unchanged resources are marked
-`current`. A dynamic materialization becomes a receipt only after the Agent
-reads the complete returned file. `context.source-body/*` resources are source
-text; source indexes and heading metadata never replace the body. Long procedures and semantic
-judgment rules are published in the Context workflow bundle and loaded only
-when the current route or operation selects them.
+Procedures, dialogue, diagnostics, schemas, source bodies, and generated views
+are addressable workflow resources. Static resources use content digests;
+dynamic views are tied to the workflow revision that selected them. Read
+receipts can keep unchanged resources current within one conversation, but a
+receipt never proves that an external action completed.
 
-Gate inspection and resolution Actions keep their own Skill and Schema
-locators. The Agent loads those conditional resources only when it enters that
-phase; they are not preloaded with the Route's ordinary required resources.
+At a human Gate, inspection and resolution resources remain phase-local. The
+Agent loads inspection material before a decision and resolution material only
+after confirmation. This keeps the ordinary review path available without
+preloading every possible decision surface.
 
-The two entry documents are also the source for hosts that expose Agent Skills
-instead of commands. There are no stage-specific skills: source, alignment,
-compile, review, and package guidance comes from the route-selected workflow
-resources.
+## Fully managed conversations
 
-## Human gates and managed sessions
-
-Ordinary mode preserves source, read-permission, scope, structure, Review, and
-package decisions as explicit gates. Fully managed mode is available only when
-the user explicitly requests it in the current conversation:
-
-```bash
-context status --managed --format json
-```
-
-That session authority is not stored. It cannot choose source boundaries,
-authorize unread external content, perform external repository operations, or
-bypass validation and verification.
-
-After the initial managed status, consecutive deterministic routes can be
-collapsed with:
+Fully managed operation is used only after the user explicitly authorizes it in
+the current conversation. The Agent then starts with:
 
 ```bash
 context run --managed --until blocked-or-complete --format json
 ```
 
-The loop stops before any route that needs Agent interpretation, configuration,
-additional authority, or diagnostic repair, and returns the current workflow
-route for normal progressive loading.
-
-## Workspace and SDK
+The loop executes consecutive deterministic actions and Route-delegated Gates,
+re-evaluating after every action. It stops before semantic reading, project
+configuration, unresolved permission, diagnostic repair, or a non-unique plan.
+Managed authority is never persisted or reused in another conversation.
 
-Run the plugin from the initialized Context project root. Project declarations
-live in `src/index.ts`; source state, draft state, approved knowledge, generated
-packages, and disposable runtime state remain owned by Context CLI.
+## Boundaries
 
-After workspace dependency installation, the SDK manual starts at:
+- The plugin does not call an LLM; it is consumed by the host Agent.
+- All workspace lifecycle writes go through Route-selected Context actions.
+- It does not silently clone, fetch, checkout, install, build, test, or read
+  external content without the required authority.
+- It does not duplicate workflow facts or lifecycle routing in the prompt.
+- It keeps CLI tokens, paths, ids, flags, and `source_ref` values unchanged,
+  while explaining decisions in the user's current conversation language.
 
-```text
-node_modules/@c4a/context/docs/README.md
-```
+## Maintainer note
 
-The plugin does not expose source deletion, purge, or retraction. It also does
-not silently clone, fetch, checkout, install, build, test, or call an LLM.
+`plugin/` is the only hand-maintained integration source. The build projects it
+to Claude commands, Codex Skills, Cursor commands, and a Skill-only layout under
+`dist/plugins`. Do not edit generated projections directly.

package/plugins/README_CN.md

@@ -1,91 +1,96 @@
-# Context Plugin
+# Context Agent 接入
 
-> [English version](./README.md)
+[English](./README.md)
 
-<p align="center"><img src="./assets/logo.svg" alt="C4A Context" width="180"/></p>
+<p align="center"><img src="./assets/logo.svg" alt="Context" width="180"/></p>
 
-Context 为项目内知识工作区提供轻量 Agent 入口。Plugin 不会把完整工作流塞进
-一份提示词，而是先观察当前工作区事实，再由 Context CLI 选择当前步骤允许的
-路线、命令、门禁以及 Markdown/schema 资源。
+这个插件是 Context 知识生产工作流的对话入口。用户向 Agent 说明知识目标，插件再
+把对话连接到本地 Context 运行时、当前工作区事实和 Route 选择的操作资源。
+
+插件有意只暴露一个精简入口，不为初始化、来源采集、审核和构建分别提供公开命令。
+详细工作流保存在运行时的 Provider bundle 中，可以依据当前事实按需选择、校验、
+测试和升级，而不会让入口 Prompt 越来越长。
+
+## 用户体验
+
+安装接入并刷新 Agent 宿主后，调用 Context 入口并说明期望知识：
+
+```text
+/c4a:context 请把架构文档和当前仓库整理成可搜索的 Agent 知识包，保留来源证据，
+最终结构批准前先让我确认。
+```
+
+同一个入口可以初始化用户请求的工作区、定位已有工作区，或继续当前知识生产轮次。
+Agent 在对话中解释用户决策，并使用运行时完成机械状态变更；用户不需要自行选择
+底层生命周期命令。
 
 ## 安装
 
+插件随 Context 运行时一起发布：
+
 ```bash
-npm i -g @c4a/context-cli
+npm install -g @c4a/context-cli@latest
 context plugin install
 ```
 
-源码开发模式需要先构建：
+从源码开发时，先构建再安装开发投影：
 
 ```bash
 bun run --filter @c4a/context-cli build
 context plugin install --dev
 ```
 
-可用 `context plugin install --dry-run` 查看安装动作，用
-`context plugin path` 定位随 CLI 发布的 marketplace。
+`context plugin install --dry-run` 可以预览宿主投影，`context plugin status`
+用于诊断安装。修改或重装插件后需要刷新 Agent 宿主。
 
-## Agent 入口
+## 入口契约
 
-公开入口保持精简：
+人工维护的源文件是 [`commands/context.md`](./commands/context.md)，启动流程为：
 
-- `init`：创建 Context 工作区；
-- `continue`：观察并推进已有工作区。
+1. 运行只读的 `context entry --language <language> --format json`；
+2. 只执行它返回的 `next_action.command`；
+3. 工作区就绪后，将 `workflow.current` 视为当前步骤权威；
+4. 完整读取当前 Route 的所有必需资源；
+5. 只执行选中的动作或配置修改；
+6. 再次求值工作区。
 
-Continuation 从以下命令开始：
+入口不会根据周边文件自行推断工作区状态。只有用户明确请求或确认时才执行初始化；
+进入或求值已有工作区是只读行为。不存在 `context continue` primitive，也没有阶段
+专属的公开 Skill。
 
-```bash
-context status --format json
-```
+## 按需加载工作流上下文
 
-`workflow.current` 是当前步骤的权威协议。Agent 读取所有标记为
-`read_state: read-required` 的 required 资源，只执行返回的命令，完整保留
-revision 与 authority 参数，并在每次动作后重新求值。当前会话可通过
-`context status --resource-receipts @<file>` 回传读取回执，使未变化资源标记为
-`current`。动态资源的 materialize 结果只有在 Agent 完整读取返回文件后才可作为
-回执；`context.source-body/*` 是必须阅读的正文，source-index 和标题元数据不能
-替代正文。
-长篇流程与语义判断规则发布在 Context workflow bundle 中，仅在当前路线或操作
-选中时加载。
+操作说明、对话、诊断、Schema、来源正文和生成 View 都是可寻址的工作流资源。
+静态资源使用内容 digest，动态 View 绑定选择它的 workflow revision。读取回执可以
+在同一对话中复用未变化资源，但不能证明外部动作已经完成。
 
-Gate 的检查动作与决议动作分别保留自己的 Skill 和 Schema 位置。Agent 只在进入
-相应阶段时加载这些条件资源，不会把它们提前混入 Route 的普通 required 资源。
+人工 Gate 的检查和决议资源保持阶段隔离：Agent 在决定前加载 inspection 内容，
+用户确认后才加载 resolution 内容。这样既保留普通审核能力，也不会预加载所有可能
+的决策界面。
 
-这两个入口文档也用于生成仅支持 Agent Skills 的宿主入口。不再发布阶段型
-Skill；来源、对齐、编译、审核和构建说明均由当前路线选择的 workflow resources
-动态提供。
+## 全托管对话
 
-## 人工门禁与全托管会话
-
-普通模式保留来源、读取权限、提取范围、结构、审阅和包形态等显式门禁。只有用户
-在当前对话明确要求全托管时，才使用：
-
-```bash
-context status --managed --format json
-```
-
-该会话权限不会持久化，也不能选择来源边界、授权尚未允许读取的外部内容、执行
-外部仓库操作，或绕过校验与验证。
-
-首次读取托管状态后，可用下面的命令合并连续的确定性步骤：
+只有用户在当前对话明确授权后，才使用全托管模式。Agent 从以下命令开始：
 
 ```bash
 context run --managed --until blocked-or-complete --format json
 ```
 
-遇到需要 Agent 判断、配置修改、额外权限、诊断修复或多条命令的路线时，循环会
-立即停止，并返回当前 `workflow.current` 供 Agent 按需加载上下文。
-
-## 工作区与 SDK
+循环会执行连续的确定性动作和 Route-delegated Gate，并在每个动作后重新求值。遇到
+语义阅读、项目配置、未解决权限、诊断修复或非唯一计划时停止。全托管权限不会被
+持久化，也不能在另一场对话复用。
 
-Plugin 应在初始化后的 Context 项目根目录运行。`src/index.ts` 保存项目声明；
-来源状态、草稿状态、已批准知识、构建产物和临时运行状态均由 Context CLI 管理。
+## 边界
 
-安装工作区依赖后，SDK 手册入口为：
+- 插件本身不调用 LLM，而是由宿主 Agent 消费。
+- 所有工作区生命周期写入都通过 Route 选择的 Context Action 完成。
+- 不会在缺少相应授权时静默 clone、fetch、checkout、install、build、test 或
+  读取外部内容。
+- 不在 Prompt 中复制工作流事实或生命周期路由。
+- CLI token、路径、id、flag 和 `source_ref` 保持原样；面向用户的解释使用当前
+  对话语言。
 
-```text
-node_modules/@c4a/context/docs/README.md
-```
+## 维护说明
 
-当前 Plugin 不暴露 source 删除、purge 或 retraction，也不会静默执行 clone、
-fetch、checkout、install、build、test 或调用 LLM。
+`plugin/` 是唯一人工维护的接入源。构建会将它投影为 `dist/plugins` 下的 Claude
+commands、Codex Skills、Cursor commands 和纯 Skill 目录。不要直接编辑生成投影。

package/plugins/VERSION

@@ -1 +1 @@
-0.6.7
+0.6.9