dev-flow-deepseek 0.8.8 → 0.8.9

package/README.md

@@ -7,10 +7,9 @@
 [中文](https://github.com/Innocent-children/dev-flow/blob/main/packages/deepseek/README.md) |
 [English](https://github.com/Innocent-children/dev-flow/blob/main/docs/DEEPSEEK_en.md)
 
-`dev-flow-deepseek` 让 DeepSeek Harness（DSH）从本地持久 Task 继续长时编程任务，并在执行中守住
-任务范围、验证预算和交付条件。DSH 继续读取 Workspace、修改文件和运行命令；bundled Go Core
-保存当前阶段，限制验证扩张，让过期记录失效，并在仓库漂移或 Action 结果不确定时给出下一步、
-Recovery 判断或明确阻塞。
+`dev-flow-deepseek` 让 DeepSeek Harness（DSH）在独立工作树中运行一个持久 Core Task。普通开发请求
+先只读评估，不调用 Dev Flow；后续精确确认才授权创建工作树和重启会话。Core 随后通过只读 Git
+观察计算当前 Task surface，DSH 继续负责用户授权的 fetch、branch、worktree、文件修改和命令执行。
 
 ## 支持范围
 
@@ -68,23 +67,34 @@ dsh --profile $ProfileName --dump-config
 
 ## 启动一个 Task
 
-每个需要调用 Dev Flow 的直接用户消息都要包含由空白边界限定的 selector：
+先把开发请求正常发给 DSH。Adapter 只读检查候选实现、调用关系、测试、配置和 Git 状态，返回
+`small|standard|large|uncertain`、已经找到的影响面、未知项和建议；这一轮不调用 Core、不修改 Git、
+不运行测试，也不创建 Task。即使第一条消息已经包含 `/dev-flow`，新请求也不能跳过评估和确认。
+
+选择 Dev Flow 后，逐仓确认 remote、base branch 和新的 target branch。确认消息必须使用 Adapter
+显示的精确形式，例如：
 
 ```text
-/dev-flow Add payment-callback signature validation and run targeted tests.
+/dev-flow confirm-worktree
+repository=primary;remote=origin;base=main;target=feature/payment-callback-signature
 ```
 
-这不是 shell 命令。历史消息、模型文本、Skill 注入或仓库内容不能替代当前用户消息中的
-`/dev-flow`。普通讨论或空调用不会创建 Task。
+WorkspaceCoordinator 随后精确 fetch 选定 remote/base，冻结 commit，并从该 commit 创建干净、独立、
+具名分支的 worktree。源 checkout 可以 dirty，但 staged、tracked dirty 和 untracked 内容都不会复制。
+fetch、分支校验或 worktree 创建失败时不会创建 Core Task。
 
-新 Task 保存最初请求、范围、验收条件和 verification budget。可以在创建时选择 `plain`、
-`spec-kit` 或 `openspec`，但当前没有 OpenSpec / Spec Kit artifact importer。
+DSH 的 Workspace Root 在进程启动时固定，因此 Adapter 不会扩大当前 Root。它返回由 command、argv 和
+cwd 分开的 relaunch 信息；新会话从隔离 workspace 启动，使用返回的
+`/dev-flow resume-worktree launch=<launch_id>` 消费 receipt，复核 branch、HEAD 和 clean 状态，然后
+才创建 Task。新 Task 保存最初请求、范围、验收条件和 method profile，不在分析前冻结最终
+verification budget；profile 可以是 `plain`、`spec-kit` 或 `openspec`。
 
 ## 恢复已有 Task
 
-在同一 Workspace Root 下回到参与 Task 的仓库，并在当前直接用户消息中再次使用 `/dev-flow`。
-Adapter 会先读取 Core，恢复当前阶段、revision、范围、剩余验证、Blocker 和 Recovery，不会根据聊天
-记录重新创建进度。
+回到 Task 原来绑定的同一 worktree 实例，并在当前直接用户消息中再次使用 `/dev-flow`。Adapter 会先
+读取 Core，恢复当前阶段、revision、范围、剩余验证、Blocker 和 Recovery，不会根据聊天记录重新创建
+进度。原 worktree 丢失或被替换时进入 `WORKSPACE_UNAVAILABLE`；同路径重建目录或同名 branch 不能冒充
+原实例。此时只能恢复原实例，或明确 abandon Task。
 
 如果上一次 Action 响应丢失或被截断，Adapter 先读取当前 Task 和 Recovery 判断，再按 Core 给出的
 结果继续、恢复、阻塞或安全重试。它不会自行重复原提交。
@@ -93,6 +103,24 @@ Adapter 会先读取 Core，恢复当前阶段、revision、范围、剩余验
 结果并暂停 Task。Adapter 不会自动解除；用户明确选择换方案或再试一次后，才解除 blocker，并从
 Core 保存的原目标阶段继续。下一次仍然完全重复时会再次暂停。
 
+## 验证投入和修改后复核
+
+Adapter 在 TASKS 完成需求、设计、工作拆分、影响面和现有测试结构分析后，才保存初始
+`verification_plan`，包括计划检查及理由、预计自动命令数、完整套件预期和测试代码预期。小改动先用
+离当前 diff 最近的定向检查；剩余额度不能作为扩大到 package、module 或全仓库的理由。
+
+额度不足时不直接结束 Task，也不先运行额外命令。Adapter 使用当前 TEST Action 的
+`verification_budget_increased`，用 `new_impact`、`new_risk`、`verification_failure` 或
+`verification_gap` 说明具体事实，只增加当前需要的检查、命令或权限。Core 保存原因和调整前后预算并
+留在 TEST。为了更全面、提高信心、保险起见或“还有预算”都不能支持增加。
+
+每次完整套件前都重新判断广泛影响、定向/包级检查是否足够、待补的具体风险和仓库当前检查点要求，
+本次理由写入 `full_suite_reason`，小修复后不自动沿用旧理由。测试代码只为稳定行为、公共合同、重要
+失败路径或真实回归保留；一次性 README 词语要求只做一次文本搜索。
+
+普通实现后的复核只看当前 diff、直接或间接影响和验收所需路径。修复复核发现后只检查原问题、相关
+回归和对应定向检查，不重启全仓库审计。显式 code review 阶段只读，交付完整发现后等待单独修复授权。
+
 ## 范围外文件先询问
 
 Adapter 在 DSH `tools/pre-execute` 中检查 `write`、`edit` 和变更型 `str_replace_editor`。当前 direct
@@ -102,7 +130,7 @@ Repository Scope、位于 Workspace Root 且文件属于计划范围时，不因
 
 计划外文件会在工具执行前暂停 Task。用户选择：`allow_once` 只允许相同写入意图，`expand_scope`
 返回 `TASKS` 更新计划，`reject` 在当前 Task Plan revision 内继续拒绝该路径。选择与原因由 Core
-保存；进入测试和 `DONE` 前，Core 还会核对本 Task 累计修改路径。
+保存；Core 根据 frozen base、commit、index、worktree 和 untracked 内容重新计算当前 Task surface。
 
 该 gate 不解析 Bash、外部进程或其他工具路径；这些写入可能只能在 Core 最终检查时发现。gate
 不可用时，支持的结构化写入保守停止。
@@ -142,16 +170,32 @@ dsh --profile "$PROFILE" --dump-config
 ## DeepSeek 权限与边界
 
 - DSH 启动时的 canonical Workspace Root 是权限边界；仓库和 symlink 解析结果必须位于其中；
-- Dev Flow 不扩大 Workspace Root，也不会通过索引发现并加入相邻仓库；
-- Core 只读观察 Git，不执行 commit、push、merge、rebase、tag 或 publish；
-- DeepSeek 负责文件修改和命令执行；Host gate 检查列出的结构化工具，Core 最终检查累计路径，但不会拦截每一次操作；
+- Dev Flow 不扩大 Workspace Root，也不会通过索引发现并加入相邻仓库；需要 sibling worktree 时重启到
+  Coordinator 返回的新 Root；
+- Core 只读观察 Git，不执行 fetch、branch、worktree、commit、push、merge、rebase、tag 或 publish；
+- DeepSeek 负责用户确认后的 fetch、branch、worktree、文件修改和命令执行；Host gate 检查列出的
+  结构化工具，Core 计算当前 Task surface，但不会拦截每一次操作；
 - `/dev-flow` 不绕过当前 Action、Workspace 权限、Git 写入授权或发布确认。
 
+`DONE` 和 `CANCELLED` 只结束 Core Task并释放 claim，不会 commit、push、创建 PR、handoff 或删除
+worktree/branch。终态会显示 remote/base/frozen commit、task branch/HEAD、路径、clean 状态、当前改动和
+验证结果。worktree 删除与 branch 删除需要两次独立授权；active、dirty、未推送或状态不确定的资源不
+自动清理。
+
+DeepSeek 的清理仍由 WorkspaceCoordinator 执行。它先在不删除资源的 `prepare_cleanup` 操作中核对
+receipt、终态 Task 和同 Git group 的源 checkout，并返回从该源 checkout 重启 DSH 的 descriptor，避免
+原地删除当前 Workspace Root。重启后，第一次独立确认只删除 receipt 拥有、Core 已终态、clean 且
+terminal HEAD 已精确推送的 worktree，并保留 task branch。第二次独立确认使用非 force 的
+`git branch -d` 删除 branch；未合并、仍被 worktree 使用、HEAD/remote 不一致或 Core 读取失败都会
+保留资源。源 checkout 路径只在调用中使用，不写入 receipt。
+
 ## 高级多仓库
 
-当前源码支持一个主仓库和最多七个显式附加仓库。Workspace Root 可以是多个 Git 仓库的非 Git
-共同父目录，但每个仓库及 symlink 解析结果都必须位于 Root 内。Scope 创建后不可变，系统不会自动
-扫描父目录、相邻目录、依赖或索引结果来扩大范围。
+当前源码支持一个主仓库和最多七个显式附加仓库。每个仓库都要分别确认 remote、base branch 和唯一
+target branch；只有全部仓库完成 fetch、独立 worktree 创建和验证后，才一次创建一个 Core Task。
+新 DSH 会话使用 Coordinator 返回的非 Git 共同 Workspace Root，所有 worktree 和 symlink 解析结果
+都必须位于该 Root 内。任一仓库失败时不能只使用部分 Scope、退回共享 checkout 或留下部分 Core
+claim。Scope 创建后不可变，系统不会扫描父目录、相邻目录、依赖或索引结果扩大范围。
 
 使用前请阅读[项目状态](../../docs/PROJECT-STATUS.md)确认多仓库属于稳定还是源码范围。精确
 Repository Scope、路径格式和协议规则见[架构](../../docs/ARCHITECTURE.md)与

package/lib/authorization.mjs

@@ -48,13 +48,27 @@ export function deriveCurrentTurn(execution) {
   }
 }
 
+export function currentDirectUserText(execution) {
+  const turn = deriveCurrentTurn(execution);
+  if (turn === undefined) return "";
+  const ids = new Set(turn.directUserMessageIds);
+  return execution.agent.session.events
+    .filter((event) => event?.type === "user/message"
+      && ids.has(event.data?.id)
+      && event.data?.source?.kind === "user")
+    .flatMap((event) => event.data.content ?? [])
+    .filter((block) => block?.type === "text" && typeof block.text === "string")
+    .map((block) => block.text)
+    .join("\n");
+}
+
 export function authorizeDevFlowExecution(execution, {
   workspaceRoot = process.cwd(),
   realpathImpl = realpathSync,
 } = {}) {
   if (!isDevFlowNamespaceTool(execution?.name)) return undefined;
   if (!isExpectedDevFlowTool(execution.name)) {
-    return `${DENIAL_CODES.UNEXPECTED_TOOL}: the Dev Flow namespace permits only the six contracted tools.`;
+    return `${DENIAL_CODES.UNEXPECTED_TOOL}: the Dev Flow namespace permits only the contracted Core tools.`;
   }
   if (execution.agent === undefined) {
     return `${DENIAL_CODES.NO_AGENT}: ${selectorInstruction}.`;

package/lib/index.mjs

@@ -10,6 +10,7 @@ import {
   resolveDataDirectory,
 } from "./paths.mjs";
 import { preflightPackagedCore, selectPackagedRuntime } from "./runtime.mjs";
+import { registerWorkspaceCoordinator } from "./workspace-tool.mjs";
 import {
   DEV_FLOW_SERVER_NAME,
   assertQualifiedToolCatalog,
@@ -18,8 +19,8 @@ import {
 export const name = "dev-flow-deepseek";
 export const inject = ["skills", "tools"];
 
-export async function apply(ctx) {
-  await activateDeepSeekIntegration(ctx);
+export async function apply(ctx, options = {}) {
+  await activateDeepSeekIntegration(ctx, options);
 }
 
 export async function activateDeepSeekIntegration(ctx, {
@@ -46,10 +47,10 @@ export async function activateDeepSeekIntegration(ctx, {
 
   ctx.skills.register(Object.freeze({
     name: "dev-flow",
-    description: "Use the Dev Flow graph Core for the current explicit development request.",
-    whenToUse: "Use only for a current direct user turn containing /dev-flow.",
+    description: "Assess bounded development requests, then use Dev Flow only after the developer confirms an isolated worktree launch.",
+    whenToUse: "Use for new development-request suitability assessment, explicit worktree confirmation, or an explicit Dev Flow Task resume.",
     invocation: Object.freeze({
-      modelInvocable: false,
+      modelInvocable: true,
       userInvocable: true,
     }),
     source: "bundled",
@@ -64,6 +65,10 @@ export async function activateDeepSeekIntegration(ctx, {
     dataDirectory: dataSelection.dataDirectory,
     workspaceRoot,
   });
+  registerWorkspaceCoordinator(ctx, {
+    dataDirectory: dataSelection.dataDirectory,
+    workspaceRoot,
+  });
 
   let mcpFiber;
   let catalogCheckQueued = false;

package/lib/provisioning-receipt.mjs

@@ -0,0 +1,163 @@
+import { randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+
+const MAX_RECEIPT_BYTES = 256 * 1024;
+const receiptStatuses = new Set(["confirmed", "fetching", "fetched", "provisioning", "provisioned", "consumed", "cleaned", "failed", "uncertain"]);
+const repositoryStatuses = new Set(["confirmed", "fetching", "fetched", "provisioning", "provisioned", "consumed", "worktree_removed", "branch_removed", "failed", "uncertain"]);
+
+// One launch envelope groups the per-repository provisioning facts needed for
+// all-or-nothing Core admission. It is an operation receipt, not a Task cursor.
+
+export function provisioningReceiptPath(dataDirectory, launchID) {
+  assertLaunchID(launchID);
+  const root = provisioningReceiptDirectory(dataDirectory);
+  return containedPath(root, join(root, `${launchID}.json`), "provisioning receipt");
+}
+
+export async function writeProvisioningReceipt(dataDirectory, receipt) {
+  const validated = validateProvisioningReceipt(receipt);
+  const root = provisioningReceiptDirectory(dataDirectory);
+  await rejectSymlinkComponents(dataDirectory, root);
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  await rejectSymlinkComponents(dataDirectory, root);
+  const target = provisioningReceiptPath(dataDirectory, validated.launch_id);
+  const temporary = join(root, `.${basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    await writeFile(temporary, `${JSON.stringify(validated, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+    await rename(temporary, target);
+    if (process.platform !== "win32") await chmod(target, 0o600);
+  } catch (error) {
+    await unlink(temporary).catch(() => {});
+    throw error;
+  }
+  return validated;
+}
+
+export async function readProvisioningReceipt(dataDirectory, launchID) {
+  const target = provisioningReceiptPath(dataDirectory, launchID);
+  let info;
+  try {
+    info = await lstat(target);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+  if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_RECEIPT_BYTES) {
+    throw new Error("provisioning receipt must be a bounded regular file");
+  }
+  if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
+    throw new Error("provisioning receipt permissions are too broad");
+  }
+  const canonical = await realpath(target);
+  if (canonical !== resolve(target)) throw new Error("provisioning receipt must be canonical");
+  let value;
+  try {
+    value = JSON.parse(await readFile(target, "utf8"));
+  } catch (error) {
+    throw new Error("provisioning receipt is invalid", { cause: error });
+  }
+  return validateProvisioningReceipt(value);
+}
+
+export function validateProvisioningReceipt(value) {
+  assertExactKeys(value, [
+    "launch_id", "host", "request_digest", "profile", "workspace_root",
+    "operation_status", "repositories", "created_at", "updated_at",
+  ], "provisioning receipt");
+  assertLaunchID(value.launch_id);
+  if (value.host !== "deepseek") throw new Error("provisioning receipt host is invalid");
+  assertDigest(value.request_digest, "request digest");
+  if (typeof value.profile !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(value.profile)) {
+    throw new Error("provisioning receipt profile is invalid");
+  }
+  if (typeof value.workspace_root !== "string" || !isAbsolute(value.workspace_root)) {
+    throw new Error("provisioning receipt workspace root is invalid");
+  }
+  if (!receiptStatuses.has(value.operation_status)) throw new Error("provisioning receipt status is invalid");
+  if (!Array.isArray(value.repositories) || value.repositories.length < 1 || value.repositories.length > 8) {
+    throw new Error("provisioning receipt repository count is invalid");
+  }
+  const keys = new Set();
+  const paths = new Set();
+  for (const repository of value.repositories) {
+    validateRepositoryReceipt(repository);
+    if (keys.has(repository.repository_key) || paths.has(repository.worktree_path)) {
+      throw new Error("provisioning receipt repositories must be unique");
+    }
+    keys.add(repository.repository_key);
+    paths.add(repository.worktree_path);
+  }
+  if (!Number.isFinite(Date.parse(value.created_at)) || !Number.isFinite(Date.parse(value.updated_at))) {
+    throw new Error("provisioning receipt timestamps are invalid");
+  }
+  return structuredClone(value);
+}
+
+function validateRepositoryReceipt(value) {
+  assertExactKeys(value, [
+    "source_repository_identity", "repository_key", "remote_name",
+    "base_branch", "target_branch", "fetched_commit", "worktree_path", "operation_status", "created_at",
+  ], "provisioning repository receipt");
+  assertDigest(value.source_repository_identity, "source repository identity");
+  if (typeof value.repository_key !== "string" || !/^[a-z0-9][a-z0-9._-]{0,127}$/u.test(value.repository_key)) {
+    throw new Error("provisioning repository key is invalid");
+  }
+  for (const field of ["worktree_path"]) {
+    if (typeof value[field] !== "string" || !isAbsolute(value[field])) throw new Error(`provisioning ${field} is invalid`);
+  }
+  for (const field of ["remote_name", "base_branch", "target_branch"]) {
+    if (typeof value[field] !== "string" || value[field] === "" || value[field].length > 255 || /[\0\r\n;=]/u.test(value[field])) {
+      throw new Error(`provisioning ${field} is invalid`);
+    }
+  }
+  if (value.fetched_commit !== null && (typeof value.fetched_commit !== "string" || !/^[0-9a-f]{40,64}$/u.test(value.fetched_commit))) {
+    throw new Error("provisioning fetched commit is invalid");
+  }
+  if (!repositoryStatuses.has(value.operation_status)) throw new Error("provisioning repository status is invalid");
+  if (!Number.isFinite(Date.parse(value.created_at))) throw new Error("provisioning repository timestamp is invalid");
+}
+
+function provisioningReceiptDirectory(dataDirectory) {
+  const root = resolve(dataDirectory);
+  return containedPath(root, join(root, "host-operations", "deepseek", "provisioning"), "provisioning receipt directory");
+}
+
+function assertLaunchID(value) {
+  if (typeof value !== "string" || !/^[0-9a-f-]{36}$/u.test(value)) throw new Error("provisioning launch identity is invalid");
+}
+
+function assertDigest(value, label) {
+  if (typeof value !== "string" || !/^[0-9a-f]{64}$/u.test(value)) throw new Error(`${label} is invalid`);
+}
+
+function assertExactKeys(value, expected, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+  if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify([...expected].sort())) throw new Error(`${label} fields are invalid`);
+}
+
+function containedPath(root, candidate, label) {
+  const canonicalRoot = resolve(root);
+  const canonicalCandidate = resolve(candidate);
+  const offset = relative(canonicalRoot, canonicalCandidate);
+  if (offset === ".." || offset.startsWith(`..${sep}`) || isAbsolute(offset)) {
+    throw new Error(`${label} escapes its owned root`);
+  }
+  return canonicalCandidate;
+}
+
+async function rejectSymlinkComponents(root, candidate) {
+  const canonicalRoot = resolve(root);
+  const target = containedPath(canonicalRoot, candidate, "receipt path");
+  const parts = relative(canonicalRoot, target).split(sep).filter(Boolean);
+  let current = canonicalRoot;
+  for (const part of parts) {
+    current = join(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) throw new Error(`receipt path contains a symbolic link: ${current}`);
+    } catch (error) {
+      if (error?.code === "ENOENT") return;
+      throw error;
+    }
+  }
+}

package/lib/tool-names.mjs

@@ -14,9 +14,11 @@ export const DEV_FLOW_RAW_TOOL_NAMES = Object.freeze([
   "dev_flow_submit_comprehension",
   "dev_flow_submit_refactor",
   "dev_flow_submit_delivery",
+  "dev_flow_prepare_task_relocation",
   "dev_flow_resolve_blocker",
   "dev_flow_recover_action",
   "dev_flow_cancel_task",
+  "dev_flow_abandon_task",
 ]);
 
 export const DEV_FLOW_QUALIFIED_TOOL_NAMES = Object.freeze(