campfire-cli 0.1.9__tar.gz → 0.1.10__tar.gz

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/ARCHITECTURE.md

@@ -118,7 +118,7 @@ Campfire 不是“Markdown 版 kubectl”，而是面向人机协作场景组合
 命令设计遵循以下约束：
 
 1. **对象域优先**：公共入口采用 `campfire <object-domain> <verb>`，例如 `document apply`、`maintenance check`；动词在所属业务对象内保持单义，不为同一行为保留多个别名。
-2. **意图原子、派生显式**：`document apply` 只创建或更新目标文档，`document move` 原子完成单文档移动、目标 Profile 对齐和确定性引用修复；命令只在 MOC、关系页或索引可能变化时返回一个最小 scope 的 `maintenance sync`。
+2. **意图原子、派生显式**：`document apply` 创建或更新文档，并在显式类型变化时将类型、文件名前缀和确定性引用作为同一变更提交；`document move` 原子完成单文档跨 Domain 移动、目标 Profile 对齐和确定性引用修复。命令只在 MOC、关系页或索引可能变化时返回零或一个可直接执行的最小 scope `maintenance sync`。
 3. **契约声明式，变更显式**：Profile 是字段、类型、枚举、顺序和条件必填的 SSOT。Agent 提交业务值，CLI 解析有效 Profile 并拒绝猜测；已有文档只修改明确给出的字段或正文操作。
 4. **写入先证明安全**：写命令默认预览，显式确认后才提交；提交时在锁内复核快照或期望哈希，多文件变更作为一个 ChangeSet 执行，失败回滚，避免静默覆盖和部分写入。
 5. **人类与 Agent 共用一个契约**：命令和结果只有一套语义。JSON 状态、issues、missing fields 与 follow-up 供 Agent 稳定消费，`tree` 和分层 `-h` 供人类与 Agent 渐进发现，不维护第二套参数目录。
@@ -128,7 +128,7 @@ Campfire 不是“Markdown 版 kubectl”，而是面向人机协作场景组合
 
 横切关注点与业务 SOP 不使用同一种复用手段。哈希复核、写锁、原子替换和失败恢复由显式 ChangeSet Executor 复用；写命令返回的 `follow_up` 由 Skill 消费。不为了复用 Maintenance 而引入 AOP 切面、命令总线、全局钩子或隐式中间件。
 
-因此，`document apply` 的准确含义是“对一个 Markdown 文档应用经 Profile 校验的显式意图”，不是“把完整声明持续调谐到某个服务端状态”。用户或 Agent 可以直接 edit 已有正文；无论通过 apply 还是 edit 写入，跨文档派生结果都由后续显式 Maintenance 收敛。
+因此，`document apply` 的准确含义是“对一个 Markdown 文档应用经 Profile 校验的显式意图”，不是“把完整声明持续调谐到某个服务端状态”。创建时文件名可省略类型前缀；显式变更类型时，CLI 负责同步类型、前缀和可确定引用。用户或 Agent 可以直接 edit 唯一路径下的已有正文；只有新建文档、修改 Frontmatter/类型/归属或需要派生治理时才进入 CLI 工作流。
 
 ## 5. SSOT 与派生数据
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/COMMAND.md

@@ -46,4 +46,4 @@ campfire maintenance archive apply [--scope <path>] --confirm
 
 Space、Domain、Project 的 `create`/`adopt`，以及文档移动、重构、归档写操作默认先预览；审查通过后才追加 `--confirm`。已注册 Workspace 只通过根级 `campfire --workspace <id> ...` 选择；已声明 Space、Domain 和 Project 使用稳定 ID，CLI 自行推导路径和父子关系。路径参数只用于新位置、具体文件、外部输入和显式扫描范围。
 
-`document apply` 可新建、更新或为已有正文补齐 Frontmatter；`document move` 可在任意已声明 Domain 之间移动单篇文档并对齐可确定的 `domain`/`project`。目标 Profile 缺少语义字段时返回 `missing_fields`，调用方用 `--set`/`--unset` 补齐。只有实际写入成功的结果才可返回一个实际需要的 scoped `maintenance sync` follow-up；预览、阻塞或无派生影响时返回空列表。具体参数以对应命令的 `-h` 为准。
+`document apply` 可新建、更新、为已有正文补齐 Frontmatter，或通过显式 `--type` 原子转换文档类型。创建和类型转换时，CLI 根据文档类型推导文件名前缀，并在结果的 `target` 中返回最终路径；调用方只提交标题或现有路径，不手工同步类型与前缀。`document move` 可在任意已声明 Domain 之间移动单篇文档并对齐可确定的 `domain`/`project`。目标 Profile 缺少语义字段时返回 `missing_fields`，调用方补齐明确业务值。只有实际写入成功的结果才可返回零或一个、且可直接执行的 scoped `maintenance sync` follow-up；Domain 内部路径会归一化为对应 Domain，预览、阻塞或无派生影响时返回空列表。具体参数以对应命令的 `-h` 为准。

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: campfire-cli
-Version: 0.1.9
+Version: 0.1.10
 Summary: Local-first shared context and governance CLI for humans and agents
 License-Expression: MIT
 License-File: LICENSE
@@ -94,7 +94,7 @@ campfire maintenance sync [--dry-run] [--scope]  # 刷新 MOC 与相关文档页
 campfire maintenance archive check / apply       # 归档候选检查与执行
 
 campfire document inspect / check / format       # 单篇文档查看、校验、格式化
-campfire document apply / move                   # 单篇文档创建更新、跨 Domain 移动
+campfire document apply / move                   # 创建更新、类型转换、跨 Domain 移动
 campfire document profile list / show / resolve  # Frontmatter Profile 规则
 campfire document type list                      # 文档类型与前缀
 
@@ -139,12 +139,12 @@ campfire workspace restructure verify --batch move-001
 - **校验分工**：`maintenance check` 统一负责正式文档的 Schema 与枚举校验，并刷新可重建索引；结构声明由 `workspace space/domain check` 校验；`maintenance sync` 只因结构、MOC、路径或并发安全问题阻塞，单篇文档问题不阻止其他领域刷新。
 - **Frontmatter Profile**：声明式一层继承（`base` 或 `base → knowledge/project-doc/task`），`document profile show` 展示编译后的完整规则；Formatter 只按有效 Profile 排序并保留值，不允许字段由 Validator 报告、不自动删除。
 - **并发与提交安全**：写入前在治理锁内复核内容哈希，外部变化返回 `concurrent-change` / `source-hash-changed`，拒绝覆盖；多文件写入和路径移动经同一 ChangeSet 提交，失败恢复到执行前。
-- **按需后续治理**：写入命令只在实际写入成功且派生内容可能变化时返回一个最小 scope 的 `maintenance sync`；预览和阻塞结果的 `follow_up` 为空。Skill 消费该结果，没有 follow-up 就结束，不固定追加 dry-run 或全量 check。
+- **按需后续治理**：写入命令只在实际写入成功且派生内容可能变化时返回零或一个、且可直接执行的最小 scope `maintenance sync`；预览和阻塞结果的 `follow_up` 为空。位于 Domain 内部的 scope 由 CLI 归一化为有效 Domain。Skill 消费该结果，没有 follow-up 就结束，不固定追加 dry-run 或全量 check。
 - **配置两层模型**：产品默认契约在包内 `resources/defaults/config.yml`（SSOT），用户只在 `~/.campfire/config.yml` 写覆盖项；Mapping 递归合并，`campfire workspace config check` 验证有效配置。
 
 ## Agent 协作
 
-全局 Skill（`campfire skill list` 查看托管清单，`campfire skill sync` 手动同步）定义了 Agent 的标准工作流：首次读写先 `workspace resolve` 并读取 Workspace 的 `AGENTS.md`；单文档用 `document apply/move`，批量结构调整用 `workspace restructure`，归档用 `maintenance archive`。有歧义的分类和重构进入 Decision，不由 Agent 擅自决定。
+全局 Skill（`campfire skill list` 查看托管清单，`campfire skill sync` 手动同步）定义了 Agent 的标准工作流：已给出唯一文件路径的正文读取或小改直接使用文件工具；新建文档、修改 Frontmatter/类型/归属或执行结构治理时才加载 bootstrap，并使用 `document apply/move` 等原子命令。批量结构调整用 `workspace restructure`，归档用 `maintenance archive`。有歧义的分类和重构进入 Decision，不由 Agent 擅自决定。
 
 ## 许可
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/README.md

@@ -78,7 +78,7 @@ campfire maintenance sync [--dry-run] [--scope]  # 刷新 MOC 与相关文档页
 campfire maintenance archive check / apply       # 归档候选检查与执行
 
 campfire document inspect / check / format       # 单篇文档查看、校验、格式化
-campfire document apply / move                   # 单篇文档创建更新、跨 Domain 移动
+campfire document apply / move                   # 创建更新、类型转换、跨 Domain 移动
 campfire document profile list / show / resolve  # Frontmatter Profile 规则
 campfire document type list                      # 文档类型与前缀
 
@@ -123,12 +123,12 @@ campfire workspace restructure verify --batch move-001
 - **校验分工**：`maintenance check` 统一负责正式文档的 Schema 与枚举校验，并刷新可重建索引；结构声明由 `workspace space/domain check` 校验；`maintenance sync` 只因结构、MOC、路径或并发安全问题阻塞，单篇文档问题不阻止其他领域刷新。
 - **Frontmatter Profile**：声明式一层继承（`base` 或 `base → knowledge/project-doc/task`），`document profile show` 展示编译后的完整规则；Formatter 只按有效 Profile 排序并保留值，不允许字段由 Validator 报告、不自动删除。
 - **并发与提交安全**：写入前在治理锁内复核内容哈希，外部变化返回 `concurrent-change` / `source-hash-changed`，拒绝覆盖；多文件写入和路径移动经同一 ChangeSet 提交，失败恢复到执行前。
-- **按需后续治理**：写入命令只在实际写入成功且派生内容可能变化时返回一个最小 scope 的 `maintenance sync`；预览和阻塞结果的 `follow_up` 为空。Skill 消费该结果，没有 follow-up 就结束，不固定追加 dry-run 或全量 check。
+- **按需后续治理**：写入命令只在实际写入成功且派生内容可能变化时返回零或一个、且可直接执行的最小 scope `maintenance sync`；预览和阻塞结果的 `follow_up` 为空。位于 Domain 内部的 scope 由 CLI 归一化为有效 Domain。Skill 消费该结果，没有 follow-up 就结束，不固定追加 dry-run 或全量 check。
 - **配置两层模型**：产品默认契约在包内 `resources/defaults/config.yml`（SSOT），用户只在 `~/.campfire/config.yml` 写覆盖项；Mapping 递归合并，`campfire workspace config check` 验证有效配置。
 
 ## Agent 协作
 
-全局 Skill（`campfire skill list` 查看托管清单，`campfire skill sync` 手动同步）定义了 Agent 的标准工作流：首次读写先 `workspace resolve` 并读取 Workspace 的 `AGENTS.md`；单文档用 `document apply/move`，批量结构调整用 `workspace restructure`，归档用 `maintenance archive`。有歧义的分类和重构进入 Decision，不由 Agent 擅自决定。
+全局 Skill（`campfire skill list` 查看托管清单，`campfire skill sync` 手动同步）定义了 Agent 的标准工作流：已给出唯一文件路径的正文读取或小改直接使用文件工具；新建文档、修改 Frontmatter/类型/归属或执行结构治理时才加载 bootstrap，并使用 `document apply/move` 等原子命令。批量结构调整用 `workspace restructure`，归档用 `maintenance archive`。有歧义的分类和重构进入 Decision，不由 Agent 擅自决定。
 
 ## 许可
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/SPEC.md

@@ -107,7 +107,7 @@ Campfire 使用语义化版本：
 
 - SQLite `spaces`、`domains`、`documents` 只允许作为可重建本机投影，不得反向覆盖 Markdown SSOT。
 - `setup` 与 `maintenance check` 必须自动刷新完整拓扑和文档索引。
-- 写命令只在实际写入成功且派生状态可能变化时返回一个 scoped `maintenance sync` follow-up；预览和阻塞结果必须返回空列表；
+- 写命令只在实际写入成功且派生状态可能变化时返回零或一个可直接执行的 scoped `maintenance sync` follow-up；Domain 内部路径必须归一化为对应 Domain，预览和阻塞结果必须返回空列表；
   调用方只执行实际返回的 follow-up，不固定追加 check 或全量扫描。
 - `workspace rebuild` 默认只预览；`--confirm` 后从 Manifest 和 Markdown 完整替换派生索引。
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "campfire-cli"
-version = "0.1.9"
+version = "0.1.10"
 description = "Local-first shared context and governance CLI for humans and agents"
 readme = "README.md"
 license = "MIT"

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/__init__.py

@@ -1,3 +1,3 @@
 """Campfire CLI package."""
 
-__version__ = "0.1.9"
+__version__ = "0.1.10"

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/document/cli/document_cli.py

@@ -102,7 +102,11 @@ def apply_document(
     expected_hash: str | None = typer.Option(None, "--expected-hash"),
     confirm: bool = typer.Option(False, "--confirm"),
 ) -> None:
-    """预览或应用一篇 Profile 合法文档的创建与补丁。"""
+    """预览或应用一篇 Profile 合法文档的创建、补丁与显式类型变更。
+
+    创建时文件名可省略类型前缀；CLI 根据 --type 返回并写入最终 target。
+    已有文档的 --type 发生变化时，同一原子操作同步文件名和引用。
+    """
     body = body_file.read_text(encoding="utf-8") if body_file else None
     invoke(
         lambda: service(ctx).apply(

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/document/schema/document_schema.py

@@ -21,11 +21,13 @@ class DocumentApplyRequest(BaseModel):
 class DocumentApplyResult(BaseModel):
     status: Literal["planned", "needs-input", "blocked", "applied"]
     workspace_id: str
-    action: Literal["create", "update"]
+    action: Literal["create", "update", "retype"]
     path: str
+    target: str
     profile: str
     expected_hash: str
     write_performed: bool = False
+    updated_references: list[str] = Field(default_factory=list)
     issues: list[dict[str, Any]] = Field(default_factory=list)
     missing_fields: list[str] = Field(default_factory=list)
     follow_up: list[CommandFollowUp] = Field(default_factory=list)

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/document/service/document_apply_service.py

@@ -12,11 +12,13 @@ from campfire_cli.app.document.schema import (
     DocumentApplyRequest,
     DocumentApplyResult,
 )
+from campfire_cli.app.document.service.document_relocation import prepare_document_relocation
 from campfire_cli.app.document.service.document_rule_service import DocumentRuleService
 from campfire_cli.app.document.service.frontmatter_formatter import render_patch
 from campfire_cli.app.document.service.profile_registry import ProfileRegistry
 from campfire_cli.common.documents.document_types import prefixed_name
 from campfire_cli.common.documents.domain_context import (
+    DomainContext,
     DomainContextError,
     resolve_domain_context,
 )
@@ -42,14 +44,16 @@ class DocumentApplyService:
         self._executor = FileChangeExecutor(settings.vault_root, settings.state_root)
 
     def apply(self, request: DocumentApplyRequest) -> DocumentApplyResult:
-        path = safe_path(self._settings.vault_root, request.path)
-        if path.suffix.lower() != ".md":
+        source = safe_path(self._settings.vault_root, request.path)
+        if source.suffix.lower() != ".md":
             raise ConfigurationError("document apply 目标必须是 Markdown 文件")
-        exists = path.is_file()
-        original = path.read_text(encoding="utf-8") if exists else ""
+        exists = source.is_file()
+        original = source.read_text(encoding="utf-8") if exists else ""
         parsed = parse_document(original)
 
         current_type = parsed.frontmatter.get("type")
+        if "type" in request.values:
+            raise GovernanceBlockedError("文档类型只能通过 --type 表达")
         document_type = request.document_type or (
             current_type if isinstance(current_type, str) else None
         )
@@ -57,24 +61,25 @@ class DocumentApplyService:
             raise ConfigurationError("创建文档时必须提供 --type")
         if document_type not in self._settings.document_types.get("types", {}):
             raise ConfigurationError(f"未知文档类型：{document_type}")
-        if (
-            exists
-            and parsed.has_frontmatter
-            and request.document_type
-            and current_type != request.document_type
-        ):
-            raise GovernanceBlockedError("不允许通过 document apply 改变已有文档的 type")
 
-        expected_name = prefixed_name(path.name, document_type, self._settings.document_types)
-        if expected_name != path.name:
-            raise ConfigurationError(f"文件名应为：{expected_name}")
-        if request.values.get("type", document_type) != document_type:
-            raise GovernanceBlockedError("--set type 与有效文档类型不一致；请使用专用重构命令")
+        changes_type = (
+            exists and request.document_type is not None and current_type != document_type
+        )
+        action = "create" if not exists else "retype" if changes_type else "update"
+        target = (
+            source.with_name(
+                prefixed_name(source.name, document_type, self._settings.document_types)
+            )
+            if not exists or changes_type
+            else source
+        )
+        target_name = target.relative_to(self._settings.vault_root).as_posix()
+        context = self._domain_context(target)
 
         today = date.today().isoformat()
         frontmatter = dict(parsed.frontmatter)
         if not exists or not parsed.has_frontmatter:
-            frontmatter.update(self._creation_defaults(path, document_type, today))
+            frontmatter.update(self._creation_defaults(target, context, document_type, today))
         for key in ("project", "domain"):
             if key in request.values and request.values[key] != frontmatter.get(key):
                 raise GovernanceBlockedError(
@@ -83,15 +88,15 @@ class DocumentApplyService:
         frontmatter.update(request.values)
         frontmatter["type"] = document_type
         frontmatter["updated"] = today
-        profile = self._profiles.resolve(document_type, frontmatter, path)
-        actual_hash = file_sha256(path) if exists else "missing"
+        profile = self._profiles.resolve(document_type, frontmatter, target)
+        actual_hash = file_sha256(source) if exists else "missing"
 
         unknown = sorted(set(request.values) - set(profile.allowed))
         if unknown:
             return self._result(
                 request,
-                exists,
-                parsed.has_frontmatter,
+                target_name,
+                action,
                 profile.name,
                 actual_hash,
                 "blocked",
@@ -107,17 +112,20 @@ class DocumentApplyService:
 
         next_body = self._next_body(request, parsed.body, exists)
         if exists and parsed.has_frontmatter:
+            patch = {**request.values, "updated": today}
+            if changes_type:
+                patch["type"] = document_type
             rendered, render_errors = render_patch(
                 original,
-                {**request.values, "updated": today},
+                patch,
                 next_body,
                 list(profile.field_order),
             )
             if render_errors:
                 return self._result(
                     request,
-                    exists,
-                    parsed.has_frontmatter,
+                    target_name,
+                    action,
                     profile.name,
                     actual_hash,
                     "blocked",
@@ -125,7 +133,9 @@ class DocumentApplyService:
                 )
         else:
             rendered = render_document(frontmatter, next_body, list(profile.field_order))
-        issues = self._rules.check_content(self._settings.vault_root, path, rendered)
+        issues = self._rules.check_content(self._settings.vault_root, target, rendered)
+        if target != source and target.exists():
+            issues.insert(0, {"code": "target-exists", "path": target_name})
         missing_codes = {"frontmatter-field-missing", "frontmatter-field-empty"}
         for issue in issues:
             field = issue.get("field")
@@ -143,8 +153,8 @@ class DocumentApplyService:
         status = "needs-input" if missing else "blocked" if issues else "planned"
         result = self._result(
             request,
-            exists,
-            parsed.has_frontmatter,
+            target_name,
+            action,
             profile.name,
             actual_hash,
             status,
@@ -161,22 +171,44 @@ class DocumentApplyService:
                 }
             )
 
-        self._executor.execute(
-            FileChangeSet(
-                writes=(FileWrite(path, rendered),),
+        updated_references: list[str] = []
+        if exists and target != source:
+            writes, updated_references, expected = prepare_document_relocation(
+                self._settings.vault_root, source, target, rendered
+            )
+            expected[source] = actual_hash
+            expected[target] = None
+            change_set = FileChangeSet(
+                writes=tuple(writes),
+                deletes=(source,),
                 label="document apply",
-                expected={path: None if actual_hash == "missing" else actual_hash},
+                expected=expected,
             )
-        )
+        else:
+            change_set = FileChangeSet(
+                writes=(FileWrite(target, rendered),),
+                label="document apply",
+                expected={target: None if not exists else actual_hash},
+            )
+        self._executor.execute(change_set)
         return result.model_copy(
             update={
                 "status": "applied",
                 "write_performed": True,
-                "follow_up": self._follow_up(request, exists, parsed.has_frontmatter),
+                "updated_references": updated_references,
+                "follow_up": self._follow_up(
+                    request, exists, parsed.has_frontmatter, context, changes_type
+                ),
             }
         )
 
-    def _creation_defaults(self, path: Path, document_type: str, today: str) -> dict[str, Any]:
+    def _creation_defaults(
+        self,
+        path: Path,
+        context: DomainContext,
+        document_type: str,
+        today: str,
+    ) -> dict[str, Any]:
         prefix = self._settings.document_types["types"][document_type]["prefix"]
         values: dict[str, Any] = {
             "name": path.stem[len(prefix) :] if path.stem.startswith(prefix) else path.stem,
@@ -186,16 +218,6 @@ class DocumentApplyService:
             "updated": today,
             "tags": [],
         }
-        try:
-            context = resolve_domain_context(
-                self._settings.vault_root,
-                path,
-                self._settings.governance.get("domain_marker", "_领域.md"),
-            )
-        except DomainContextError as exc:
-            raise ConfigurationError(
-                f"无法解析目标 Domain 上下文：{exc.code}: {exc.detail}"
-            ) from exc
         values["domain"] = context.domain_id
         if context.project_id:
             values["project"] = context.project_id
@@ -224,8 +246,8 @@ class DocumentApplyService:
     def _result(
         self,
         request: DocumentApplyRequest,
-        exists: bool,
-        had_frontmatter: bool,
+        target: str,
+        action: str,
         profile: str,
         expected_hash: str,
         status: str,
@@ -235,8 +257,9 @@ class DocumentApplyService:
         return DocumentApplyResult(
             status=status,
             workspace_id=self._settings.workspace_id,
-            action="update" if exists else "create",
+            action=action,
             path=request.path,
+            target=target,
             profile=profile,
             expected_hash=expected_hash,
             issues=issues,
@@ -248,16 +271,31 @@ class DocumentApplyService:
         request: DocumentApplyRequest,
         exists: bool,
         had_frontmatter: bool,
+        context: DomainContext,
+        changes_type: bool,
     ) -> list[CommandFollowUp]:
         derived_fields = {"name", "type", "status", "lifecycle", "domain", "project", "related"}
         needs_sync = not exists or not had_frontmatter
         needs_sync = needs_sync or bool(set(request.values) & derived_fields)
         needs_sync = needs_sync or request.body is not None
+        needs_sync = needs_sync or changes_type
         return (
             maintenance_sync_follow_up(
                 self._settings.workspace_id,
-                [Path(request.path).parent.as_posix()],
+                [context.root.relative_to(self._settings.vault_root).as_posix()],
             )
             if needs_sync
             else []
         )
+
+    def _domain_context(self, path: Path) -> DomainContext:
+        try:
+            return resolve_domain_context(
+                self._settings.vault_root,
+                path,
+                self._settings.governance.get("domain_marker", "_领域.md"),
+            )
+        except DomainContextError as exc:
+            raise ConfigurationError(
+                f"无法解析目标 Domain 上下文：{exc.code}: {exc.detail}"
+            ) from exc

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/document/service/document_move_service.py

@@ -3,18 +3,13 @@ from __future__ import annotations
 from datetime import date
 from pathlib import Path
 from typing import Any
-from urllib.parse import quote
 
 from campfire_cli.app.base.schema.operation_schema import maintenance_sync_follow_up
 from campfire_cli.app.document.schema import DocumentMoveResult
+from campfire_cli.app.document.service.document_relocation import prepare_document_relocation
 from campfire_cli.app.document.service.document_rule_service import DocumentRuleService
 from campfire_cli.app.document.service.frontmatter_formatter import render_patch
 from campfire_cli.app.document.service.profile_registry import ProfileRegistry
-from campfire_cli.app.document.service.type_apply import (
-    rebase_markdown_links,
-    rewrite_markdown_links,
-    rewrite_wikilinks,
-)
 from campfire_cli.common.documents.document_types import prefixed_name
 from campfire_cli.common.documents.domain_context import (
     DomainContext,
@@ -23,7 +18,7 @@ from campfire_cli.common.documents.domain_context import (
 )
 from campfire_cli.common.documents.markdown import parse_document
 from campfire_cli.common.exceptions import ConfigurationError
-from campfire_cli.common.filesystem import FileChangeExecutor, FileChangeSet, FileWrite, safe_path
+from campfire_cli.common.filesystem import FileChangeExecutor, FileChangeSet, safe_path
 from campfire_cli.common.hashing import file_sha256
 from campfire_cli.config.settings import WorkspaceSettings
 
@@ -224,7 +219,9 @@ class DocumentMoveService:
         if issues or not confirm:
             return result
 
-        writes, updated_references, expected = self._prepare_writes(source, target, rendered)
+        writes, updated_references, expected = prepare_document_relocation(
+            self._settings.vault_root, source, target, rendered
+        )
         expected[source] = actual_hash
         expected[target] = None
         self._executor.execute(
@@ -244,36 +241,6 @@ class DocumentMoveService:
             }
         )
 
-    def _prepare_writes(
-        self, source: Path, target: Path, moved_text: str
-    ) -> tuple[list[FileWrite], list[str], dict[Path, str | None]]:
-        references = self._reference_files()
-        unique_stem = (
-            sum(path.stem == source.stem for path in references if path.suffix == ".md") == 1
-        )
-        source_relative = source.relative_to(self._settings.vault_root).as_posix()
-        target_relative = target.relative_to(self._settings.vault_root).as_posix()
-        writes: dict[Path, str] = {}
-        changed: list[str] = []
-        expected = {path: file_sha256(path) for path in references}
-        for reference in references:
-            text = moved_text if reference == source else reference.read_text(encoding="utf-8")
-            updated = text.replace(source_relative, target_relative).replace(
-                quote(source_relative), quote(target_relative)
-            )
-            if unique_stem and source.stem != target.stem:
-                updated = rewrite_wikilinks(updated, source.stem, target.stem)
-            if reference.suffix.lower() == ".md":
-                updated = rewrite_markdown_links(updated, reference, source, target)
-                if reference == source and source.parent != target.parent:
-                    updated = rebase_markdown_links(updated, source, target)
-            output = target if reference == source else reference
-            if reference == source or updated != text:
-                writes[output] = updated
-            if reference != source and updated != text:
-                changed.append(reference.relative_to(self._settings.vault_root).as_posix())
-        return [FileWrite(path, text) for path, text in writes.items()], changed, expected
-
     def _domain_context(self, path: Path) -> tuple[DomainContext | None, str | None]:
         try:
             return (
@@ -294,15 +261,3 @@ class DocumentMoveService:
             *self._settings.governance.get("project_reserved_directories", []),
         }
         return any(part in reserved or part.startswith(".") for part in relative.parts)
-
-    def _reference_files(self) -> list[Path]:
-        ignored = {".git", ".campfire"}
-        return sorted(
-            path
-            for path in self._settings.vault_root.rglob("*")
-            if path.is_file()
-            and path.suffix.lower() in {".md", ".canvas"}
-            and not any(
-                part in ignored for part in path.relative_to(self._settings.vault_root).parts
-            )
-        )

campfire_cli-0.1.10/src/campfire_cli/app/document/service/document_relocation.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import quote
+
+from campfire_cli.app.document.service.type_apply import (
+    rebase_markdown_links,
+    rewrite_markdown_links,
+    rewrite_wikilinks,
+)
+from campfire_cli.common.filesystem import FileWrite
+from campfire_cli.common.hashing import file_sha256
+
+
+def prepare_document_relocation(
+    vault_root: Path,
+    source: Path,
+    target: Path,
+    moved_text: str,
+) -> tuple[list[FileWrite], list[str], dict[Path, str | None]]:
+    """Prepare one document relocation and every deterministic reference rewrite."""
+
+    references = _reference_files(vault_root)
+    unique_stem = sum(
+        path.stem == source.stem for path in references if path.suffix == ".md"
+    ) == 1
+    source_relative = source.relative_to(vault_root).as_posix()
+    target_relative = target.relative_to(vault_root).as_posix()
+    writes: dict[Path, str] = {}
+    changed: list[str] = []
+    expected = {path: file_sha256(path) for path in references}
+    for reference in references:
+        text = moved_text if reference == source else reference.read_text(encoding="utf-8")
+        updated = text.replace(source_relative, target_relative).replace(
+            quote(source_relative), quote(target_relative)
+        )
+        if unique_stem and source.stem != target.stem:
+            updated = rewrite_wikilinks(updated, source.stem, target.stem)
+        if reference.suffix.lower() == ".md":
+            updated = rewrite_markdown_links(updated, reference, source, target)
+            if reference == source and source.parent != target.parent:
+                updated = rebase_markdown_links(updated, source, target)
+        output = target if reference == source else reference
+        if reference == source or updated != text:
+            writes[output] = updated
+        if reference != source and updated != text:
+            changed.append(reference.relative_to(vault_root).as_posix())
+    return [FileWrite(path, text) for path, text in writes.items()], changed, expected
+
+
+def _reference_files(vault_root: Path) -> list[Path]:
+    ignored = {".git", ".campfire"}
+    return sorted(
+        path
+        for path in vault_root.rglob("*")
+        if path.is_file()
+        and path.suffix.lower() in {".md", ".canvas"}
+        and not any(part in ignored for part in path.relative_to(vault_root).parts)
+    )

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/maintenance/service/maintenance_service.py

@@ -153,14 +153,28 @@ class MaintenanceService:
             scope_path = (self._settings.vault_root / scope).resolve()
             if not self._is_within_workspace(scope_path):
                 return self._sync_blocked("scope-outside-workspace", scope, scope)
-            domains = [
+            exact = [domain for domain in domains if domain.path == scope_path]
+            if not exact and not scope_path.exists():
+                return self._sync_blocked("scope-missing", scope, scope)
+            containing = [domain for domain in domains if domain.path in scope_path.parents]
+            if exact:
+                scope_path = exact[0].path
+            elif containing:
+                scope_path = max(containing, key=lambda domain: len(domain.path.parts)).path
+                scope = scope_path.relative_to(self._settings.vault_root).as_posix()
+            descendants = [
                 domain
                 for domain in domains
                 if domain.path == scope_path or scope_path in domain.path.parents
             ]
+            space_marker = self._settings.governance.get("space_marker", "_空间.md")
+            empty_governance_root = scope_path == self._settings.vault_root or (
+                scope_path / space_marker
+            ).is_file()
+            if not descendants and not empty_governance_root:
+                return self._sync_blocked("scope-unmanaged", scope, scope)
+            domains = descendants
             issues = [issue for issue in issues if self._path_matches_scope(issue["path"], scope)]
-            if not domains and not scope_path.exists():
-                return self._sync_blocked("scope-missing", scope, scope)
         if issues:
             return MaintenanceResult(
                 status="blocked",

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/workspace/SPEC.md

@@ -10,9 +10,9 @@
 
 `workspace config check` 统一校验包内产品默认值和当前 Workspace 的有效治理契约，包括目录与 Space 冲突、文档类型前缀、Profile 引用和继承、归档策略以及托管资源列表。
 
-`workspace restructure` 负责原子命令无法表达的批量文档映射、领域拆分和 Frontmatter Patch：冻结范围、生成带内容哈希的审批计划、更新引用并验证迁移事实。Domain 的 rename/move/merge/delete/rekey 直接位于 `workspace domain`；move 使用目标 Space/Domain id 推导路径，merge 一次完成内容迁移和源领域移除，delete 只删除逻辑空领域。单篇文档移动属于 `document move`，以目标 Domain id 代替目标路径。纯移动不得重写文档内容；`verify` 只验证本批次 source/target 结果。该能力属于 Workspace Service，不设独立 App，也不用于日常增量维护。
+`workspace restructure` 负责原子命令无法表达的批量文档映射、领域拆分和 Frontmatter Patch：冻结范围、生成带内容哈希的审批计划、更新引用并验证迁移事实。Domain 的 rename/move/merge/delete/rekey 直接位于 `workspace domain`；move 使用目标 Space/Domain id 推导路径，merge 一次完成内容迁移和源领域移除，delete 只删除逻辑空领域。单篇文档移动属于 `document move`，以目标 Domain id 代替目标路径。无 `--spec` 时只推断可确定的文档类型与文件名前缀规范化；没有变化返回 `up-to-date`，任意路径映射或 Frontmatter Patch 必须使用已文档化的 spec。纯移动不得重写文档内容；`verify` 只验证本批次 source/target 结果。该能力属于 Workspace Service，不设独立 App，也不用于日常增量维护。
 
-Adoption、文档批量 Restructure 与 Domain Restructure 均使用共享 ChangeSet Executor 提交文件写入和路径移动，并在协调的 Repository 写入失败时补偿恢复。Workspace Service 不调用 Maintenance Service；实际写入成功的结果只在必要时以轻量 `follow_up` 返回一个 scoped `maintenance sync`，预览和阻塞结果不返回可执行后续。
+Adoption、文档批量 Restructure 与 Domain Restructure 均使用共享 ChangeSet Executor 提交文件写入和路径移动，并在协调的 Repository 写入失败时补偿恢复。Workspace Service 不调用 Maintenance Service；实际写入成功的结果只在必要时以轻量 `follow_up` 返回零或一个可直接执行的 scoped `maintenance sync`，预览和阻塞结果不返回可执行后续。
 
 Space 是 Workspace 根下以 `_空间.md` 声明的顶级内容容器；Domain 位于 Space 内，以 `_领域.md` 声明并可任意嵌套。子 Domain 必须处于父 Domain 路径下、属于同一 Space 并继承 governance。`_收件箱` 与 `治理视图` 是系统区域，不是 Space。Maintenance 只消费本模块发现的结构，不维护第二套领域规则。
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/workspace/cli/restructure_cli.py

@@ -42,10 +42,15 @@ def plan(
     spec: Path | None = typer.Option(
         None,
         "--spec",
-        help="YAML/JSON：operations[{source,target?,frontmatter?,reason?,approved?}]",
+        help="YAML/JSON 意图规格文件",
     ),
 ) -> None:
-    """生成带源哈希且默认未审批的逐文件计划。"""
+    """生成带源哈希且默认未审批的逐文件计划。
+
+    无 --spec：只规范化类型与文件名。
+    移动或 Frontmatter Patch：使用 operations spec。
+    完整格式见 Restructure Skill reference。
+    """
     emit(invoke(lambda: service(ctx).plan(batch, spec)))
 
 

{campfire_cli-0.1.9 → campfire_cli-0.1.10}/src/campfire_cli/app/workspace/service/restructure_service.py

@@ -318,7 +318,7 @@ class RestructureService:
     ) -> RestructureResult:
         approved_count = sum(item.approved for item in items)
         return RestructureResult(
-            status="planned",
+            status="planned" if items else "up-to-date",
             batch=batch,
             item_count=len(items),
             inventory_count=inventory_count,