@zq-silk/yui 0.10.0 → 0.11.0

package/dist/web/assets/client/view.js

@@ -14,6 +14,8 @@ import {
   messageCard,
   metaItem,
   metricTile,
+  observabilityMetricCard,
+  dagGraph,
   overviewRow,
   pagedList,
   pathMetaItem,
@@ -290,6 +292,9 @@ export function renderTaskDetail(detail, data, t, locale, actions) {
   // the attention/blocker facts behind it.
   const band = executionBand(data.execution, t, locale);
   if (band) summaryBody.append(band);
+  const observability = data.observability || (data.execution && data.execution.observability);
+  const metrics = observabilityMetricCard(observability, t);
+  if (metrics) summaryBody.append(metrics);
 
   if (task.completionSummary) {
     const conclusion = node("div", "conclusion");
@@ -367,6 +372,16 @@ export function renderTaskDetail(detail, data, t, locale, actions) {
     ));
   }
 
+  if (observability && observability.dag) {
+    const dagBody = node("div", "section-body");
+    dagBody.append(dagGraph(observability.dag, t));
+    scaffold.append(anchorSection(
+      "detail-dag",
+      sectionHead(t("detail.dag"), { count: observability.dag.nodes.length }),
+      dagBody
+    ));
+  }
+
   // 3. Focus (anchor #detail-focus) — brief + technical approach
   const focusBody = node("div", "section-body");
   if (data.brief) {

package/dist/web/assets/styles/cards.js

@@ -159,6 +159,29 @@ details.work-item-card>summary.record-head~*{margin-top:0}
 .lane-role{font-family:var(--font-body);font-weight:700;font-size:12px;color:var(--text)}
 .lane-status{font-family:var(--font-mono);font-size:9.5px;letter-spacing:.06em;text-transform:uppercase;color:var(--muted)}
 .lane-summary{flex:1;min-width:0;color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.execution-stage-meta,.execution-resource-meta,.work-item-observability{gap:10px;flex-wrap:wrap}
+.work-item-stages{margin-top:6px}
+.execution-stage-meta .chip,.execution-resource-meta .chip{margin-left:auto}
+.observability-metrics{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:8px;margin-top:12px}
+.observability-metrics .metric{min-height:52px;padding:8px 10px}
+.observability-metrics .metric-value{font-size:18px}
+.observability-context-meta{gap:10px;flex-wrap:wrap;margin-top:7px}
+.dag-graph{display:grid;gap:8px}
+.dag-node{display:grid;gap:6px;padding:9px 11px;background:var(--bg-2);border:1px solid var(--border);border-left:3px solid var(--faint);border-radius:var(--radius);box-shadow:var(--shadow-card)}
+.dag-node.is-ready{border-left-color:var(--accent)}
+.dag-node.is-running{border-left-color:var(--active)}
+.dag-node.is-blocked,.dag-node.is-failed,.dag-node.is-awaiting_acceptance{border-left-color:var(--danger)}
+.dag-node.is-completed{border-left-color:var(--success)}
+.dag-node.is-retired{border-left-color:var(--faint)}
+.dag-node-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
+.dag-node-head .status-dot{margin-top:0}
+.dag-node-title{flex:1;min-width:0;font-size:12px;color:var(--text)}
+.dag-node-deps{display:flex;align-items:center;gap:6px;flex-wrap:wrap;color:var(--muted);font-family:var(--font-mono);font-size:9.5px}
+.dag-node-deps small{margin-right:2px;text-transform:uppercase;letter-spacing:.08em}
+.dag-root-cause{color:var(--warning);font-family:var(--font-mono);font-size:9.5px;letter-spacing:.03em}
+.chip.is-satisfied{color:var(--success);background:var(--success-soft);border-color:transparent}
+.chip.is-active{color:var(--accent);background:var(--accent-soft);border-color:var(--accent-line)}
+.chip.is-failed-open,.chip.is-dead{color:var(--danger);background:var(--danger-soft);border-color:transparent}
 .exec-resolution{display:flex;gap:9px;align-items:baseline;flex-wrap:wrap;padding:7px 10px;border-radius:var(--radius);background:var(--accent-soft);border:1px solid var(--accent-line)}
 .exec-resolution-decision{font-family:var(--font-mono);font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--accent)}
 .exec-resolution-summary{flex:1;min-width:0;font-size:12px;color:var(--text)}

package/dist/web/assets/styles/responsive.js

@@ -21,6 +21,7 @@ export const RESPONSIVE_STYLES = `
   body.detail-active .detail-back{display:grid}
   .detail{overflow:visible}
   .overview-duo{grid-template-columns:1fr}
+  .observability-metrics{grid-template-columns:repeat(3,minmax(0,1fr))}
   /* Terminal panel overlays full-screen instead of occupying a grid column */
   .terminal-panel{position:fixed;inset:0;z-index:70;grid-column:auto;height:100vh;border-left:0}
 }
@@ -34,6 +35,7 @@ export const RESPONSIVE_STYLES = `
   .topbar{flex-wrap:nowrap;gap:10px}
   .detail-tabs{mask-image:linear-gradient(90deg,#000 calc(100% - 28px),transparent);-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 28px),transparent)}
   .record-cols{grid-template-columns:1fr}
+  .observability-metrics{grid-template-columns:repeat(2,minmax(0,1fr))}
 }
 @media(prefers-reduced-motion:reduce){*{scroll-behavior:auto!important;transition:none!important;animation:none!important}}
 `;

package/dist/web/webSnapshot.js

@@ -33,7 +33,7 @@ export function buildWebDashboardSnapshot(store, now = new Date()) {
             const needsAttentionCount = reader.listAgentRuns(task.id)
                 .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
                 .length;
-            const execution = buildTaskExecutionProjection(reader, task.id);
+            const execution = buildTaskExecutionProjection(reader, task.id, task, now);
             const names = task.projectBindings.flatMap(({ projectId }) => {
                 const name = projectNames.get(projectId);
                 return name === undefined ? [] : [name];
@@ -105,18 +105,24 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
                     && effectiveLaunch.sourceDesiredRevision !== role.launchRevision
             };
         });
+        const execution = buildTaskExecutionProjection(reader, taskId, task, now);
+        if (execution === null)
+            return null;
+        const workItemObservability = new Map(execution.observability.workItems.map((item) => [item.workItemId, item]));
         return {
             task: {
                 ...task,
                 ...(projectNames.length === 0 ? {} : { projectNames })
             },
-            execution: buildTaskExecutionProjection(reader, taskId),
+            execution,
+            observability: execution.observability,
             brief: reader.getTaskBrief(taskId),
             roles,
             workItems: reader.listWorkItems(taskId).map((item) => {
                 const group = currentWorkItemExecutionGroup(item);
                 return {
                     ...item,
+                    observability: workItemObservability.get(item.id),
                     ...(group === undefined ? {} : { currentExecution: summarizeExecutionGroup(group) })
                 };
             }),

package/dist/workItem/workItem.js

@@ -1,9 +1,10 @@
-import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
+import { normalizedUniqueIdentities, normalizedUniqueText, requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
+import { contextContentDigest, validateContextSnapshotRef } from "../context/contextSnapshot.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
 import { taskFinalReviewConfig, validateTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { assertExecutionGroupTransition, validateExecutionGroup } from "../execution/executionGroup.js";
+import { assertExecutionGroupTransition, validateExecutionGroup, WORK_ITEM_EXPLORATION_STAGES } from "../execution/executionGroup.js";
 const TERMINAL_STATUSES = [
     "completed",
     "failed",
@@ -12,7 +13,7 @@ const TERMINAL_STATUSES = [
 export function createWorkItem(id, taskId, input, now) {
     const timestamp = now.toISOString();
     return validateWorkItem({
-        schemaVersion: 9,
+        schemaVersion: 12,
         id: requireIdentity(id, "Work Item id"),
         taskId: requireIdentity(taskId, "Task id"),
         title: requireText(input.title, "Work item title"),
@@ -247,8 +248,8 @@ export function recordWorkItemWorkspaceDisposition(workItem, disposition, now) {
     });
 }
 export function validateWorkItem(workItem) {
-    if (workItem.schemaVersion !== 9)
-        throw new Error("WorkItem must use schemaVersion 9.");
+    if (workItem.schemaVersion !== 12)
+        throw new Error("WorkItem must use schemaVersion 12.");
     validateTaskRecordReference({ taskId: workItem.taskId, localId: workItem.id }, "workItem");
     requireIdentity(workItem.taskId, "Task id");
     requireText(workItem.title, "Work item title");
@@ -283,6 +284,7 @@ export function validateWorkItem(workItem) {
         }
         groupIds.add(group.id);
     }
+    validateWorkItemExplorationHistory(workItem.executionGroups);
     if (workItem.currentExecutionGroupId !== undefined) {
         requireIdentity(workItem.currentExecutionGroupId, "ExecutionGroup id");
         if (!groupIds.has(workItem.currentExecutionGroupId)) {
@@ -309,6 +311,16 @@ export function validateWorkItem(workItem) {
         if (candidate.workItemRevision > workItem.revision) {
             throw new Error("Work Item candidate revision cannot exceed the Work Item revision.");
         }
+        if (candidate.executionGroupId !== undefined) {
+            const group = workItem.executionGroups.find(({ id }) => id === candidate.executionGroupId);
+            if (group?.stage !== undefined) {
+                if (group.stage.stage !== "resolve"
+                    || group.resolution?.decision !== "accept"
+                    || !group.resolution.selectedLaneIds.includes(candidate.executionLaneId)) {
+                    throw new Error("An exploration Candidate must come from the accepted Resolve stage.");
+                }
+            }
+        }
     });
     const currentCandidate = currentWorkItemCandidate(workItem);
     if (workItem.status === "awaiting_acceptance" && currentCandidate === undefined) {
@@ -351,6 +363,130 @@ export function validateWorkItem(workItem) {
     }
     return workItem;
 }
+/**
+ * Project the next legal exploration stage from immutable WorkItem Group
+ * history. Retry repeats the current stage; retry at Resolve begins the next
+ * round. Reject has no continuation, while blocked follows the same bounded
+ * retry path after the Leader settles any required InputRequest.
+ */
+export function planWorkItemExplorationStage(workItem, input) {
+    validateWorkItem(workItem);
+    const snapshot = validateContextSnapshotRef(input.contextSnapshotRef);
+    const capacity = executionStrategyCapacity(input.strategy);
+    const current = currentWorkItemExecutionGroup(workItem);
+    if (workItem.executionGroups.length === 0) {
+        if (workItem.status !== "pending" && workItem.status !== "running") {
+            throw new Error(`Work Item cannot begin exploration from ${workItem.status}: ${workItem.id}.`);
+        }
+        if (input.mode === undefined) {
+            throw new Error("The first exploration stage requires a mode.");
+        }
+        if (input.convergence === undefined) {
+            throw new Error("The first exploration stage requires a candidate convergence policy.");
+        }
+        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
+        const resources = requireNewStageResources(input.resources);
+        return {
+            schemaVersion: 1,
+            mode: input.mode,
+            stage: "plan",
+            round: 1,
+            stageAttempt: 1,
+            maxRounds: requirePositiveInteger(input.maxRounds ?? 1, "Exploration max rounds"),
+            budget: {
+                maxLanes: capacity,
+                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
+                ...resourceBudget
+            },
+            resources,
+            contextSnapshotRef: snapshot,
+            parentResults: [],
+            ...(input.convergence === undefined ? {} : { convergence: input.convergence })
+        };
+    }
+    if (current === undefined || current.stage === undefined) {
+        throw new Error("A Work Item cannot mix single and exploration ExecutionGroups.");
+    }
+    if (current.resolution === undefined) {
+        throw new Error(`Execution stage is still active: ${current.id}.`);
+    }
+    if (input.mode !== undefined && input.mode !== current.stage.mode) {
+        throw new Error("Work Item exploration mode is immutable.");
+    }
+    if (input.maxRounds !== undefined && input.maxRounds !== current.stage.maxRounds) {
+        throw new Error("Work Item exploration maxRounds is immutable.");
+    }
+    const parentResults = selectedParentResults(current);
+    const base = {
+        schemaVersion: 1,
+        mode: current.stage.mode,
+        maxRounds: current.stage.maxRounds,
+        contextSnapshotRef: snapshot,
+        parentResults,
+        ...(current.stage.convergence === undefined
+            ? {}
+            : { convergence: current.stage.convergence })
+    };
+    if (current.resolution.decision === "reject") {
+        throw new Error(`Rejected exploration has no continuation: ${current.id}.`);
+    }
+    if (current.resolution.decision === "accept") {
+        if (current.stage.stage === "resolve") {
+            throw new Error(`Accepted Resolve stage already completed exploration: ${current.id}.`);
+        }
+        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
+        const resources = requireNewStageResources(input.resources);
+        return {
+            ...base,
+            stage: nextExplorationStage(current.stage.stage),
+            round: current.stage.round,
+            stageAttempt: 1,
+            budget: {
+                maxLanes: capacity,
+                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
+                ...resourceBudget
+            },
+            resources
+        };
+    }
+    if (current.stage.stage === "resolve" && current.resolution.decision === "retry") {
+        if (current.stage.round >= current.stage.maxRounds) {
+            throw new Error(`Work Item exploration round budget is exhausted: ${workItem.id}.`);
+        }
+        const resourceBudget = requireNewStageResourceBudget(input.resourceBudget);
+        const resources = requireNewStageResources(input.resources);
+        return {
+            ...base,
+            stage: "plan",
+            round: current.stage.round + 1,
+            stageAttempt: 1,
+            budget: {
+                maxLanes: capacity,
+                maxAttempts: requirePositiveInteger(input.maxAttempts ?? 1, "Exploration stage max attempts"),
+                ...resourceBudget
+            },
+            resources
+        };
+    }
+    if (current.stage.stageAttempt >= current.stage.budget.maxAttempts) {
+        throw new Error(`Work Item exploration stage attempt budget is exhausted: ${workItem.id}.`);
+    }
+    if (capacity !== current.stage.budget.maxLanes) {
+        throw new Error("A retried exploration stage must keep its frozen Lane budget.");
+    }
+    if (input.maxAttempts !== undefined
+        && input.maxAttempts !== current.stage.budget.maxAttempts) {
+        throw new Error("A retried exploration stage must keep its frozen attempt budget.");
+    }
+    return {
+        ...base,
+        stage: current.stage.stage,
+        round: current.stage.round,
+        stageAttempt: current.stage.stageAttempt + 1,
+        budget: current.stage.budget,
+        ...(current.stage.resources === undefined ? {} : { resources: current.stage.resources })
+    };
+}
 /** Resolve the WorkItem's current execution iteration. */
 export function currentWorkItemExecutionGroup(workItem) {
     return workItem.currentExecutionGroupId === undefined
@@ -361,6 +497,127 @@ export function currentWorkItemExecutionGroup(workItem) {
 export function workItemExecutionGroupById(workItem, executionGroupId) {
     return workItem.executionGroups.find(({ id }) => id === executionGroupId);
 }
+/**
+ * True when a Run failure belongs to the WorkItem's current unresolved Lane.
+ * Such a failure is Lane-bounded: the WorkItem remains running so the Leader
+ * can reuse completed siblings and retry only this failed attempt.
+ */
+export function workItemOwnsUnresolvedExecutionLane(workItem, executionGroupId, executionLaneId) {
+    if (executionGroupId === undefined
+        || executionLaneId === undefined
+        || workItem.currentExecutionGroupId !== executionGroupId)
+        return false;
+    const group = workItem.executionGroups.find(({ id }) => id === executionGroupId);
+    return group !== undefined
+        && group.resolution === undefined
+        && group.lanes.some(({ id, status }) => (id === executionLaneId && status === "failed"));
+}
+function validateWorkItemExplorationHistory(groups) {
+    const staged = groups.filter(({ stage }) => stage !== undefined);
+    if (staged.length === 0)
+        return;
+    if (staged.length !== groups.length) {
+        throw new Error("A Work Item cannot mix single and exploration ExecutionGroups.");
+    }
+    const first = groups[0].stage;
+    if (first.stage !== "plan"
+        || first.round !== 1
+        || first.stageAttempt !== 1
+        || first.parentResults.length !== 0) {
+        throw new Error("Work Item exploration must begin at Plan round 1 attempt 1.");
+    }
+    for (let index = 1; index < groups.length; index += 1) {
+        const previous = groups[index - 1];
+        const current = groups[index];
+        const before = previous.stage;
+        const after = current.stage;
+        if (previous.resolution === undefined) {
+            throw new Error(`Exploration stage must resolve before its successor: ${previous.id}.`);
+        }
+        if (previous.resolution.decision === "reject") {
+            throw new Error(`Rejected exploration cannot have a successor: ${previous.id}.`);
+        }
+        if (after.mode !== before.mode
+            || after.maxRounds !== before.maxRounds
+            || JSON.stringify(after.convergence) !== JSON.stringify(before.convergence)) {
+            throw new Error("Work Item exploration mode, maxRounds and convergence policy are immutable.");
+        }
+        const parents = selectedParentResults(previous);
+        if (JSON.stringify(after.parentResults) !== JSON.stringify(parents)) {
+            throw new Error(`Exploration parentResults do not match ${previous.id}.`);
+        }
+        if (previous.resolution.decision === "accept") {
+            if (before.stage === "resolve"
+                || after.stage !== nextExplorationStage(before.stage)
+                || after.round !== before.round
+                || after.stageAttempt !== 1) {
+                throw new Error(`Exploration stage transition is invalid: ${previous.id}/${current.id}.`);
+            }
+            continue;
+        }
+        if (before.stage === "resolve" && previous.resolution.decision === "retry") {
+            if (before.round >= before.maxRounds
+                || after.stage !== "plan"
+                || after.round !== before.round + 1
+                || after.stageAttempt !== 1) {
+                throw new Error(`Exploration round transition is invalid: ${previous.id}/${current.id}.`);
+            }
+            continue;
+        }
+        if (after.stage !== before.stage
+            || after.round !== before.round
+            || after.stageAttempt !== before.stageAttempt + 1
+            || after.stageAttempt > before.budget.maxAttempts
+            || JSON.stringify(after.budget) !== JSON.stringify(before.budget)
+            || JSON.stringify(after.resources) !== JSON.stringify(before.resources)) {
+            throw new Error(`Exploration retry transition is invalid: ${previous.id}/${current.id}.`);
+        }
+    }
+}
+function requireNewStageResourceBudget(value) {
+    if (value?.maxTokens === undefined
+        || value.maxToolCalls === undefined
+        || value.maxWallClockSeconds === undefined) {
+        throw new Error("A new exploration stage requires token, tool-call and wall-clock budgets.");
+    }
+    return {
+        maxTokens: requirePositiveInteger(value.maxTokens, "Exploration stage max tokens"),
+        maxToolCalls: requirePositiveInteger(value.maxToolCalls, "Exploration stage max tool calls"),
+        maxWallClockSeconds: requirePositiveInteger(value.maxWallClockSeconds, "Exploration stage max wall-clock seconds")
+    };
+}
+function requireNewStageResources(value) {
+    if (value === undefined) {
+        throw new Error("A new exploration stage requires resource completion policy.");
+    }
+    return value;
+}
+function selectedParentResults(group) {
+    if (group.resolution === undefined) {
+        throw new Error(`ExecutionGroup is unresolved: ${group.id}.`);
+    }
+    return group.resolution.selectedLaneIds.map((laneId) => {
+        const lane = group.lanes.find(({ id }) => id === laneId);
+        if (lane?.result === undefined) {
+            throw new Error(`Selected ExecutionLane result is missing: ${group.id}/${laneId}.`);
+        }
+        return {
+            executionGroupId: group.id,
+            executionLaneId: lane.id,
+            resultDigest: contextContentDigest(lane.result)
+        };
+    });
+}
+function nextExplorationStage(stage) {
+    const index = WORK_ITEM_EXPLORATION_STAGES.indexOf(stage);
+    const next = WORK_ITEM_EXPLORATION_STAGES[index + 1];
+    if (next === undefined)
+        throw new Error("Resolve is the final exploration stage.");
+    return next;
+}
+function executionStrategyCapacity(strategy) {
+    return requirePositiveInteger(strategy.mode === "fixed" ? strategy.count : strategy.max, "Execution strategy capacity");
+}
 function validateWorkItemExecutionGroup(group, taskId, workItemId) {
     validateExecutionGroup(group);
     if (group.taskId !== taskId || group.purpose !== "execution") {

package/i18n/README.zh-CN.md

@@ -288,6 +288,48 @@ yui task work isolate <task-id>/<work-item-id>
 yui task work dispatch <task-id>/<work-item-id> --input "完成实现并运行聚焦测试"
 ```
 
+派发默认仍为 `single`。Leader 可在全新 WorkItem 上显式开启有界多路探索；每个
+接受的阶段按 `Plan → Generate → Compare → Synthesize → Verify → Resolve`
+推进，只有接受后的 Resolve 阶段会物化既有的单一 Candidate：
+
+```sh
+yui task work dispatch <task-id>/<work-item-id> \
+  --mode parallel-diverse --max-rounds 2 --stage-max-attempts 2 \
+  --strategy fixed:2 --lane-role critic \
+  --stage-max-tokens 240000 --stage-max-tool-calls 200 \
+  --stage-max-seconds 1800 --stage-quorum 2
+yui task work group resolve <task-id>/<work-item-id> \
+  --decision accept --summary "Plan 证据充分"
+```
+
+每个阶段都是新的不可变 ExecutionGroup；其 ContextSnapshot 与选中的父 Lane
+结果都以持久引用衔接。`retry` 在阶段尝试预算内重做当前阶段，而 Resolve 上的
+`retry` 才进入下一轮，并受最大轮次约束。
+
+每个新阶段还会冻结一份 Resource Broker 契约：token、工具调用和墙钟预算，
+quorum 与 deadline，straggler 窗口，以及继续增加 Lane 所需的最低边际价值。
+省略这些参数时复用现有 context budget 与 runtime-health 时间窗；同一阶段的 retry
+累计原有花费并共享绝对 deadline。执行、Lane retry 和 Reviewer panel 准入统一核算
+Home、Task、WorkItem、Group、Provider、Agent 和模型层级的活动 Lane；容量不足的
+Lane 会耐久保留为 pending，不会把整个 Group 判失败。容量释放或 deadline 到达会沿
+既有 actionability 路径唤醒 Leader，重跑同一 dispatch 即按冻结输入继续。释放的
+容量优先留给最早且当前可准入的等待 Lane；受 Provider 或 Agent 限制的队首
+不会阻塞独立资源域继续推进。Provider 限流仍沿用既有的原地重试窗口，不会扩散成
+兄弟 Lane 失败。
+
+Leader 可在接受 Group 时增加 `--early-stop <0-100>`。只有 quorum 已满足且 T5 的
+Verify/Resolve 证据证明验收充分时，Yui 才允许提前终止；它只跳过从未启动的 Lane，
+运行中的 straggler 会被报告并保留，不会因为省费被自动杀死。证据不足时，预算或
+deadline 耗尽会把阶段留给 Leader 决议，绝不会把薄证据转换成成功。
+
+新建探索历史还会冻结结构化候选收敛契约。Yui 将当前阶段的精确 JSON 形状追加到
+每个 Lane assignment，并在 Leader 推进前校验入选报告：Compare 必须显式划分
+重复簇，并以直接来源、可执行检查或冻结产物支持每条入选路线；Synthesize 对调研
+使用 claim/evidence 表、对架构使用决策矩阵、对代码只选择一个冻结 Git snapshot。
+Verify 必须使用与入选 Synthesize 作者不同的 Role。只有逐条验收证据完整时才能得到
+`passed` 并由 Resolve 接受 Candidate；显式 gap 只能形成 `next-round`，再通过有界的
+Resolve `retry` 继续。票数和衍生分析可以作为报告上下文，但不能替代直接证据。
+
 每个 Agent binding 只有一套 adapter-specific 权限枚举配置：`default` 遵循
 provider 默认行为；`bypass` 编译 provider 支持的 bypass flag；`configured`
 保留其中显式设置的原生选项。Codex 选项是 `sandbox` 和 `approval`；Claude 选项是

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,