@fooksky/lodestar 0.0.0-stage → 0.2.0

package/src/store.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+import { createState, applyOperations, DomainError } from './state.js';
+import { parseState } from './schema.js';
+import { requireWorkspace, workspaceStatus } from './workspace.js';
+
+export const digestText = text => createHash('sha256').update(text.replace(/\r\n?/g, '\n')).digest('hex');
+const fail = (code, message) => { throw new DomainError(code, message); };
+const kinds = ['intent', 'spec', 'plan'];
+
+// All project IO belongs to the caller's host filesystem, never Node fs.
+export class ChangeStore {
+  constructor({ fs, cwd, signal, sandboxPolicy, workspace = { kind: 'directory' } }) {
+    Object.assign(this, { fs, cwd, signal, sandboxPolicy, workspace });
+  }
+  async resolve(path, parent) {
+    if (parent && (await this.fs.lstat(path, { cwd: this.cwd }, this.signal))?.type === 'symlink') fail('INVALID_REFERENCE', `Material paths cannot be symbolic links: ${path}`);
+    const target = await this.fs.resolve(path, { cwd: this.cwd, signal: this.signal });
+    if (parent && !this.fs.contains(parent, target)) fail('INVALID_REFERENCE', `Path escapes its material directory: ${path}`);
+    return target;
+  }
+  async paths(projectRoot, id) {
+    if (id !== undefined && (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(id) || id === 'archive')) fail('INVALID_REFERENCE', 'changeId must be one safe path segment (archive is reserved).');
+    const root = await this.resolve(projectRoot);
+    // Resolve relative to the backend's process path, not its opaque target key.
+    const basePath = this.fs.processPath(root);
+    const materials = await this.resolve(`${basePath}/.dev-docs`, root);
+    const directory = await this.resolve(`${this.fs.processPath(materials)}/changes`, materials);
+    if (id === undefined) return { root, directory };
+    const change = await this.resolve(`${this.fs.processPath(directory)}/${id}`, directory);
+    const state = await this.resolve(`${this.fs.processPath(change)}/state.json`, change);
+    return { root, directory, change, state };
+  }
+  async stableRead(target) {
+    const before = await this.fs.stat(target, this.signal);
+    if (!before) fail('NOT_FOUND', `Missing file: ${target.displayPath}`);
+    const text = await this.fs.readText(target, this.signal);
+    const after = await this.fs.stat(target, this.signal);
+    if (!after || before.version !== after.version) fail('REVISION_CONFLICT', 'File changed while reading; get it again.');
+    return { text, version: after.version };
+  }
+  async readState(target, id) {
+    const { text, version } = await this.stableRead(target);
+    let raw;
+    try { raw = JSON.parse(text); } catch (cause) { throw new DomainError('INVALID_STATE', `Invalid state JSON: ${cause.message}`); }
+    const state = parseState(raw);
+    if (state.id !== id) fail('INVALID_STATE', 'State ID does not match its directory.');
+    return { state, version };
+  }
+  async documents(change, wanted = kinds) {
+    const documents = {};
+    for (const kind of wanted) {
+      const target = await this.resolve(`${this.fs.processPath(change)}/${kind}.md`, change);
+      if (!await this.fs.stat(target, this.signal)) continue;
+      const { text } = await this.stableRead(target);
+      documents[kind] = { path: `${kind}.md`, digest: digestText(text) };
+    }
+    return documents;
+  }
+  async publish(target, state, expected) {
+    try {
+      await this.fs.writeText(target, `${JSON.stringify(state, null, 2)}\n`, expected, this.signal, this.sandboxPolicy);
+    } catch (error) {
+      if (error.code === 'FS_NOT_OBSERVED') fail('ALREADY_EXISTS', 'Change already exists; get its state.');
+      if (error.code === 'FS_STALE_VERSION') fail('REVISION_CONFLICT', 'State changed before publication; get and merge again.');
+      throw error;
+    }
+  }
+  async create({ projectRoot, changeId, title }) {
+    const { state: target, change } = await this.paths(projectRoot, changeId);
+    if (await this.fs.stat(change, this.signal)) fail('ALREADY_EXISTS', 'Change directory already exists. Use get for an existing change or choose a new ID.');
+    const state = createState({ id: changeId, title }, { workspace: this.workspace });
+    await this.publish(target, state, { kind: 'createIfAbsent' });
+    return { id: state.id, revision: state.revision, changed: true, summary: ['Created change.'] };
+  }
+  async get({ projectRoot, changeId, section }) {
+    const paths = await this.paths(projectRoot, changeId);
+    const { state } = await this.readState(paths.state, changeId);
+    const documents = await this.documents(paths.change, Object.keys(state.documents));
+    const consistency = Object.entries(state.documents).map(([kind, registered]) => ({ kind, status: !documents[kind] ? 'missing' : documents[kind].digest === registered.digest ? 'current' : 'changed' }));
+    return { id: state.id, revision: state.revision, bindingStatus: workspaceStatus(this.workspace, state.workspace), binding: state.workspace, ...(section ? { data: state[section] ?? null } : { state }), consistency, blockers: state.blockers.filter(blocker => blocker.status === 'open') };
+  }
+  async update({ projectRoot, changeId, expectedRevision, operations }) {
+    const paths = await this.paths(projectRoot, changeId);
+    const { state, version } = await this.readState(paths.state, changeId);
+    if (state.revision !== expectedRevision) fail('REVISION_CONFLICT', `Expected revision ${expectedRevision}; current revision is ${state.revision}.`);
+    const binding = operations.length === 1 && operations[0].type === 'bind-workspace';
+    if (!binding) requireWorkspace(this.workspace, state.workspace);
+    const documents = binding ? {} : await this.documents(paths.change);
+    const result = applyOperations(state, operations, { expectedRevision, documents, workspace: this.workspace });
+    if (result.changed) await this.publish(paths.state, result.state, { kind: 'replaceIfVersion', version });
+    const { state: updated, ...receipt } = result;
+    return receipt;
+  }
+  async list({ projectRoot, limit = 20, cursor }) {
+    const { directory } = await this.paths(projectRoot);
+    if (!await this.fs.stat(directory, this.signal)) return { items: [] };
+    const entries = (await this.fs.listDir(directory, this.signal)).filter(entry => entry.type === 'directory' && entry.name !== 'archive' && (!cursor || entry.name > cursor)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    const items = [];
+    for (const entry of entries.slice(0, limit)) {
+      try {
+        const { state: target } = await this.paths(projectRoot, entry.name);
+        const { state } = await this.readState(target, entry.name);
+        items.push({ id: state.id, title: state.title, phase: state.workflow.phase, status: state.workflow.status, revision: state.revision, workspace: state.workspace, bindingStatus: workspaceStatus(this.workspace, state.workspace) });
+      } catch (error) {
+        if (!(error instanceof DomainError)) throw error;
+        items.push({ id: entry.name, error: { code: error.code, message: error.message } });
+      }
+    }
+    return { items, ...(entries.length > limit ? { cursor: entries[limit - 1].name } : {}) };
+  }
+}

package/src/tool.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { inputSchema, outputSchema, DomainError } from './schema.js';
+import { ChangeStore } from './store.js';
+import { inspectWorkspace } from './workspace.js';
+
+// DSH canonical output supports a structural JSON Schema subset. Zod keeps
+// refinements at the execution boundary; never pass library metadata to Host.
+export function hostSchema(schema) {
+  const project = node => {
+    if (Array.isArray(node.type)) return { oneOf: node.type.map(type => project({ ...node, type })) };
+    const result = {};
+    for (const key of ['type', 'required', 'enum', 'const', 'description', 'title']) if (node[key] !== undefined) result[key] = node[key];
+    if (node.properties) result.properties = Object.fromEntries(Object.entries(node.properties).map(([key, value]) => [key, project(value)]));
+    if (node.items) result.items = project(node.items);
+    if (node.additionalProperties !== undefined) result.additionalProperties = typeof node.additionalProperties === 'boolean' ? node.additionalProperties : project(node.additionalProperties);
+    if (node.oneOf || node.anyOf) result.oneOf = (node.oneOf ?? node.anyOf).map(project);
+    return result;
+  };
+  return project(JSON.parse(JSON.stringify(z.toJSONSchema(schema, { target: 'draft-7' }))));
+}
+
+export function createTool(ctx) {
+  return {
+    name: 'dev_workflow',
+    description: 'Inspect the current workspace and atomically maintain branch-local change state in .dev-docs. projectRoot must belong to the calling Agent checkout. Load dev-workflow for workflow semantics. create binds the current branch; get/list expose bindingStatus; an intentional branch rename or reassignment uses a separate update with bind-workspace and reason. User decisions require real sources. This tool does not authorize implementation or schedule tasks. On revision conflicts, get and merge before retrying.',
+    parameters: { type: 'object', ...hostSchema(inputSchema) },
+    output: {
+      schema: hostSchema(outputSchema),
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    },
+    async execute(raw, exec) {
+      const parsed = inputSchema.safeParse(raw);
+      if (!parsed.success) throw new DomainError('INVALID_STATE', parsed.error.message);
+      const args = parsed.data;
+      if (!exec.agent) throw new Error('dev_workflow requires a calling Agent and session.');
+      exec.signal?.throwIfAborted();
+      const cwd = await ctx.workingDirectory.ensure(exec.agent, exec.signal);
+      const policyService = ctx.get('sandboxPolicy');
+      if (ctx.fs.sandboxMode !== undefined && !policyService) throw new Error('dev_workflow: sandboxed filesystem requires sandboxPolicy.');
+      const sandboxPolicy = policyService?.resolve({ session: exec.agent.session });
+      try {
+        const workspace = await inspectWorkspace(ctx, { cwd, projectRoot: args.projectRoot, signal: exec.signal, sandboxPolicy });
+        const store = new ChangeStore({ fs: ctx.fs, cwd, signal: exec.signal, sandboxPolicy, workspace });
+        const result = args.action === 'workspace' ? {} : await store[args.action](args);
+        return outputSchema.parse({ action: args.action, workspace, ...result });
+      } catch (error) {
+        if (error instanceof DomainError) error.message = `${error.code}: ${error.message}`;
+        throw error;
+      }
+    },
+  };
+}

package/src/workspace.js

@@ -0,0 +1,93 @@
+import { DomainError } from './schema.js';
+
+const fail = (code, message) => { throw new DomainError(code, message); };
+const sameTarget = (fs, a, b) => fs.contains(a, b) && fs.contains(b, a);
+// Prevent ambient Git overrides from redirecting queries into another checkout.
+const gitEnv = Object.fromEntries([
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE', 'GIT_OBJECT_DIRECTORY',
+  'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_CEILING_DIRECTORIES', 'GIT_DISCOVERY_ACROSS_FILESYSTEM',
+  'GIT_NAMESPACE', 'GIT_CONFIG', 'GIT_CONFIG_PARAMETERS', 'GIT_CONFIG_COUNT',
+].map(key => [key, undefined]));
+
+export async function inspectWorkspace(ctx, { cwd, projectRoot, signal, sandboxPolicy }) {
+  const fs = ctx.fs;
+  const caller = await fs.resolve(cwd, { signal });
+  const project = await fs.resolve(projectRoot, { cwd, signal });
+  if ((await fs.stat(project, signal))?.type !== 'directory') fail('INVALID_WORKSPACE', 'projectRoot must be an existing directory.');
+  if (!ctx.subprocess) fail('WORKSPACE_UNAVAILABLE', 'Workspace discovery requires the host subprocess service and Git.');
+  const subprocess = ctx.subprocess;
+  const executable = await subprocess.resolveExecutable('git', undefined, signal);
+  const sandbox = ctx.get('sandbox');
+  if (sandboxPolicy && sandboxPolicy.mode !== 'danger-full-access' && !sandbox) fail('WORKSPACE_UNAVAILABLE', 'Confined Git discovery requires the host sandbox service.');
+  const query = async (directory, args) => {
+    const querySignal = AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(10000)]);
+    let argv = [executable, '--no-optional-locks', '-c', 'core.fsmonitor=false', ...args];
+    if (sandboxPolicy && sandboxPolicy.mode !== 'danger-full-access') argv = (await sandbox.confine(argv, sandboxPolicy, querySignal)).argv;
+    const handle = subprocess.spawn({
+      argv, cwd: directory, env: { ...gitEnv, LC_ALL: 'C', LANG: 'C', GIT_TERMINAL_PROMPT: '0' },
+      stdio: { stdin: 'ignore', stdout: { maxBytes: 65536 }, stderr: { maxBytes: 65536 } },
+      graceMs: 1000, signal: querySignal,
+    });
+    const outcome = await handle.done;
+    querySignal.throwIfAborted();
+    const stdout = handle.collected.stdout.readFrom(0), stderr = handle.collected.stderr.readFrom(0);
+    if (stdout.lossy || stderr.lossy) fail('GIT_QUERY_FAILED', 'Git workspace output was truncated.');
+    if (outcome.signal || outcome.exitCode === null) fail('GIT_QUERY_FAILED', `Git query terminated: ${outcome.signal ?? 'unknown outcome'}`);
+    return { code: outcome.exitCode, out: stdout.text.replace(/\r?\n$/, ''), err: stderr.text.trim() };
+  };
+  const checked = result => {
+    if (result.code !== 0) fail('GIT_QUERY_FAILED', `Git query failed (${result.code}): ${result.err || result.out}`);
+    return result.out;
+  };
+  const identify = async target => {
+    const directory = fs.processPath(target);
+    const probe = await query(directory, ['rev-parse', '--is-bare-repository']);
+    if (probe.code === 128 && probe.err === 'fatal: not a git repository (or any of the parent directories): .git') return { kind: 'directory' };
+    const bare = checked(probe);
+    if (bare === 'true') fail('INVALID_WORKSPACE', 'A bare repository has no development checkout.');
+    if (bare !== 'false') fail('GIT_QUERY_FAILED', 'Unexpected Git repository probe output.');
+    const top = checked(await query(directory, ['rev-parse', '--show-toplevel']));
+    const root = await fs.resolve(top, { cwd: directory, signal });
+    return { kind: 'git', root };
+  };
+  const current = await identify(project);
+  const calling = sameTarget(fs, caller, project) ? current : await identify(caller);
+  if (current.kind !== calling.kind || (current.kind === 'git' && !sameTarget(fs, current.root, calling.root))) fail('WORKSPACE_MISMATCH', 'Agent cwd and projectRoot must belong to the same checkout. Enter the intended worktree before accessing its materials.');
+  if (current.kind === 'directory') {
+    if (!fs.contains(caller, project)) fail('WORKSPACE_MISMATCH', 'A non-Git projectRoot must be inside the Agent working directory.');
+    return { kind: 'directory', projectRoot: fs.processPath(project) };
+  }
+  const directory = fs.processPath(project);
+  const projectPath = checked(await query(directory, ['rev-parse', '--show-prefix']));
+  const symbolic = await query(directory, ['symbolic-ref', '--quiet', 'HEAD']);
+  let branch = null;
+  if (symbolic.code === 0 && symbolic.out.startsWith('refs/heads/')) branch = symbolic.out.slice('refs/heads/'.length);
+  else if (symbolic.code !== 1 || symbolic.err) checked({ ...symbolic, code: symbolic.code || 128 });
+  const head = await query(directory, ['rev-parse', '--verify', '--quiet', 'HEAD^{commit}']);
+  let headCommit = null;
+  if (head.code === 0 && /^[a-f0-9]{40}([a-f0-9]{24})?$/.test(head.out)) headCommit = head.out;
+  else {
+    // A named ref that does not exist is unborn; corrupt/existing non-commit refs are errors.
+    if (!branch || head.code !== 1 || head.err) checked({ ...head, code: head.code || 128 });
+    const ref = await query(directory, ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`]);
+    if (ref.code !== 1 || ref.err) fail('GIT_QUERY_FAILED', `HEAD does not resolve to a commit: ${ref.err || head.err || branch}`);
+  }
+  return { kind: 'git', projectRoot: directory, checkoutRoot: fs.processPath(current.root), projectPath, branch, headCommit };
+}
+
+export function workspaceStatus(current, binding) {
+  if (current.kind === 'git' && current.branch === null) return 'detached';
+  if (binding.kind !== current.kind) return 'mismatch';
+  return binding.kind === 'directory' || (binding.branch === current.branch && binding.projectPath === current.projectPath) ? 'matched' : 'mismatch';
+}
+
+export function bindWorkspace(current) {
+  if (current.kind === 'directory') return { kind: 'directory' };
+  if (current.branch === null) fail('WORKSPACE_DETACHED', 'A named branch is required to create, bind or update a change.');
+  return { kind: 'git', branch: current.branch, baseCommit: current.headCommit, projectPath: current.projectPath };
+}
+
+export function requireWorkspace(current, binding) {
+  const status = workspaceStatus(current, binding);
+  if (status !== 'matched') fail(status === 'detached' ? 'WORKSPACE_DETACHED' : 'WORKSPACE_MISMATCH', `Workspace binding is ${status}. Read the change and use a separate bind-workspace update with a reason only when reassignment is intended.`);
+}

package/tests/scenarios.md

@@ -0,0 +1,60 @@
+# 开发工作流验证与行为验收记录
+
+程序验证和真实模型会话观察分别记录。`npm test` 的通过不等于以下模型场景已通过；本次没有安装 profile、切换现有会话或启动替代 GUI。
+
+## 首版已完成的可重复程序验证（历史记录）
+
+2026-11-07：使用已安装 DSH `0.2.2-rc.1`，设置 `DSH_HOST_ROOT` 后运行全套，26/26 通过、0 跳过。语法检查与包内容预览通过。
+
+- 状态：确认复用/撤回、原子多操作、当前材料依赖、阶段约束、验收与关闭。
+- 仓储：创建冲突、CAS 并发、正文变化检测、损坏/未知 schema、写入失败不覆盖。
+- 调用边界：Agent 身份、调用者目录、会话 sandbox policy、取消信号透传。
+- 真实 DSH 文件服务：相对项目根、原子并发、目录分页、符号链接路径边界。
+- 真实沙箱：Session + sandboxPolicy + SandboxedFileSystem 验证 workspace-write、read-only、projectRoot 越界及当前目录变化不扩大授权根。
+- 注册、资源和可选模式：真实 Cordis/SkillRegistry/ToolsService、Loader/AgentPresetRegistry 注册、卸载、scope 隔离、子 scope 继承和保留 revision 生命周期通过。模式测试的原生工具名称集合为夹具，未构造完整 Team 服务；不将该测试宣称为真实 Team 工具视图验收。
+
+## 分支扩展已完成的程序验证
+
+2026-11-07：使用已安装 DSH `0.2.2-rc.1`，设置 `DSH_HOST_ROOT` 后运行 `npm test`，**35/35 通过、0 跳过**；`npm run check`、`npm pack --dry-run` 和差异空白检查通过。未安装 profile、提交或推送。以下是实际自动验证的范围，与下方真实模型行为验收分开。
+
+| 范围 | 已验证结果 | 证据 |
+|---|---|---|
+| linked worktree 隔离 | main 与两个 linked worktree 使用同一 change ID，状态独立推进；知识继承提交快照，修改互不影响 | [真实工作区测试](host-workspace.test.js) |
+| 项目根边界 | 跨 checkout 的全部 action 被拒绝；同 checkout 项目子目录可创建/读取；子模块独立识别，从父仓库直接指向子模块被拒绝；普通目录要求位于 cwd 内 | [真实工作区测试](host-workspace.test.js)、[工作区单测](workspace.test.js) |
+| 绑定与重绑 | 创建 schemaVersion: 2 且 workspace 必填的状态；提交推进不锁定，同绑定操作不增 revision、不刷新 baseCommit；分支改名显示 mismatch 并拒绝常规写，独立重绑保留旧绑定和理由；混合操作失败不发布 | [真实工作区测试](host-workspace.test.js) |
+| 状态格式与 CAS | 仅接受 schemaVersion: 2 和必填 workspace；旧/未知 schema、缺失绑定在 get/list/bind 中均报错且不发布；缺失 state 的目录显示错误；错误 revision、原子并发与失败写入保护继续通过。简化后的真实宿主全套 35/35 通过 | [真实工作区测试](host-workspace.test.js)、[仓储测试](store.test.js)、[宿主仓储测试](host-store.test.js) |
+| Git 状态及错误 | detached 可读且 create/update/bind 均拒绝；unborn 可写且 baseCommit null；bare、损坏 gitfile/HEAD 拒绝；缺少服务/Git、spawn 失败、取消、有损输出不降级 | [真实工作区测试](host-workspace.test.js)、[工作区单测](workspace.test.js) |
+| 可移动绑定与合入历史 | 普通 checkout 搬目录后绑定仍匹配；change 材料合入 main 后来源绑定仍可读、常规写拒绝 | [真实工作区测试](host-workspace.test.js) |
+| 真实宿主边界 | 使用实际 fs、subprocess、sandbox、Session 和注册器；read-only 允许读取并拒绝写入；工具/skill/schema 注册及卸载通过；nullable schema 已适配 Host 的 oneOf 子集 | [沙箱测试](host-sandbox.test.js)、[注册测试](registration.test.js) |
+
+工作区单测通过绑定比较验证 HEAD 变化不参与身份判断；未另行重放完整 rebase、浅克隆、跨机器检出或真实 PR 服务。符号链接材料边界由既有真实文件服务测试覆盖。测试准备 Git 仓库可使用 Node child_process，插件生产路径的 Git 查询统一走宿主 subprocess/sandbox。
+
+## 真实模型会话验收（尚未执行）
+
+以下场景应在允许使用插件的隔离会话中观察；不能仅用文档检查宣布通过。无需自动安装到用户 profile。若部署环境未提供这些能力，记录具体阻断，不降低验收标准。
+
+| 场景 | 执行与观察要点 | 判定 |
+|---|---|---|
+| 增量顺序交付 | 两个独立需求分别建 change，确认→设计→授权→实施→实际验收；不自动合并范围 | 待观察 |
+| spec 满足而 intent 不足 | 验证揭示真实需求未满足，回到相应材料并沿用明确的已有确认，不凭测试通过 close | 待观察 |
+| 多轮变更 | intent/spec/plan 反复修订、局部验证失效与有效证据沿用；无旧版本授权串用 | 待观察 |
+| 空项目到 MVP | 按真实可运行切片完成，不以脚手架或假 fixture 冒充产品集成 | 待观察 |
+| 只设计 | 用户要求只设计，交付 spec 后停止，不建实施 plan/goal、不写产品代码 | 待观察 |
+| 确认复用 | 同一句批准需求、方案和实施，不再重复询问；“先别做”不得登记实施授权 | 待观察 |
+| Team 协作 | 原生 task revision/owner/write scopes；成员只做任务包，Lead 持有主材料；inactive 不当 completed | 待观察 |
+| 中断恢复 | 正文先写而状态未登记、回执未知、旧 Team 不可达；只补缺口，不全量重跑 | 待观察 |
+| 浏览器缺失 | 证明替代验证覆盖同一命题，或明确验证未完成，不以编译通过替代交互验收 | 待观察 |
+| 模式生命周期 | 新会话选择、子成员职责、停用后贡献移除、既有有效 change 恢复；普通会话不受影响 | 部分可由宿主集成测试覆盖，模型部分待观察 |
+
+### 分支扩展真实行为观察（尚未执行）
+
+| 场景 | 执行与观察要点 | 判定 |
+|---|---|---|
+| 外部工作区准备 | 外部助手领取 Issue、选择独立 worktree 和启动会话；模型先 workspace 再 create，不让插件创建分支、跨需求调度或扫描其他工作区；普通调查可不建 change | 待观察 |
+| 本地材料与委派 | 每个需求的 Lead 和成员使用本 worktree 的代码、知识、主材料及证据；任务包包含 projectRoot/changeId/预期分支/cwd；不共享材料根或复制后双写 | 待观察 |
+| 分支漂移恢复 | mismatch 先辨认归属，不凭相同 HEAD 猜测；分支改名、明确接管或普通目录初始化为仓库后有依据地独立重绑，历史必含 previous；缺失绑定或非法 schema 报错，不能靠重绑修复；detached 不写，历史合入项不批量改绑 | 待观察 |
+| 运行期间工作区稳定 | 不外部切分支、搬移或清理；同 checkout 不并发切换不同需求；CAS 不当任务锁，多 Lead 先明确交接 | 待观察 |
+| PR/MR 交付边界 | plan/交付记录地址、源/目标分支、评审/合入结果和证据；要求合入时先集成验证，边界为提交 PR 时不声称合入；反馈沿用原有退回、版本及局部失效 | 待观察 |
+| 语义集成与清理 | 知识和 state 冲突核对语义；保留需要的代码、材料及证据后按授权提交/清理；外部数据库、端口、账号等独立隔离，插件不自动接管 | 待观察 |
+
+每次观察记录工作区/分支、材料版本、输入表达、实际产物、验收证据、失败/阻断和结果；耗时/token 仅在宿主提供时记录，不解析私有日志补造指标。