From c3978f369518b1a908fa88f3dcf81825df2c7e69 Mon Sep 17 00:00:00 2001 From: hhyykk <4408344+hhyykk@users.noreply.github.com> Date: Mon, 2 Nov 2026 20:46:37 +0800 Subject: [PATCH] refactor(quota): decide adaptive child admission in TypeScript Adaptive native-child admission now runs as one quota.task_orchestration.admit request owned by quota/adaptive_children.ts. TypeScript decides candidate eligibility, User-dependency exclusion, coordinator election, ordered rejection reasons, primary selection, capacity deferral, first write-scope conflict, child ordering and brief policy, composing the capability and scheduling-overlap owners in process. The standalone scheduling-overlap RPC is retired. Python keeps a transport adapter with the historical Todo, repository, resume and Agent-id codecs and public objective rendering. Frozen admission and quota JSON/Markdown characterization stays byte-identical; per-pair and capability crossings fold into one request, and early exits now cost one. Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com> Signed-off-by: hhyykk <4408344+hhyykk@users.noreply.github.com> --- .../2026-11-02-adaptive-child-admission.md | 102 ++++ ...26-11-02-adaptive-child-admission.zh-CN.md | 81 +++ .../typescript-control-plane-migration-v0.md | 1 + ...script-control-plane-migration-v0.zh-CN.md | 1 + .../control_plane/effect_runtime_handlers.ts | 2 +- .../control_plane/quota/adaptive_children.ts | 223 +++++++ .../control_plane/quota/task_orchestration.py | 2 +- .../quota/task_orchestration_admission.py | 547 ++++-------------- loopx/control_plane/quota/turn_envelope.ts | 4 + loopx/control_plane/todos/summary_lanes.ts | 8 +- .../work_items/task_lease_acquire_decision.ts | 22 +- ...tive_child_admission_characterization.json | 118 ++++ ...aptive_child_admission_characterization.py | 120 ++++ .../adaptive_children.test.ts | 56 ++ .../effect_runtime_handlers.test.ts | 10 +- 15 files changed, 830 insertions(+), 467 deletions(-) create mode 100644 docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.md create mode 100644 docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.zh-CN.md create mode 100644 loopx/control_plane/quota/adaptive_children.ts create mode 100644 tests/control_plane/adaptive_child_admission_characterization.json create mode 100644 tests/control_plane/test_adaptive_child_admission_characterization.py create mode 100644 tests/control_plane_ts/adaptive_children.test.ts diff --git a/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.md b/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.md new file mode 100644 index 0000000000..daf89bba62 --- /dev/null +++ b/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.md @@ -0,0 +1,102 @@ +# Adaptive child admission — 2026-11-02 + +This checkpoint moves the complete adaptive native-child admission decision from +`quota/task_orchestration_admission.py` to `quota/adaptive_children.ts`, next to +the peer orchestration owner. The existing `multi_subagent` capability and its +builtin provider remain unchanged; this is an internal quota owner cutover, +not a new capability, provider, permission or frontend setting. + +One `quota.task_orchestration.admit` request owns candidate eligibility, +User-dependency exclusion, coordinator election, ordered rejection reasons, +primary selection, capacity deferral, first conflicting lane, child ordering, +brief construction and context/execution policy. Capability requirements and +quota scheduling overlap execute through their existing TypeScript owners in +process. The standalone scheduling-overlap RPC is removed. Ordinary lease +matching keeps its folded semantics; Goal allow-scope matching remains +case-sensitive. Todo actionability reuses the summary-lane owner, including +acceptance denial. Election uses the shared Python-compatible JSON codec, +Unicode code-point ordering and an unsigned 64-bit digest prefix via BigInt. + +## Migration receipt + +The immutable characterization fixture was captured and passed on unchanged +`fb16c6cb1` before moving rules. Its 18 cases preserve complete admission JSON, +quota contract/work-lane JSON and Markdown. Instrumentation measures admission +crossings separately from the surrounding quota command: + +| Operation | Before | After | +| --- | ---: | ---: | +| Requirement-free admitted lanes | 0 | 1 | +| Missing-capability case | 3 | 1 | +| Conflict/first-conflict cases | 2 | 1 | +| Empty source or non-coordinator | 0 | 1 | +| Adaptive mode off | 0 | 0 | + +Previously there were P per-pair overlap requests plus M uncached capability +requests; both owners now run in process behind the admission request. The +zero-to-one early-exit cost is intentional: Python keeps no candidate/election +rule merely to avoid that crossing. This does not claim one request for the +whole quota command, lower latency or long-horizon benefit. + +The replaced Python dataclasses, rejection/selection/election composition, +brief/context policy, overlap adapter and admission constants are deleted. +Python retains a transport adapter with historical Todo/repository/resume and +Agent-id codecs, explicit source-vs-display selection and public objective text +rendering. These preserve persisted spellings and public text at the existing +Host boundary; none selects, rejects or orders a lane. Capability wrappers, +peer hashing and projection-repair scope matching retain independent production +callers; they are not admission fallbacks or unused compatibility exports. + +The TypeScript `schedulingWriteScopeAllowed` intentionally duplicates Python `projection_repair.write_scope_allowed`, whose retained production caller `build_boundary_projection_repair_hint` uses it for missing-scope detection and inactive-boundary candidate matching; remove this duplication when that caller migrates to the shared typed scope owner with equivalent behavior validated. + +The adapter exits when the sole production caller in `task_orchestration.py` +and its surrounding should-run transaction consume typed source facts natively. +Then that caller composes `admitAdaptiveChildren` in process and removes the +Python adapter and `quota.task_orchestration.admit` transport registration. +The frozen fixture remains until that caller cutover carries equivalent +complete-output and crossing evidence. + +Product changes total +342/−461 physical lines, net −119. The Python admission +module changes from 490 to 137 lines (+97/−450); its 101-line adapter function +including signature performs only transport/compatibility work. The new typed +owner is 222 lines. Test, fixture and documentation lines are counted separately. + +## Qualification boundary + +The existing dashboard capability workbench and orchestration settings, +Lark/CLI consumers and quota readback retain their contracts; no visual surface +changes. The source-checkout production `quota should-run` entrypoint was +compared against a `git archive HEAD` baseline with a synthetic temporary home, +a fixed clock and adaptive admission enabled. Complete outputs match byte for +byte on File and SQLite, in JSON (35,126 / 35,160 bytes) and Markdown +(8,565 / 8,587 bytes). This qualifies source behavior, not installed adoption. + +The focused Python suite passed 543 tests; the existing focused TypeScript +suite passed 100 with one unrelated PostgreSQL workspace test skipped, and +17 new typed admission tests passed. Typecheck, semantic vocabulary drift +(45/45 independent twins), maintainability ratchet, interface budgets and +integrated File/SQLite canaries passed. The diff-scoped semantic advisory found +no supported new vocabulary carriers; its limited syntax coverage is not proof +of semantic completeness. No budget, smoke anchor or gate is relaxed. + +The bounded refactoring pass shares Todo actionability and extends the existing +glob engine with a case-sensitive mode rather than adding another matcher. +No storage backend, lease persistence, lease authority or PostgreSQL IO changes. +A capability recovery read with `network` available also matches complete +outputs: File JSON/Markdown 31,907/8,478 bytes, SQLite 31,937/8,500 bytes. +The first recovery comparison observed an existing capability-hook mutation: +`local_private_state_mutated` was true for the first base read and false for +the subsequent head read. A base-only repeat reproduced true → false and then +matched head byte for byte. Final comparisons settle that synthetic hook state +before both reads; no expected fixture or product rule was changed. + +The synthetic CLI outputs also preserve a baseline limitation: +`interaction_contract.agent_channel.work_context.complete` is false, with +`selected_todo` / `context_source_unavailable`. All eight JSON observations +(base/head, both providers and capability states) contain that same failure. +Admission and quota-output parity are qualified; fully available selected-work +context delivery is not. This separate readback gap is outside this admission +owner cutover and must not be hidden by a parity success. + +Full CI, installed packaging, cross-host operation and performance remain +unqualified by this slice. diff --git a/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.zh-CN.md b/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.zh-CN.md new file mode 100644 index 0000000000..cd12d16f10 --- /dev/null +++ b/docs/architecture/rfcs/ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.zh-CN.md @@ -0,0 +1,81 @@ +# 自适应子 Agent 准入 — 2026-11-02 + +本检查点将完整的自适应原生子 Agent 准入决策从 +`quota/task_orchestration_admission.py` 移至 peer orchestration owner 旁的 +`quota/adaptive_children.ts`。既有 `multi_subagent` capability 及其 builtin +provider 不变；这是 quota 内部 owner 切换，不新增 capability、provider、权限或前端设置。 + +单次 `quota.task_orchestration.admit` 请求拥有候选资格、User 依赖排除、协调者选举、 +有序拒绝原因、主任务选择、容量延后、首个冲突 lane、子任务排序、brief 构造及 +上下文／执行策略。Capability 要求和 quota 调度重叠复用既有 TypeScript owner， +在进程内执行。独立的调度重叠 RPC 已删除。普通 lease 匹配保持大小写折叠语义， +Goal allow-scope 匹配保持大小写敏感。Todo 可执行性复用 summary-lane owner， +包含 acceptance 拒绝。选举复用兼容 Python 的 JSON codec、Unicode 码点排序， +并通过 BigInt 处理无符号 64 位摘要前缀。 + +## 迁移收据 + +不可变 characterization fixture 在移动规则前，已于未修改的 `fb16c6cb1` 上捕获并通过。 +18 个场景保留完整 admission JSON、quota contract/work-lane JSON 和 Markdown。 +插桩单独测量 admission crossing，不混同外围 quota 命令： + +| 操作 | 之前 | 之后 | +| --- | ---: | ---: | +| 无 capability 要求的已准入 lane | 0 | 1 | +| 缺少 capability 的场景 | 3 | 1 | +| 冲突／首个冲突场景 | 2 | 1 | +| 空源或非协调者 | 0 | 1 | +| 自适应模式关闭 | 0 | 0 | + +此前有 P 次逐对重叠请求及 M 次未缓存 capability 请求；现在两个 owner 都在准入请求内 +同进程执行。提前退出由零次变一次是有意代价：Python 不为省一次 crossing 而保留 +候选／选举规则。这不表示整个 quota 命令只有一次请求，也不声称延迟或长程收益。 + +被替代的 Python dataclass、拒绝／选择／选举组合、brief／上下文策略、重叠 adapter +及准入常量已删除。Python 保留 transport adapter，负责历史 Todo／repository／resume +和 Agent-id codec、显式 source 与 display 选择及公开 objective 文本渲染。 +这些在既有 Host 边界保留持久化拼写和公开文本，不选择、拒绝或排序 lane。 +Capability wrapper、peer hash 及 projection-repair scope 匹配仍有独立生产调用方； +它们不是准入 fallback，也不是无人调用的兼容导出。 + +TypeScript `schedulingWriteScopeAllowed` 有意保留与 Python `projection_repair.write_scope_allowed` 的重复实现，后者仍由生产调用方 `build_boundary_projection_repair_hint` 用于缺失 scope 检测及非活动 boundary 候选匹配；当该调用方迁移至共享 typed scope owner 并验证等价行为后，删除该重复实现。 + +当 `task_orchestration.py` 中唯一生产调用方及其外围 should-run 事务原生消费 typed +源事实后，adapter 退出。届时调用方在进程内组合 `admitAdaptiveChildren`，删除 Python +adapter 及 `quota.task_orchestration.admit` transport 注册。在该调用方切换具有等价的 +完整输出及 crossing 证据之前，保留冻结 fixture。 + +产品改动合计新增 342／删除 461 个物理行，净减 119 行。Python 准入模块由 +490 行降至 137 行（新增 97／删除 450）；包含签名的 101 行 adapter 函数只负责 +transport／兼容工作。新的 typed owner 为 222 行。测试、fixture 与文档行数单独计算。 + +## 资格边界 + +既有 dashboard capability workbench、orchestration 设置、Lark／CLI 消费方及 quota +回读保持原合同；没有视觉表面变化。Source-checkout 生产 `quota should-run` 入口与 +`git archive HEAD` baseline 比较，使用合成临时 home、固定时钟并启用自适应准入。 +File 和 SQLite 的完整 JSON（35,126／35,160 字节）及 Markdown +（8,565／8,587 字节）均逐字节一致。这资格化源码行为，不证明已安装采用。 + +聚焦 Python 套件通过 543 项；既有聚焦 TypeScript 套件通过 100 项，另有一个无关 +PostgreSQL workspace 测试跳过；17 项新 typed 准入测试通过。Typecheck、语义词汇 +漂移（独立 twin 45/45）、maintainability ratchet、interface budget 及 File／SQLite +集成 canary 均通过。Diff-scoped semantic advisory 未发现支持的新词汇 carrier； +其有限语法覆盖不证明语义完整。没有放宽预算、smoke anchor 或 gate。 + +有界重构共享 Todo 可执行性，并为既有 glob 引擎扩展大小写敏感模式，避免再造 matcher。 +没有修改存储 backend、lease 持久化、lease authority 或 PostgreSQL IO。 +在 `network` 可用的 capability 恢复读取中，完整输出也一致：File JSON／Markdown +为 31,907／8,478 字节，SQLite 为 31,937／8,500 字节。首次恢复比较观察到既有 +capability-hook mutation：第一次 base 读取的 `local_private_state_mutated` 为 true， +随后 head 读取为 false。只运行 base 重复读取也复现 true → false，随后逐字节匹配 head。 +最终比较在两次读取前先稳定该合成 hook 状态；没有改动 expected fixture 或产品规则。 + +合成 CLI 输出还保留一项 baseline 限制： +`interaction_contract.agent_channel.work_context.complete` 为 false，带有 +`selected_todo`／`context_source_unavailable`。八份 JSON 观测（base／head、两种 +provider 及两种 capability 状态）都有相同失败。已资格化准入及 quota 输出等价性， +未资格化完全可用的 selected-work context 交付。该独立回读缺口在本次准入 owner +切换范围之外，不能用 parity 成功掩盖。 + +本切片不资格化完整 CI、已安装打包、跨 Host 运行或性能。 diff --git a/docs/architecture/rfcs/typescript-control-plane-migration-v0.md b/docs/architecture/rfcs/typescript-control-plane-migration-v0.md index 0bb0622ea4..b5d40e8513 100644 --- a/docs/architecture/rfcs/typescript-control-plane-migration-v0.md +++ b/docs/architecture/rfcs/typescript-control-plane-migration-v0.md @@ -2843,3 +2843,4 @@ with shared write/read status-phase checks. See the [2026-10-02 checkpoint](ledg - Complete global summary and gate read transactions: [2026-11-02 checkpoint](ledger/typescript-control-plane-migration-v0/2026-11-02-global-manager-reads.md). - Complete global-risk read ownership: [2026-11-02](ledger/typescript-control-plane-migration-v0/2026-11-02-global-risks-read.md). - Complete durable-completion evidence read: [2026-11-02 owner and crossings ledger](ledger/typescript-control-plane-migration-v0/2026-11-02-completion-evidence-read.md). +- Complete adaptive child admission decision: [2026-11-02 checkpoint](ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.md). diff --git a/docs/architecture/rfcs/typescript-control-plane-migration-v0.zh-CN.md b/docs/architecture/rfcs/typescript-control-plane-migration-v0.zh-CN.md index 6a6e54ce0d..170cb866e3 100644 --- a/docs/architecture/rfcs/typescript-control-plane-migration-v0.zh-CN.md +++ b/docs/architecture/rfcs/typescript-control-plane-migration-v0.zh-CN.md @@ -2108,3 +2108,4 @@ SQLite 中位数略升，收益不能外推为全面加速。这只资格化本 - 完整全局摘要与门禁读取事务：[2026-11-02 检查点](ledger/typescript-control-plane-migration-v0/2026-11-02-global-manager-reads.zh-CN.md)。 - 完整全局风险读取所有权：[2026-11-02](ledger/typescript-control-plane-migration-v0/2026-11-02-global-risks-read.zh-CN.md)。 - 完整 durable-completion 证据读取：[2026-11-02 owner 与调用边界记录](ledger/typescript-control-plane-migration-v0/2026-11-02-completion-evidence-read.zh-CN.md)。 +- 完整自适应子 Agent 准入决策：[2026-11-02 检查点](ledger/typescript-control-plane-migration-v0/2026-11-02-adaptive-child-admission.zh-CN.md)。 diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts index b98ba473d4..fe6557e0d8 100644 --- a/loopx/control_plane/effect_runtime_handlers.ts +++ b/loopx/control_plane/effect_runtime_handlers.ts @@ -429,7 +429,7 @@ export function createEffectRuntimeHandlers( lazyHandler(() => import("./coordination/legacy_writer_fence.ts"), ({checkLegacyCoordinationWriteAllowed}) => checkLegacyCoordinationWriteAllowed), ], ["task_lease.write_scopes.overlap", lazyHandler(() => import("./work_items/task_lease_acquire_decision.ts"), ({evaluateTaskLeaseWriteScopesOverlap}) => evaluateTaskLeaseWriteScopesOverlap)], - ["quota.task_orchestration.write_scope_overlap", lazyHandler(() => import("./work_items/task_lease_acquire_decision.ts"), ({evaluateQuotaSchedulingWriteScopesOverlap}) => evaluateQuotaSchedulingWriteScopesOverlap)], + ["quota.task_orchestration.admit", lazyHandler(() => import("./quota/adaptive_children.ts"), ({admitAdaptiveChildren}) => admitAdaptiveChildren)], ["quota.monitor_poll.commit", lazyHandler(() => import("./quota/monitor_poll_commit.ts"), ({evaluateQuotaMonitorPollCommit}) => evaluateQuotaMonitorPollCommit)], ["presentation.global_risks.project", lazyHandler(() => import("./presentation/global_risk_read.ts"), ({projectGlobalRisks}) => projectGlobalRisks)], ["presentation.decision_notice.project", lazyHandler(() => import("./presentation/decision_notice.ts"), ({projectDecisionNotice}) => projectDecisionNotice)], diff --git a/loopx/control_plane/quota/adaptive_children.ts b/loopx/control_plane/quota/adaptive_children.ts new file mode 100644 index 0000000000..1c67c632af --- /dev/null +++ b/loopx/control_plane/quota/adaptive_children.ts @@ -0,0 +1,223 @@ +/** Complete native-child admission; host codecs supply facts, never lane decisions. */ +import { createHash } from "node:crypto"; +import type { JsonObject } from "../effect_program.ts"; +import { requireJsonObject, requireStringArray, requireInteger, requireNonEmptyString } from "../runtime_decode.ts"; +import { authorityUnicodeCompare } from "../coordination/authority_store_codec.ts"; +import { pythonJson } from "../todos/read_codec.ts"; +import { todoIsActionableOpen } from "../todos/summary_lanes.ts"; +import { missingRequiredCapabilities } from "../agents/capability_gate.ts"; +import { + evaluateQuotaSchedulingWriteScopesOverlap, + schedulingWriteScopeAllowed, +} from "../work_items/task_lease_acquire_decision.ts"; +import { QUOTA_GOAL_BOUNDARY_ARTIFACT } from "./turn_envelope.ts"; + +interface Lane { + item: JsonObject; + id: string | null; + domain: string | null; + repository: string | null; + effectiveRepository: string | null; + scopes: string[]; +} +const rows = (value: unknown): JsonObject[] => { + if (!Array.isArray(value)) throw new TypeError("admission rows must be an array"); + return value.map((row) => requireJsonObject(row, "admission row")); +}; +const nullable = (value: unknown): string | null => + value === null ? null : requireNonEmptyString(value, "admission token"); +const sha256 = (value: string) => createHash("sha256").update(value).digest(); +const READ_ONLY_ACTION_KINDS = ["analyze", "compare", "inspect", "review", "test", "validate"]; +const actionable = (item: JsonObject) => + todoIsActionableOpen({ + done: item.done === true, + status: String(item.status), + hasResume: Boolean(item.resume_when), + resumeReady: item.resume_ready === true, + acceptanceBlocked: (item.goal_acceptance_guard as JsonObject | null)?.allowed === false, + }); +const blockedLane = (lane: Lane, reasons: string[]): JsonObject => ({ + todo_id: lane.id, + task_domain: lane.domain, + reason_codes: reasons, +}); + +export function admitAdaptiveChildren(value: unknown): JsonObject | null { + const input = requireJsonObject(value, "adaptive child admission"); + const agent = requireNonEmptyString(input.agent_id, "agent_id"); + const available = requireStringArray(input.available_capabilities, "available_capabilities"); + const goalRepository = nullable(input.goal_repository); + const goalScopes = requireStringArray(input.goal_write_scope, "goal_write_scope"); + const domains = input.allowed_domains === null ? null : requireStringArray(input.allowed_domains, "allowed_domains"); + const maxChildren = requireInteger(input.max_children, "max_children"); + const users = rows(input.user_items); + const lanes: Lane[] = rows(input.items).map((item) => ({ + item, + id: nullable(item.todo_id), + domain: nullable(item.task_domain), + repository: nullable(item.task_repository), + effectiveRepository: nullable(item.task_repository) || goalRepository, + scopes: requireStringArray(item.required_write_scopes, "required_write_scopes"), + })); + const candidates = lanes.filter((lane) => lane.item.done !== true && lane.item.task_class === "advancement_task"); + const dependency = (lane: Lane) => + users.some( + (user) => + user.unblocks_todo_id === lane.item.dependency_todo_id && + user.done !== true && + !["done", "deferred"].includes(String(user.status).toLowerCase()), + ); + const election = candidates.filter((lane) => actionable(lane.item) && !dependency(lane)); + if (election.length < 2) return null; + const claims = new Set( + election.map((lane) => nullable(lane.item.claimed_by)).filter((id): id is string => id !== null), + ); + const assignmentKey = sha256( + pythonJson({ mode: "adaptive", todo_ids: election.map((lane) => lane.id ?? "").sort(authorityUnicodeCompare) }), + ).toString("hex"); + const peers = requireStringArray(input.registered_agents, "registered_agents"); + // Python selected an unsigned 64-bit prefix. Number would round away low bits. + const index = peers.length ? Number(sha256(assignmentKey).readBigUInt64BE(0) % BigInt(peers.length)) : -1; + const coordinator = claims.size === 1 ? [...claims][0] : (peers[index] ?? null); + if (coordinator !== agent) return null; + const owned = candidates.filter((lane) => !lane.item.claimed_by || lane.item.claimed_by === agent); + if (owned.length < 2) return null; + const admitted: Lane[] = []; + const blocked: JsonObject[] = []; + for (const lane of owned) { + const item = lane.item; + const reasons: string[] = []; + if (requireStringArray(item.excluded_agents, "excluded_agents").includes(agent)) + reasons.push("coordinator_excluded"); + if (!actionable(item) || dependency(lane)) reasons.push("dependency_not_ready"); + if (domains !== null && (lane.domain === null || !domains.includes(lane.domain))) + reasons.push("task_domain_not_allowed"); + if ( + missingRequiredCapabilities( + requireStringArray(item.required_capabilities, "required_capabilities"), + requireStringArray(item.target_capabilities, "target_capabilities"), + available, + ).length + ) + reasons.push("capability_unavailable"); + if (item.repository_declared) { + if (!lane.repository) reasons.push("task_repository_invalid"); + else if (!goalRepository || lane.repository !== goalRepository) reasons.push("task_repository_not_allowed"); + } + const action = String(item.action_kind ?? "").toLowerCase(); + if ( + !READ_ONLY_ACTION_KINDS.some((prefix) => action === prefix || action.startsWith(`${prefix}_`)) && + !lane.scopes.length + ) + reasons.push("write_scope_missing"); + if ( + lane.scopes.length && + (!goalScopes.length || lane.scopes.some((scope) => !schedulingWriteScopeAllowed(scope, goalScopes))) + ) + reasons.push("write_scope_not_allowed"); + if (reasons.length) blocked.push(blockedLane(lane, reasons)); + else admitted.push(lane); + } + if (admitted.length < 2) return null; + const primary = admitted[0]; + const selected: JsonObject[] = []; + const writeLanes = [primary]; + for (let index = 1; index < admitted.length; index += 1) { + const lane = admitted[index]; + if (selected.length >= maxChildren) { + blocked.push(...admitted.slice(index).map((row) => blockedLane(row, ["capacity_deferred"]))); + break; + } + const conflict = writeLanes.find( + (existing) => + existing.scopes.length && + lane.scopes.length && + existing.effectiveRepository === lane.effectiveRepository && + evaluateQuotaSchedulingWriteScopesOverlap({ left: existing.scopes, right: lane.scopes }).overlap, + ); + if (conflict) { + blocked.push({ ...blockedLane(lane, ["write_scope_conflict"]), conflicts_with_todo_id: conflict.id }); + continue; + } + const item = lane.item; + const brief: JsonObject = { + todo_id: lane.id, + objective: item.objective ?? null, + action_kind: item.action_kind, + task_domain: lane.domain, + required_capabilities: item.required_capabilities, + task_repository: lane.repository, + required_write_scopes: lane.scopes, + workspace_isolation: lane.scopes.length ? "independent_git_worktree" : "not_required", + continuation_policy: item.continuation_policy, + target_key: item.target_key, + }; + if ( + item.validation_command != null || + item.validation_command_argv != null || + item.completion_validation_required === true + ) { + brief.validation_declared = true; + brief.validation_label = item.validation_label; + } + selected.push({ + todo_id: lane.id, + task_domain: lane.domain, + execution_kind: "ephemeral_child", + child_brief: brief, + }); + writeLanes.push(lane); + } + if (!selected.length) return null; + return { + schema_version: "task_orchestration_contract_v2", + mode: "adaptive", + coordinator_agent_id: coordinator, + assignment_key: assignmentKey, + activation_required: false, + activation_allowed: true, + strategy_owner: "task_coordinator", + max_children: maxChildren, + primary_todo_id: primary.id, + child_brief_defaults: childBriefDefaults(input.parent_goal_id ?? null, available), + eligible_child_lanes: selected, + blocked_lanes: blocked, + writeback_owner: "task_coordinator", + coordinator_obligation: + "choose whether admitted child lanes shorten the critical path; review returned evidence, " + + "then write accepted state/todos and spend once", + }; +} + +function childBriefDefaults(parentGoalId: JsonObject[string], available: string[]): JsonObject { + return { + schema_version: "subagent_control_plane_handoff_v0", + parent_goal_id: parentGoalId, + authority_artifact: QUOTA_GOAL_BOUNDARY_ARTIFACT, + latest_state_ref: "quota_should_run.action_signature.source_hash", + quota_gate_snapshot: "admitted_by_task_orchestration_contract", + context_policy: { + selection_owner: "task_coordinator", + default: "fresh", + allowed: [ + "fresh", + ...(available.includes("subagent_context_fork") ? ["forked_snapshot"] : []), + ...(available.includes("subagent_resume") ? ["resume"] : []), + ], + }, + expected_output: "public_safe_evidence", + execution_policy: { + timeout: "bounded_by_host_turn", + cancel: "task_coordinator_or_host_timeout", + }, + child_guard_policy: "prevention_first_v0", + validation_policy: "child reports evidence; parent runs declared todo gate", + acceptance: [ + "report completed scope and evidence", + "report validation result and residual risk", + "do not write LoopX state or spend quota", + ], + writeback_spend_contract: + "child reports evidence only; task coordinator accepts evidence, writes state, and spends once", + }; +} diff --git a/loopx/control_plane/quota/task_orchestration.py b/loopx/control_plane/quota/task_orchestration.py index 909e0b2a46..551083a4e3 100644 --- a/loopx/control_plane/quota/task_orchestration.py +++ b/loopx/control_plane/quota/task_orchestration.py @@ -14,7 +14,6 @@ from ..work_items.work_lane_context import build_work_lane_context_contract from .recent_runs import latest_unchanged_monitor_observation from .task_orchestration_admission import ( - SUBAGENT_SPAWN_CAPABILITY, build_adaptive_task_orchestration_contract, ) @@ -23,6 +22,7 @@ AgentScopeFrontierAction.AGENT_SCOPE_WAIT.value, AgentScopeFrontierAction.REASSIGNMENT_REQUIRED.value, } +SUBAGENT_SPAWN_CAPABILITY = "subagent_spawn" PEER_AGENT_ACTIVATION_CAPABILITY = "peer_agent_activation" PEER_COORDINATION_BLOCKED_ACTION = EffectiveAction.PEER_COORDINATION_BLOCKED.value diff --git a/loopx/control_plane/quota/task_orchestration_admission.py b/loopx/control_plane/quota/task_orchestration_admission.py index ead80c932a..e87a6de90f 100644 --- a/loopx/control_plane/quota/task_orchestration_admission.py +++ b/loopx/control_plane/quota/task_orchestration_admission.py @@ -1,59 +1,37 @@ from __future__ import annotations -from dataclasses import dataclass from typing import Any -from ..agents.capability_gate import missing_required_capabilities -from ..agents.runtime_model import peer_work_key, select_peer_for_work +from ..agents.runtime_model import normalized_peer_agent_ids from ..effect_runtime import effect_runtime_result from ..todos.contract import ( normalize_required_capabilities, normalize_required_write_scopes, + normalize_target_capabilities, normalize_todo_claimed_by, normalize_todo_excluded_agents, + normalize_todo_resume_when, + normalize_todo_status, normalize_todo_task_domain, normalize_todo_task_repository, ) -from ..todos.todo_semantics import todo_item_is_actionable_open from ..work_items.primary_action import protocol_action_text -from .projection_repair import write_scope_allowed -SUBAGENT_SPAWN_CAPABILITY = "subagent_spawn" -SUBAGENT_CONTEXT_FORK_CAPABILITY = "subagent_context_fork" -SUBAGENT_RESUME_CAPABILITY = "subagent_resume" -READ_ONLY_ACTION_KINDS = frozenset( - { - "analyze", - "compare", - "inspect", - "review", - "test", - "validate", - } -) - - -@dataclass(frozen=True) -class _NormalizedAdmissionLane: - item: dict[str, Any] - todo_id: str | None - task_domain: str | None - task_repository: str | None - effective_repository: str | None - repository_declared: bool - required_write_scopes: tuple[str, ...] - action_kind: str +def _source_items(items: Any, summary: Any) -> list[dict[str, Any]]: + if items is not None: + values = items + elif isinstance(summary, dict): + values = summary.get("items", []) + else: + values = [] + if not isinstance(values, list): + return [] + return [item for item in values if isinstance(item, dict)] -@dataclass(frozen=True) -class _NormalizedAdmissionInput: - lanes: tuple[_NormalizedAdmissionLane, ...] - user_items: tuple[dict[str, Any], ...] - allowed_domains: frozenset[str] | None - available_capabilities: tuple[str, ...] - goal_write_scope: tuple[str, ...] - goal_repository: str | None +def _optional_text(value: Any) -> str | None: + return str(value or "").strip() or None def build_adaptive_task_orchestration_contract( @@ -70,421 +48,90 @@ def build_adaptive_task_orchestration_contract( parent_goal_id: str | None, max_children: int, ) -> dict[str, Any] | None: - admission = _normalize_admission_input( - goal_boundary=goal_boundary, - orchestration=orchestration, - raw_agent_todo_summary=raw_agent_todo_summary, - raw_user_todo_summary=raw_user_todo_summary, - agent_todo_source_items=agent_todo_source_items, - user_todo_source_items=user_todo_source_items, - available_capabilities=available_capabilities, - ) - global_candidates = [ - lane for lane in admission.lanes if _is_adaptive_candidate(lane.item) - ] - election_candidates = [ - lane - for lane in global_candidates - if todo_item_is_actionable_open(lane.item) - and not _has_open_dependency( - lane.item, - user_items=admission.user_items, + items = [] + for item in _source_items(agent_todo_source_items, raw_agent_todo_summary): + items.append( + { + **{ + key: item.get(key) + for key in ( + "done", + "resume_ready", + "goal_acceptance_guard", + "validation_command", + "validation_command_argv", + "completion_validation_required", + ) + }, + **{ + key: _optional_text(item.get(key)) + for key in ( + "todo_id", + "action_kind", + "continuation_policy", + "target_key", + "validation_label", + ) + }, + "dependency_todo_id": str(item.get("todo_id") or ""), + "task_class": str(item.get("task_class") or ""), + "status": normalize_todo_status(item.get("status")) or "open", + "resume_when": normalize_todo_resume_when(item.get("resume_when")), + "claimed_by": normalize_todo_claimed_by(item.get("claimed_by")), + "excluded_agents": normalize_todo_excluded_agents( + item.get("excluded_agents") + ), + "task_domain": normalize_todo_task_domain(item.get("task_domain")), + "task_repository": normalize_todo_task_repository( + item.get("task_repository") + ), + "repository_declared": bool(item.get("task_repository")), + "required_write_scopes": normalize_required_write_scopes( + item.get("required_write_scopes") + ), + "required_capabilities": normalize_required_capabilities( + item.get("required_capabilities") + ), + "target_capabilities": normalize_target_capabilities( + item.get("target_capabilities") + ), + "objective": protocol_action_text( + item.get("title") or item.get("text"), limit=180 + ), + } ) - ] - if len(election_candidates) < 2: - return None - claimed_owners = { - claimed_by - for lane in election_candidates - for claimed_by in [normalize_todo_claimed_by(lane.item.get("claimed_by"))] - if claimed_by - } - assignment_key = peer_work_key( + raw_domains = orchestration.get("allowed_domains") + allowed_domains = None + if isinstance(raw_domains, list) and raw_domains: + normalized_domains = [ + normalize_todo_task_domain(value) for value in raw_domains + ] + allowed_domains = [domain for domain in normalized_domains if domain] + return effect_runtime_result( + "quota.task_orchestration.admit", { - "mode": "adaptive", - "todo_ids": sorted(lane.todo_id or "" for lane in election_candidates), - }, - fallback="adaptive_task_orchestration", - ) - coordinator = ( - next(iter(claimed_owners)) - if len(claimed_owners) == 1 - else select_peer_for_work( - agent_identity.get("registered_agents") or [agent_id], - work_key=assignment_key, - ) - ) - if coordinator != agent_id: - return None - candidates = [ - lane - for lane in global_candidates - if _candidate_owned_by_coordinator(lane.item, agent_id=agent_id) - ] - if len(candidates) < 2: - return None - - admitted: list[_NormalizedAdmissionLane] = [] - blocked: list[dict[str, Any]] = [] - for lane in candidates: - reason_codes = _block_reasons( - lane, - agent_id=agent_id, - admission=admission, - ) - if reason_codes: - blocked.append(_blocked_lane(lane, reason_codes=reason_codes)) - continue - admitted.append(lane) - if len(admitted) < 2: - return None - - primary = admitted[0] - child_brief_defaults = _child_brief_defaults( - parent_goal_id=parent_goal_id, - available_capabilities=available_capabilities, - ) - selected_children: list[dict[str, Any]] = [] - admitted_write_lanes = [primary] - for item_index, lane in enumerate(admitted[1:]): - if len(selected_children) >= max_children: - blocked.extend( - _blocked_lane( - deferred_lane, - reason_codes=["capacity_deferred"], - ) - for deferred_lane in admitted[item_index + 1 :] - ) - break - conflict = next( - ( - existing - for existing in admitted_write_lanes - if _write_scopes_conflict(existing, lane) - ), - None, - ) - if conflict is not None: - blocked.append( + "agent_id": agent_id, + "items": items, + "user_items": [ { - **_blocked_lane( - lane, - reason_codes=["write_scope_conflict"], - ), - "conflicts_with_todo_id": conflict.todo_id, + "unblocks_todo_id": str(item.get("unblocks_todo_id") or ""), + "done": item.get("done"), + "status": str(item.get("status") or "open"), } - ) - continue - selected_children.append(_eligible_child_lane(lane)) - admitted_write_lanes.append(lane) - if not selected_children: - return None - return { - "schema_version": "task_orchestration_contract_v2", - "mode": "adaptive", - "coordinator_agent_id": coordinator, - "assignment_key": assignment_key, - "activation_required": False, - "activation_allowed": True, - "strategy_owner": "task_coordinator", - "max_children": max_children, - "primary_todo_id": primary.todo_id, - "child_brief_defaults": child_brief_defaults, - "eligible_child_lanes": selected_children, - "blocked_lanes": blocked, - "writeback_owner": "task_coordinator", - "coordinator_obligation": ( - "choose whether admitted child lanes shorten the critical path; " - "review returned evidence, then write accepted state/todos and spend once" - ), - } - - -def _summary_items(summary: dict[str, Any] | None) -> list[dict[str, Any]]: - if not isinstance(summary, dict) or not isinstance(summary.get("items"), list): - return [] - return [item for item in summary["items"] if isinstance(item, dict)] - - -def _authoritative_items( - source_items: list[dict[str, Any]] | None, - summary: dict[str, Any] | None, -) -> list[dict[str, Any]]: - if source_items is not None: - return [item for item in source_items if isinstance(item, dict)] - return _summary_items(summary) - - -def _normalize_allowed_domains(orchestration: dict[str, Any]) -> frozenset[str] | None: - raw_domains = orchestration.get("allowed_domains") - if not isinstance(raw_domains, list) or not raw_domains: - return None - return frozenset( - domain - for value in raw_domains - for domain in [normalize_todo_task_domain(value)] - if domain - ) - - -def _normalize_admission_lane( - item: dict[str, Any], - *, - goal_repository: str | None, -) -> _NormalizedAdmissionLane: - task_repository = normalize_todo_task_repository(item.get("task_repository")) - return _NormalizedAdmissionLane( - item=item, - todo_id=str(item.get("todo_id") or "").strip() or None, - task_domain=normalize_todo_task_domain(item.get("task_domain")), - task_repository=task_repository, - effective_repository=task_repository or goal_repository, - repository_declared=bool(item.get("task_repository")), - required_write_scopes=tuple( - normalize_required_write_scopes(item.get("required_write_scopes")) - ), - action_kind=str(item.get("action_kind") or "").strip().lower(), - ) - - -def _normalize_admission_input( - *, - goal_boundary: dict[str, Any], - orchestration: dict[str, Any], - raw_agent_todo_summary: dict[str, Any] | None, - raw_user_todo_summary: dict[str, Any] | None, - agent_todo_source_items: list[dict[str, Any]] | None, - user_todo_source_items: list[dict[str, Any]] | None, - available_capabilities: list[str], -) -> _NormalizedAdmissionInput: - goal_repository = normalize_todo_task_repository( - goal_boundary.get("task_repository") - ) - return _NormalizedAdmissionInput( - lanes=tuple( - _normalize_admission_lane(item, goal_repository=goal_repository) - for item in _authoritative_items( - agent_todo_source_items, - raw_agent_todo_summary, - ) - ), - user_items=tuple( - _authoritative_items( - user_todo_source_items, - raw_user_todo_summary, - ) - ), - allowed_domains=_normalize_allowed_domains(orchestration), - available_capabilities=tuple(available_capabilities), - goal_write_scope=tuple( - normalize_required_write_scopes(goal_boundary.get("write_scope")) - ), - goal_repository=goal_repository, - ) - - -def _candidate_owned_by_coordinator( - item: dict[str, Any], - *, - agent_id: str, -) -> bool: - if item.get("done") is True: - return False - if str(item.get("task_class") or "") != "advancement_task": - return False - claimed_by = normalize_todo_claimed_by(item.get("claimed_by")) - return not claimed_by or claimed_by == agent_id - - -def _is_adaptive_candidate(item: dict[str, Any]) -> bool: - return bool( - item.get("done") is not True - and str(item.get("task_class") or "") == "advancement_task" - ) - - -def _block_reasons( - lane: _NormalizedAdmissionLane, - *, - agent_id: str, - admission: _NormalizedAdmissionInput, -) -> list[str]: - item = lane.item - reasons: list[str] = [] - if agent_id in normalize_todo_excluded_agents(item.get("excluded_agents")): - reasons.append("coordinator_excluded") - if not todo_item_is_actionable_open(item) or _has_open_dependency( - item, - user_items=admission.user_items, - ): - reasons.append("dependency_not_ready") - if ( - admission.allowed_domains is not None - and lane.task_domain not in admission.allowed_domains - ): - reasons.append("task_domain_not_allowed") - if missing_required_capabilities( - item, - available_capabilities=list(admission.available_capabilities), - ): - reasons.append("capability_unavailable") - if lane.repository_declared: - if not lane.task_repository: - reasons.append("task_repository_invalid") - elif ( - not admission.goal_repository - or lane.task_repository != admission.goal_repository - ): - reasons.append("task_repository_not_allowed") - if ( - _action_requires_write_scope(lane.action_kind) - and not lane.required_write_scopes - ): - reasons.append("write_scope_missing") - if lane.required_write_scopes and ( - not admission.goal_write_scope - or any( - not write_scope_allowed(scope, list(admission.goal_write_scope)) - for scope in lane.required_write_scopes - ) - ): - reasons.append("write_scope_not_allowed") - return reasons - - -def _action_requires_write_scope(action_kind: str) -> bool: - return not any( - action_kind == prefix or action_kind.startswith(f"{prefix}_") - for prefix in READ_ONLY_ACTION_KINDS - ) - - -def _has_open_dependency( - item: dict[str, Any], - *, - user_items: tuple[dict[str, Any], ...], -) -> bool: - todo_id = str(item.get("todo_id") or "") - return any( - str(user_item.get("unblocks_todo_id") or "") == todo_id - and user_item.get("done") is not True - and str(user_item.get("status") or "open").lower() not in {"done", "deferred"} - for user_item in user_items - ) - - -def _blocked_lane( - lane: _NormalizedAdmissionLane, - *, - reason_codes: list[str], -) -> dict[str, Any]: - return { - "todo_id": lane.todo_id, - "task_domain": lane.task_domain, - "reason_codes": reason_codes, - } - - -def _child_brief_defaults( - *, - parent_goal_id: str | None, - available_capabilities: list[str], -) -> dict[str, Any]: - allowed_contexts = ["fresh"] - if SUBAGENT_CONTEXT_FORK_CAPABILITY in available_capabilities: - allowed_contexts.append("forked_snapshot") - if SUBAGENT_RESUME_CAPABILITY in available_capabilities: - allowed_contexts.append("resume") - return { - "schema_version": "subagent_control_plane_handoff_v0", - "parent_goal_id": parent_goal_id, - "authority_artifact": "quota_should_run.goal_boundary", - "latest_state_ref": "quota_should_run.action_signature.source_hash", - "quota_gate_snapshot": "admitted_by_task_orchestration_contract", - "context_policy": { - "selection_owner": "task_coordinator", - "default": "fresh", - "allowed": allowed_contexts, - }, - "expected_output": "public_safe_evidence", - "execution_policy": { - "timeout": "bounded_by_host_turn", - "cancel": "task_coordinator_or_host_timeout", - }, - "child_guard_policy": "prevention_first_v0", - "validation_policy": "child reports evidence; parent runs declared todo gate", - "acceptance": [ - "report completed scope and evidence", - "report validation result and residual risk", - "do not write LoopX state or spend quota", - ], - "writeback_spend_contract": ( - "child reports evidence only; task coordinator accepts evidence, " - "writes state, and spends once" - ), - } - - -def _eligible_child_lane(lane: _NormalizedAdmissionLane) -> dict[str, Any]: - item = lane.item - required_capabilities = normalize_required_capabilities( - item.get("required_capabilities") - ) - required_write_scopes = list(lane.required_write_scopes) - validation_declared = bool( - item.get("validation_command") is not None - or item.get("validation_command_argv") is not None - or item.get("completion_validation_required") is True - ) - child_brief: dict[str, Any] = { - "todo_id": lane.todo_id, - "objective": protocol_action_text( - item.get("title") or item.get("text"), - limit=180, - ), - "action_kind": str(item.get("action_kind") or "").strip() or None, - "task_domain": lane.task_domain, - "required_capabilities": required_capabilities, - "task_repository": lane.task_repository, - "required_write_scopes": required_write_scopes, - "workspace_isolation": ( - "independent_git_worktree" if required_write_scopes else "not_required" - ), - "continuation_policy": ( - str(item.get("continuation_policy") or "").strip() or None - ), - "target_key": str(item.get("target_key") or "").strip() or None, - } - if validation_declared: - child_brief["validation_declared"] = True - child_brief["validation_label"] = ( - str(item.get("validation_label") or "").strip() or None - ) - return { - "todo_id": child_brief["todo_id"], - "task_domain": lane.task_domain, - "execution_kind": "ephemeral_child", - "child_brief": child_brief, - } - - -def _write_scopes_conflict( - left: _NormalizedAdmissionLane, - right: _NormalizedAdmissionLane, -) -> bool: - """Consume the scheduling overlap decision owned by the canonical lease module.""" - - if not left.required_write_scopes or not right.required_write_scopes: - return False - if left.effective_repository != right.effective_repository: - return False - decision = effect_runtime_result( - "quota.task_orchestration.write_scope_overlap", - { - "left": list(left.required_write_scopes), - "right": list(right.required_write_scopes), + for item in _source_items(user_todo_source_items, raw_user_todo_summary) + ], + "registered_agents": normalized_peer_agent_ids( + agent_identity.get("registered_agents") or [agent_id] + ), + "goal_repository": normalize_todo_task_repository( + goal_boundary.get("task_repository") + ), + "goal_write_scope": normalize_required_write_scopes( + goal_boundary.get("write_scope") + ), + "allowed_domains": allowed_domains, + "available_capabilities": available_capabilities, + "parent_goal_id": parent_goal_id, + "max_children": int(max_children), }, ) - if not isinstance(decision, dict) or not isinstance(decision.get("overlap"), bool): - raise RuntimeError("quota scheduling write-scope decision shape mismatch") - return bool(decision["overlap"]) diff --git a/loopx/control_plane/quota/turn_envelope.ts b/loopx/control_plane/quota/turn_envelope.ts index fb33dc3526..b0c94fd52a 100644 --- a/loopx/control_plane/quota/turn_envelope.ts +++ b/loopx/control_plane/quota/turn_envelope.ts @@ -32,6 +32,10 @@ export const ACTION_SIGNATURE_COVERAGE_V1 = "turn_envelope_action_dimensions_v1" export const ACTION_SIGNATURE_COVERAGE_V2 = "turn_envelope_action_dimensions_v2"; export const ACTION_SIGNATURE_COVERAGE_V3 = "turn_envelope_action_dimensions_v3"; +// Single owner for the should-run artifact path a child brief points at, so the +// legacy field token stays inside this module's retirement budget. +export const QUOTA_GOAL_BOUNDARY_ARTIFACT = "quota_should_run.goal_boundary"; + export const SCHEDULER_QUOTA_IDENTITY_KEYS = ["goal_id", "agent_identity.agent_id", "effective_action", "heartbeat_recommendation.recommended_mode", "interaction_contract.mode"]; export function schedulerQuotaContext(payload: JsonObject) { diff --git a/loopx/control_plane/todos/summary_lanes.ts b/loopx/control_plane/todos/summary_lanes.ts index fa6ba9d3ee..36fd067607 100644 --- a/loopx/control_plane/todos/summary_lanes.ts +++ b/loopx/control_plane/todos/summary_lanes.ts @@ -45,6 +45,11 @@ export function monitorIsDue(row: MonitorSchedule, now: number): boolean { export function monitorHasScheduleGap(row: MonitorSchedule, now: number): boolean { return monitorIsActive(row, now) && !row.watchOnly && row.dueAt === null; } +export function todoIsActionableOpen(row: {done: boolean; status: string; hasResume: boolean; + resumeReady: boolean; acceptanceBlocked: boolean}): boolean { + return !row.done && row.status === "open" && (!row.hasResume || row.resumeReady) && !row.acceptanceBlocked; +} + function decodeRow(value: unknown, ordinal: number): Row { const row = requireJsonObject(value, `rows[${ordinal}]`); const status = requireStringLiteral(row.status, ["open", "blocked", "done", "deferred"], "status"); @@ -60,7 +65,8 @@ function decodeRow(value: unknown, ordinal: number): Row { throw new EffectRuntimeRequestError("Todo presentation sort coordinate is invalid"); } return {ordinal, status, done, taskClass: requireStringLiteral(row.task_class, TASK_CLASSES, "task_class"), - actionable: status === "open" && (!hasResume || ready) && !requireBoolean(row.acceptance_blocked, "acceptance_blocked"), + actionable: todoIsActionableOpen({done, status, hasResume, resumeReady: ready, + acceptanceBlocked: requireBoolean(row.acceptance_blocked, "acceptance_blocked")}), claim: requireBoolean(row.claimed, "claimed"), resumeBlocked: hasResume && row.resume_ready === false, preferred: requireBoolean(row.preferred, "preferred"), ...decodeMonitorSchedule(row), sort: [finite(sort[0], "priority"), finite(sort[1], "index"), sort[2], sort[3]]}; diff --git a/loopx/control_plane/work_items/task_lease_acquire_decision.ts b/loopx/control_plane/work_items/task_lease_acquire_decision.ts index efef8e8f50..cf0c0795f9 100644 --- a/loopx/control_plane/work_items/task_lease_acquire_decision.ts +++ b/loopx/control_plane/work_items/task_lease_acquire_decision.ts @@ -182,12 +182,12 @@ type GlobToken = | {kind: "question"} | {kind: "class"; body: string; negated: boolean}; -function globTokens(pattern: string): GlobToken[] { +function globTokens(pattern: string, fold = true): GlobToken[] { const tokens: GlobToken[] = []; let literal = ""; const flushLiteral = () => { if (literal.length === 0) return; - tokens.push({kind: "literal", folded: caseFold(literal)}); + tokens.push({kind: "literal", folded: fold ? caseFold(literal) : literal}); literal = ""; }; for (let index = 0; index < pattern.length; index += 1) { @@ -372,9 +372,9 @@ function classHasMatch(body: string, negated: boolean): boolean { * No multi-symbol character fold crosses that slash, so the existing character * transitions also decide prefix reachability without splitting a folded atom. */ -function fnmatchcase(value: string, pattern: string, descendants = false): boolean { - const symbols = [...caseFold(value)]; - const tokens = globTokens(pattern); +function fnmatchcase(value: string, pattern: string, descendants = false, fold = true): boolean { + const symbols = [...(fold ? caseFold(value) : value)]; + const tokens = globTokens(pattern, fold); const suffixPossible: boolean[] = []; if (descendants) { suffixPossible[tokens.length] = true; @@ -402,12 +402,13 @@ function fnmatchcase(value: string, pattern: string, descendants = false): boole } else if (valueIndex === symbols.length) { result = false; } else if (token.kind === "question") { - result = singleCharacterMatchLengths(symbols, valueIndex) + result = (fold ? singleCharacterMatchLengths(symbols, valueIndex) : [1]) .some((length) => match(valueIndex + length, tokenIndex + 1)); } else if (token.kind === "class") { - const lengths = classMatchLengths(token.body, symbols, valueIndex); + const lengths = fold ? classMatchLengths(token.body, symbols, valueIndex) + : classContains(characterClass(token.body), symbols[valueIndex]) ? [1] : []; result = token.negated - ? singleCharacterMatchLengths(symbols, valueIndex).some((length) => + ? (fold ? singleCharacterMatchLengths(symbols, valueIndex) : [1]).some((length) => !lengths.includes(length) && match(valueIndex + length, tokenIndex + 1)) : lengths.some((length) => match(valueIndex + length, tokenIndex + 1)); } else { @@ -785,3 +786,8 @@ export function materializeTaskLeaseAcquire(identity: {goal_id: string; todo_id: expires_at: new Date(now.valueOf() + command.ttl_seconds * 1000).toISOString().replace(/\.\d{3}Z$/u, "Z"), status: "active"}; } + +/** Goal allow scopes use case-sensitive fnmatch, unlike folded lease overlap. */ +export function schedulingWriteScopeAllowed(required: string, allowed: readonly string[]): boolean { + return !required || allowed.some(pattern => pattern === required || fnmatchcase(required, pattern, false, false)); +} diff --git a/tests/control_plane/adaptive_child_admission_characterization.json b/tests/control_plane/adaptive_child_admission_characterization.json new file mode 100644 index 0000000000..576b41111d --- /dev/null +++ b/tests/control_plane/adaptive_child_admission_characterization.json @@ -0,0 +1,118 @@ +{ + "unclaimed": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=0 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "claimed": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"0acfbe7f22586bf68ab7ee22d4607a20c99da71e37056e6097b6cf05f6681c25\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"0acfbe7f22586bf68ab7ee22d4607a20c99da71e37056e6097b6cf05f6681c25\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=0 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "excluded_and_ordered_reasons": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_blocked\",\"task_domain\":\"research\",\"reason_codes\":[\"coordinator_excluded\",\"dependency_not_ready\",\"task_domain_not_allowed\",\"capability_unavailable\",\"task_repository_not_allowed\",\"write_scope_missing\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_blocked\",\"task_domain\":\"research\",\"reason_codes\":[\"coordinator_excluded\",\"dependency_not_ready\",\"task_domain_not_allowed\",\"capability_unavailable\",\"task_repository_not_allowed\",\"write_scope_missing\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: capability_unavailable, coordinator_excluded, dependency_not_ready, task_domain_not_allowed, task_repository_not_allowed, write_scope_missing\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": { + "agent.capability_gate.evaluate": 1 + } + }, + "user_dependency": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_waiting\",\"task_domain\":\"code\",\"reason_codes\":[\"dependency_not_ready\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_waiting\",\"task_domain\":\"code\",\"reason_codes\":[\"dependency_not_ready\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: dependency_not_ready\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "mixed_repository": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"5964be9e11f30b4982b902512d34850c81ae606b77fc61fb1e228d9915385370\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_other\",\"task_domain\":\"code\",\"reason_codes\":[\"task_repository_not_allowed\"]},{\"todo_id\":\"todo_invalid\",\"task_domain\":\"code\",\"reason_codes\":[\"task_repository_invalid\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"5964be9e11f30b4982b902512d34850c81ae606b77fc61fb1e228d9915385370\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_other\",\"task_domain\":\"code\",\"reason_codes\":[\"task_repository_not_allowed\"]},{\"todo_id\":\"todo_invalid\",\"task_domain\":\"code\",\"reason_codes\":[\"task_repository_invalid\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=2 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: task_repository_invalid, task_repository_not_allowed\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "empty_write_scope": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"647276c7807064b09235dcdf3a4c16099ce0ca15fa2c836fb53799c6c59d50bc\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_writer\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_missing\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"647276c7807064b09235dcdf3a4c16099ce0ca15fa2c836fb53799c6c59d50bc\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_writer\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_missing\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: write_scope_missing\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "scope_conflicts_capacity": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"f6db8a86012bc876c639625a88b608eab16d19204da3adda941c49de913e6c6a\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":1,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[\"tests/**\"],\"workspace_isolation\":\"independent_git_worktree\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_glob\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_conflict\"],\"conflicts_with_todo_id\":\"todo_primary\"},{\"todo_id\":\"todo_docs\",\"task_domain\":\"code\",\"reason_codes\":[\"capacity_deferred\"]},{\"todo_id\":\"todo_overflow\",\"task_domain\":\"code\",\"reason_codes\":[\"capacity_deferred\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"f6db8a86012bc876c639625a88b608eab16d19204da3adda941c49de913e6c6a\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":1,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[\"tests/**\"],\"workspace_isolation\":\"independent_git_worktree\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_glob\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_conflict\"],\"conflicts_with_todo_id\":\"todo_primary\"},{\"todo_id\":\"todo_docs\",\"task_domain\":\"code\",\"reason_codes\":[\"capacity_deferred\"]},{\"todo_id\":\"todo_overflow\",\"task_domain\":\"code\",\"reason_codes\":[\"capacity_deferred\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=3 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: capacity_deferred, write_scope_conflict\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": { + "quota.task_orchestration.write_scope_overlap": 2 + } + }, + "first_conflict": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"06dc7351754663890b279c0df86637b3659906a8793c919f1fe310dd8ee94f51\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[\"src/b/**\"],\"workspace_isolation\":\"independent_git_worktree\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_both\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_conflict\"],\"conflicts_with_todo_id\":\"todo_primary\"}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"06dc7351754663890b279c0df86637b3659906a8793c919f1fe310dd8ee94f51\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[\"src/b/**\"],\"workspace_isolation\":\"independent_git_worktree\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_both\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_conflict\"],\"conflicts_with_todo_id\":\"todo_primary\"}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: write_scope_conflict\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": { + "quota.task_orchestration.write_scope_overlap": 2 + } + }, + "case_sensitive_scope": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"0cc767ce66ceb2dcf85117f554b4a10fc5d73f6004d7aa152aafc011b2f5b00c\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_case\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_not_allowed\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"0cc767ce66ceb2dcf85117f554b4a10fc5d73f6004d7aa152aafc011b2f5b00c\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_case\",\"task_domain\":\"code\",\"reason_codes\":[\"write_scope_not_allowed\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: write_scope_not_allowed\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "missing_capabilities": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"281ae88a37e4226dabffed401ecf679fd68ddb7abef15f2587293db67456101e\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[\"network\"],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_blocked\",\"task_domain\":\"code\",\"reason_codes\":[\"capability_unavailable\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"281ae88a37e4226dabffed401ecf679fd68ddb7abef15f2587293db67456101e\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[\"network\"],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_blocked\",\"task_domain\":\"code\",\"reason_codes\":[\"capability_unavailable\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: capability_unavailable\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": { + "agent.capability_gate.evaluate": 3 + } + }, + "brief": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"\\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b...\",\"action_kind\":\"inspect_detail\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":\"bounded\",\"target_key\":\"sample\",\"validation_declared\":true,\"validation_label\":\"synthetic check\"}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"\\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b \\ud83d\\ude00 \\u793a\\u4f8b...\",\"action_kind\":\"inspect_detail\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":\"bounded\",\"target_key\":\"sample\",\"validation_declared\":true,\"validation_label\":\"synthetic check\"}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=0 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "acceptance_guard": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_guarded\",\"task_domain\":\"code\",\"reason_codes\":[\"dependency_not_ready\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[{\"todo_id\":\"todo_guarded\",\"task_domain\":\"code\",\"reason_codes\":[\"dependency_not_ready\"]}],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=1 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- task_orchestration_blockers: dependency_not_ready\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "empty_canonical": { + "admission_json": "null", + "quota_fields_json": "{\"task_orchestration_contract\":null,\"work_lane_contract\":{\"lane\":\"advancement_task\"}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- work_lane_contract: lane=advancement_task next=None obligation=None must_attempt_work=None", + "crossings": {} + }, + "empty_user_canonical": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"56997385b957b3b2b00efc69a4ae6c733247584f156508908e0c48898c076a40\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_primary\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_child\",\"objective\":\"Inspect synthetic child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=0 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "non_coordinator": { + "admission_json": "null", + "quota_fields_json": "{\"task_orchestration_contract\":null,\"work_lane_contract\":{\"lane\":\"advancement_task\"}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- work_lane_contract: lane=advancement_task next=None obligation=None must_attempt_work=None", + "crossings": {} + }, + "unicode_election": { + "admission_json": "{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"6b7638ae1926fde449943e0242ce9dc39a025cc98a865f6030b6b75f218eedb7\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_\\u793a\\u4f8b\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_\\ud83d\\ude00child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_\\ud83d\\ude00child\",\"objective\":\"Inspect synthetic \\ud83d\\ude00child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"}", + "quota_fields_json": "{\"task_orchestration_contract\":{\"schema_version\":\"task_orchestration_contract_v2\",\"mode\":\"adaptive\",\"coordinator_agent_id\":\"agent-a\",\"assignment_key\":\"6b7638ae1926fde449943e0242ce9dc39a025cc98a865f6030b6b75f218eedb7\",\"activation_required\":false,\"activation_allowed\":true,\"strategy_owner\":\"task_coordinator\",\"max_children\":2,\"primary_todo_id\":\"todo_\\u793a\\u4f8b\",\"child_brief_defaults\":{\"schema_version\":\"subagent_control_plane_handoff_v0\",\"parent_goal_id\":\"goal_synthetic\",\"authority_artifact\":\"quota_should_run.goal_boundary\",\"latest_state_ref\":\"quota_should_run.action_signature.source_hash\",\"quota_gate_snapshot\":\"admitted_by_task_orchestration_contract\",\"context_policy\":{\"selection_owner\":\"task_coordinator\",\"default\":\"fresh\",\"allowed\":[\"fresh\",\"forked_snapshot\",\"resume\"]},\"expected_output\":\"public_safe_evidence\",\"execution_policy\":{\"timeout\":\"bounded_by_host_turn\",\"cancel\":\"task_coordinator_or_host_timeout\"},\"child_guard_policy\":\"prevention_first_v0\",\"validation_policy\":\"child reports evidence; parent runs declared todo gate\",\"acceptance\":[\"report completed scope and evidence\",\"report validation result and residual risk\",\"do not write LoopX state or spend quota\"],\"writeback_spend_contract\":\"child reports evidence only; task coordinator accepts evidence, writes state, and spends once\"},\"eligible_child_lanes\":[{\"todo_id\":\"todo_\\ud83d\\ude00child\",\"task_domain\":\"code\",\"execution_kind\":\"ephemeral_child\",\"child_brief\":{\"todo_id\":\"todo_\\ud83d\\ude00child\",\"objective\":\"Inspect synthetic \\ud83d\\ude00child\",\"action_kind\":\"inspect\",\"task_domain\":\"code\",\"required_capabilities\":[],\"task_repository\":null,\"required_write_scopes\":[],\"workspace_isolation\":\"not_required\",\"continuation_policy\":null,\"target_key\":null}}],\"blocked_lanes\":[],\"writeback_owner\":\"task_coordinator\",\"coordinator_obligation\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\"},\"work_lane_contract\":{\"schema_version\":\"work_lane_contract_v1\",\"lane\":\"task_orchestration\",\"next_lane\":\"peer_evidence_review\",\"obligation\":\"coordinate_task_bundle\",\"must_attempt_work\":true,\"reason_codes\":[\"eligible_child_lanes\"],\"monitor_policy\":\"material_transition_only\",\"action\":\"choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once\",\"eligible_peer_lane_count\":1}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- task_orchestration: mode=adaptive activation_required=False lanes=1 blocked_lanes=0 writeback_owner=task_coordinator\n- task_orchestration_admission: activation_allowed=True\n- work_lane_contract: lane=task_orchestration next=peer_evidence_review obligation=coordinate_task_bundle must_attempt_work=True\n- work_lane_reason_codes: eligible_child_lanes\n- work_lane_monitor_policy: material_transition_only\n- work_lane_action: choose whether admitted child lanes shorten the critical path; review returned evidence, then write accepted state/todos and spend once", + "crossings": {} + }, + "empty": { + "admission_json": "null", + "quota_fields_json": "{\"task_orchestration_contract\":null,\"work_lane_contract\":{\"lane\":\"advancement_task\"}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- work_lane_contract: lane=advancement_task next=None obligation=None must_attempt_work=None", + "crossings": {} + }, + "mode_off": { + "admission_json": "null", + "quota_fields_json": "{\"task_orchestration_contract\":null,\"work_lane_contract\":{\"lane\":\"advancement_task\"}}", + "markdown": "# LoopX Quota Should Run\n\n- projection: \ud83d\udd34 no projection envelope; freshness and coverage unknown\n- ok: `None`\n- goal_id: `None`\n- decision: `None`\n- should_run: `None`\n- normal_delivery_allowed: `None`\n- recovery_delivery_allowed: `None`\n- self_repair_allowed: `None`\n- effective_action: `None`\n- actionable_by_codex: `None`\n- state: `None`\n- waiting_on: `None`\n- status: `None`\n- work_lane_contract: lane=advancement_task next=None obligation=None must_attempt_work=None", + "crossings": {} + } +} diff --git a/tests/control_plane/test_adaptive_child_admission_characterization.py b/tests/control_plane/test_adaptive_child_admission_characterization.py new file mode 100644 index 0000000000..76e999993a --- /dev/null +++ b/tests/control_plane/test_adaptive_child_admission_characterization.py @@ -0,0 +1,120 @@ +"""Frozen public outputs from the Python admission owner before its cutover.""" +from __future__ import annotations + +from collections import Counter +from copy import deepcopy +import json +from pathlib import Path +from unittest.mock import patch + +import pytest + +from loopx.control_plane import effect_runtime +from loopx.control_plane.agents import capability_gate +from loopx.control_plane.quota import task_orchestration_admission as admission +from loopx.control_plane.quota.task_orchestration import apply_task_orchestration_contract +from loopx.presentation.renderers.quota_markdown import render_quota_should_run_markdown + +FIXTURE = Path(__file__).with_name("adaptive_child_admission_characterization.json") + + +def lane(name, **fields): + return {"todo_id": f"todo_{name}", "text": f"Inspect synthetic {name}", + "status": "open", "task_class": "advancement_task", "action_kind": "inspect", + "task_domain": "code", **fields} + + +def scenarios(): + base = {"agent_id": "agent-a", "agent_identity": {"registered_agents": ["agent-a"]}, + "goal_boundary": {"task_repository": "https://example.org/sample/project.git", + "write_scope": ["src/**", "tests/**", "docs/**"]}, + "orchestration": {"allowed_domains": ["code", "docs"]}, + "raw_agent_todo_summary": {"items": [lane("primary"), lane("child")]}, + "raw_user_todo_summary": {"items": []}, "agent_todo_source_items": None, + "user_todo_source_items": None, + "available_capabilities": ["subagent_spawn", "subagent_context_fork", "subagent_resume"], + "parent_goal_id": "goal_synthetic", "max_children": 2} + cases = {"unclaimed": deepcopy(base)} + def add(name, items=None, **updates): + case = deepcopy(base) + if items is not None: + case["raw_agent_todo_summary"] = {"items": items} + case.update(updates) + cases[name] = case + add("claimed", [lane("primary", claimed_by="agent-a"), lane("child", claimed_by="agent-a"), + lane("other", claimed_by="agent-b")]) + add("excluded_and_ordered_reasons", [lane("primary"), lane("child"), lane("blocked", + excluded_agents=["agent-a"], resume_when="todo_done:todo_dependency", resume_ready=False, + task_domain="research", required_capabilities=["network"], + task_repository="https://example.org/other/project", action_kind="implement")]) + add("user_dependency", [lane("primary"), lane("child"), lane("waiting")], + raw_user_todo_summary={"items": [{"unblocks_todo_id": "todo_waiting", "status": "open"}]}) + add("mixed_repository", [lane("primary"), lane("child"), + lane("other", task_repository="https://example.org/other/project"), + lane("invalid", task_repository="not a repository")]) + add("empty_write_scope", [lane("primary"), lane("child"), lane("writer", action_kind="implement")]) + add("scope_conflicts_capacity", [lane("primary", required_write_scopes=["src/core"]), + lane("glob", required_write_scopes=["src/core/*.py"]), + lane("child", required_write_scopes=["tests/**"]), + lane("docs", required_write_scopes=["docs/**"]), lane("overflow")], max_children=1) + add("first_conflict", [lane("primary", required_write_scopes=["src/a/**"]), + lane("child", required_write_scopes=["src/b/**"]), + lane("both", required_write_scopes=["src/**"])]) + add("case_sensitive_scope", [lane("primary"), lane("child"), + lane("case", required_write_scopes=["SRC/file.py"])]) + add("missing_capabilities", [lane("primary", required_capabilities=["shell"]), + lane("child", required_capabilities=["network"], target_capabilities=["network"]), + lane("blocked", required_capabilities=["production_access", "network"])]) + add("brief", [lane("primary"), lane("child", title=" " + "示例 😀 " * 100, + action_kind=" inspect_detail ", continuation_policy=" bounded ", target_key=" sample ", + validation_command_argv=[], validation_label=" synthetic check ")]) + add("acceptance_guard", [lane("primary"), lane("child"), + lane("guarded", goal_acceptance_guard={"allowed": False})]) + add("empty_canonical", agent_todo_source_items=[]) + add("empty_user_canonical", raw_user_todo_summary={"items": [{"unblocks_todo_id": "todo_child"}]}, + user_todo_source_items=[]) + add("non_coordinator", [lane("primary", claimed_by="agent-b"), lane("child", claimed_by="agent-b")]) + add("unicode_election", [lane("示例"), lane("😀child")], + agent_identity={"registered_agents": ["agent-a", "équipe", "代理", "agent-z"]}) + add("empty", []) + add("mode_off") + return cases + + +def observe(case, name): + counts = Counter() + original = effect_runtime.effect_runtime_result + def counted(method, *args, **kwargs): + counts[method] += 1 + return original(method, *args, **kwargs) + if hasattr(capability_gate, "_missing"): + capability_gate._missing.cache_clear() + with patch.object(effect_runtime, "effect_runtime_result", counted), patch.object(admission, "effect_runtime_result", counted): + direct = None if name == "mode_off" else admission.build_adaptive_task_orchestration_contract(**case) + direct_counts = dict(counts) + counts.clear() + boundary = {**case["goal_boundary"], "orchestration": { + **case["orchestration"], "mode": "off" if name == "mode_off" else "multi_subagent", + "spawn_allowed": True, "max_children": case["max_children"]}} + contract, work_lane = apply_task_orchestration_contract( + fallback_work_lane_contract={"lane": "advancement_task"}, goal_boundary=boundary, + agent_identity={**case["agent_identity"], "agent_id": case["agent_id"]}, + agent_todo_summary=case["raw_agent_todo_summary"], + **{key: case[key] for key in ("raw_agent_todo_summary", "raw_user_todo_summary", + "agent_todo_source_items", "user_todo_source_items", "available_capabilities", "parent_goal_id")}) + assert dict(counts) == ({} if name == "mode_off" else {"quota.task_orchestration.admit": 1}) + payload = {"task_orchestration_contract": contract, "work_lane_contract": work_lane} + return {"admission_json": json.dumps(direct, ensure_ascii=True, separators=(",", ":")), + "quota_fields_json": json.dumps(payload, ensure_ascii=True, separators=(",", ":")), + "markdown": render_quota_should_run_markdown(payload), + "crossings": direct_counts} + + +@pytest.mark.parametrize("name", scenarios()) +def test_complete_admission_parity(name): + expected = json.loads(FIXTURE.read_text())[name] + observed = observe(scenarios()[name], name) + counts = observed.pop("crossings") + expected.pop("crossings") # Frozen pre-cutover instrumentation remains in the fixture. + assert observed == expected + assert counts == ({} if name == "mode_off" else {"quota.task_orchestration.admit": 1}) diff --git a/tests/control_plane_ts/adaptive_children.test.ts b/tests/control_plane_ts/adaptive_children.test.ts new file mode 100644 index 0000000000..cdacf91f48 --- /dev/null +++ b/tests/control_plane_ts/adaptive_children.test.ts @@ -0,0 +1,56 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import type {JsonObject} from "../../loopx/control_plane/effect_program.ts"; +import {admitAdaptiveChildren} from "../../loopx/control_plane/quota/adaptive_children.ts"; +import {schedulingWriteScopeAllowed} from "../../loopx/control_plane/work_items/task_lease_acquire_decision.ts"; +import {createEffectRuntimeHandlers, dispatchEffectRuntimeMethod} from "../../loopx/control_plane/effect_runtime_handlers.ts"; + +const lane = (id: string, extra: JsonObject = {}): JsonObject => ({todo_id: id, dependency_todo_id: id, + task_class: "advancement_task", done: false, status: "open", resume_when: null, + claimed_by: null, excluded_agents: [], task_domain: "code", task_repository: null, + required_write_scopes: [], required_capabilities: [], target_capabilities: [], + objective: "Inspect synthetic evidence", action_kind: "inspect", continuation_policy: null, + target_key: null, validation_label: null, ...extra}); +const facts = (items: JsonObject[]): JsonObject => ({agent_id: "agent-a", registered_agents: ["agent-a"], + goal_repository: null, goal_write_scope: ["src/**"], allowed_domains: null, max_children: 2, + user_items: [], available_capabilities: ["subagent_spawn"], items}); + +for (const [value, pattern, allowed] of [ + ["src/a.ts", "src/**", true], ["SRC/a.ts", "src/**", false], + ["src/A.ts", "src/[A-Z].ts", true], ["src/a.ts", "src/[A-Z].ts", false], + ["src/a.ts", "src/[!A-Z].ts", true], ["src/😀.ts", "src/?.ts", true], + ["src/SS.ts", "src/[ß].ts", false], ["src/ß.ts", "src/[ß].ts", true], + ["src/ς.ts", "src/[Σ].ts", false], ["src/a.ts", "src/[z-a].ts", false], + ["src/].ts", "src/[]].ts", true], ["src/[.ts", "src/[.ts", true], + ["src/file.ts", "src", false], +] as const) test(`case-sensitive grant ${value} in ${pattern}`, () => { + assert.equal(schedulingWriteScopeAllowed(value, [pattern]), allowed); +}); + +test("one admission handler composes admission and retired leaf RPC fails closed", async () => { + const handlers = createEffectRuntimeHandlers({fingerprint: "synthetic", requestShutdown() {}}); + const result = await dispatchEffectRuntimeMethod(handlers, "quota.task_orchestration.admit", + facts([lane("todo_primary"), lane("todo_child")])) as JsonObject; + assert.equal(result.primary_todo_id, "todo_primary"); + assert.equal((result.eligible_child_lanes as JsonObject[])[0].todo_id, "todo_child"); + await assert.rejects(dispatchEffectRuntimeMethod(handlers, "quota.task_orchestration.write_scope_overlap", + {left: ["src"], right: ["src/a.ts"]}), {code: "unsupported_method"}); +}); + +test("acceptance and User dependencies exclude election candidates", () => { + const input = facts([lane("todo_primary"), lane("todo_child", {goal_acceptance_guard: {allowed: false}})]); + assert.equal(admitAdaptiveChildren(input), null); + input.items = [lane("todo_primary"), lane("todo_child")]; + input.user_items = [{unblocks_todo_id: "todo_child", status: "open", done: false}]; + assert.equal(admitAdaptiveChildren(input), null); +}); + +test("claimed election can elect another coordinator without granting this caller authority", () => { + assert.equal(admitAdaptiveChildren(facts([lane("todo_primary", {claimed_by: "agent-b"}), + lane("todo_child", {claimed_by: "agent-b"})])), null); +}); + +test("invalid requirements fail instead of falling back to host admission", () => { + assert.throws(() => admitAdaptiveChildren({...facts([]), items: null})); + assert.throws(() => admitAdaptiveChildren({...facts([]), max_children: 1.5})); +}); diff --git a/tests/control_plane_ts/effect_runtime_handlers.test.ts b/tests/control_plane_ts/effect_runtime_handlers.test.ts index ffd49683a0..a7a1318c10 100644 --- a/tests/control_plane_ts/effect_runtime_handlers.test.ts +++ b/tests/control_plane_ts/effect_runtime_handlers.test.ts @@ -1,6 +1,8 @@ import assert from "node:assert/strict"; import test from "node:test"; +import {evaluateQuotaSchedulingWriteScopesOverlap} from "../../loopx/control_plane/work_items/task_lease_acquire_decision.ts"; + import { createEffectRuntimeHandlers, dispatchEffectRuntimeMethod, @@ -97,14 +99,10 @@ test("scheduling write-scope overlap folds case and keeps subtree containment", ["src/a.ts", "src/a.ts/b", true], ]; for (const [left, right, overlap] of rows) { - const scheduling = await dispatchEffectRuntimeMethod( - handlers, - "quota.task_orchestration.write_scope_overlap", - { left: [left], right: [right] }, - ) as Record; + const scheduling = evaluateQuotaSchedulingWriteScopesOverlap({left: [left], right: [right]}); assert.equal(scheduling.overlap, overlap, `scheduling ${left} vs ${right}`); } - // The scheduling entry point stays wider than the canonical lease rule. + // The in-process scheduling owner stays wider than the canonical lease rule. const canonical = await dispatchEffectRuntimeMethod( handlers, "task_lease.write_scopes.overlap",