@tea-agent/loop-agent 0.28.11 → 0.28.12

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -351,6 +351,19 @@ export function extractFrontendImplementationJson(text) {
             return JSON.parse(source);
         }
         catch (error) {
+            // Apply only deterministic, structure-preserving repairs before the
+            // quote repair below. These are common JSONC/model formatting defects,
+            // not a general parser relaxation.
+            const withoutComments = source
+                .replace(/\/\*[\s\S]*?\*\//g, "")
+                .replace(/^\s*\/\/.*$/gm, "");
+            const withoutTrailingCommas = withoutComments.replace(/,\s*([}\]])/g, "$1");
+            try {
+                return JSON.parse(withoutTrailingCommas);
+            }
+            catch {
+                // Continue with the narrower embedded-quote repair.
+            }
             // Models sometimes put ordinary ASCII quotes inside a JSON string
             // (for example: `reason: "支持..."`). Repair only quotes that are
             // clearly not structural: a closing quote is followed by JSON
@@ -503,6 +516,51 @@ function asStringArray(value) {
         .map((item) => asString(item))
         .filter((item) => item.length > 0);
 }
+function normalizeFrontendRoute(value) {
+    const route = asString(value).replaceAll("\\", "/").replace(/^\/+/, "");
+    if (!route || route === "." || route.split("/").includes(".."))
+        return null;
+    return `/${route}`;
+}
+function normalizeFrontendContractOptionalFields(value) {
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const targets = asRecord(record.targets);
+    const mockApi = asRecord(record.mockApi);
+    return {
+        ...record,
+        ...(targets
+            ? {
+                targets: {
+                    ...targets,
+                    routes: Array.isArray(targets.routes)
+                        ? targets.routes.map(normalizeFrontendRoute).filter((route) => Boolean(route))
+                        : targets.routes,
+                },
+            }
+            : {}),
+        ...(mockApi
+            ? {
+                mockApi: {
+                    ...mockApi,
+                    endpoints: Array.isArray(mockApi.endpoints)
+                        ? mockApi.endpoints.map((item) => {
+                            const endpoint = asRecord(item);
+                            if (!endpoint)
+                                return item;
+                            return {
+                                ...endpoint,
+                                fixture: asString(endpoint.fixture) || undefined,
+                                consumer: asString(endpoint.consumer) || undefined,
+                            };
+                        })
+                        : mockApi.endpoints,
+                },
+            }
+            : {}),
+    };
+}
 function isRequirementId(value) {
     return REQUIREMENT_ID_PATTERN.test(value);
 }
@@ -570,6 +628,112 @@ function canonicalizeVerificationTargetAliases(value) {
         : record.requirements;
     return { ...record, requirements };
 }
+/**
+ * Model-written evidence gaps are hypotheses, not authoritative coverage
+ * facts. If the plan contains a real verification target that explicitly
+ * names a requirement, the executor can prove that the requirement has a
+ * verification path even when the model forgot to wire the target into the
+ * requirement entry or conservatively marked its gap as blocking.
+ *
+ * Keep gaps blocking when that proof cannot be derived. This is deliberately
+ * narrow: it uses only sourceBinding requirement IDs and structurally present
+ * verification targets, and never invents a command, file, or target.
+ */
+function deriveFrontendVerificationCoverage(value, canonicalBinding) {
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const rawTargets = Array.isArray(record.verificationTargets)
+        ? record.verificationTargets
+        : [];
+    const targetIds = new Set(rawTargets
+        .map((item) => asRecord(item))
+        .filter((item) => Boolean(item))
+        .map((item) => asString(item.id))
+        .filter(Boolean));
+    const targetIdsByRequirement = new Map();
+    for (const item of rawTargets) {
+        const target = asRecord(item);
+        if (!target)
+            continue;
+        const targetId = asString(target.id);
+        const commandLabel = asString(target.commandLabel) || asString(target.command);
+        const file = asString(target.file);
+        // A target is usable evidence only when it has an identity, command and
+        // file. The strict schema will validate the final shape afterwards.
+        if (!targetId || !commandLabel || !file)
+            continue;
+        const targetRequirementIds = asStringArray(target.requirementIds);
+        const inferredRequirementIds = targetRequirementIds.length > 0
+            ? targetRequirementIds
+            : rawTargets.length === 1
+                ? canonicalBinding.requirementIds
+                : [];
+        for (const requirementId of inferredRequirementIds) {
+            const canonicalId = canonicalizeRequirementId(requirementId);
+            if (!canonicalBinding.requirementIds.includes(canonicalId))
+                continue;
+            const ids = targetIdsByRequirement.get(canonicalId) ?? [];
+            if (!ids.includes(targetId))
+                ids.push(targetId);
+            targetIdsByRequirement.set(canonicalId, ids);
+        }
+    }
+    const provenRequirementIds = new Set(targetIdsByRequirement.keys());
+    const requirements = Array.isArray(record.requirements)
+        ? record.requirements.map((item) => {
+            const requirement = asRecord(item);
+            if (!requirement)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(requirement.id));
+            const inferredTargetIds = targetIdsByRequirement.get(requirementId) ?? [];
+            const existingTargetIds = asStringArray(requirement.verificationTargetIds)
+                .filter((id) => targetIds.has(id));
+            const verificationTargetIds = [...new Set([
+                    ...existingTargetIds,
+                    ...inferredTargetIds,
+                ])];
+            const evidenceGap = asRecord(requirement.evidenceGap);
+            const hasProof = provenRequirementIds.has(requirementId);
+            return {
+                ...requirement,
+                ...(verificationTargetIds.length > 0 ? { verificationTargetIds } : {}),
+                ...(hasProof
+                    ? (evidenceGap ? { evidenceGap: { ...evidenceGap, blocking: false } } : {})
+                    : {
+                        evidenceGap: {
+                            requirementId,
+                            description: `No executable verification target can be derived for ${requirementId}`,
+                            blocking: true,
+                        },
+                    }),
+            };
+        })
+        : record.requirements;
+    const modelEvidenceGaps = Array.isArray(record.evidenceGaps)
+        ? record.evidenceGaps.map((item) => {
+            const gap = asRecord(item);
+            if (!gap)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(gap.requirementId));
+            // Model gaps are advisory. Blocking status is reconstructed below
+            // from the source binding and executable verification targets.
+            return { ...gap, blocking: false };
+        })
+        : [];
+    const derivedBlockingGaps = canonicalBinding.requirementIds
+        .filter((requirementId) => !provenRequirementIds.has(requirementId))
+        .map((requirementId) => ({
+        requirementId,
+        description: `No executable verification target can be derived for ${requirementId}`,
+        blocking: true,
+    }));
+    return {
+        ...record,
+        requirements,
+        evidenceGaps: [...modelEvidenceGaps, ...derivedBlockingGaps],
+    };
+}
 function assertFrontendContractPathsSafe(value) {
     const record = asRecord(value);
     if (!record)
@@ -700,12 +864,13 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
                 : rawRecord.uiStates,
         }
         : value;
+    const normalizedOptionalFields = normalizeFrontendContractOptionalFields(normalizedValue);
     // A payload can have the strict top-level shape while still containing
     // empty requirement coverage arrays. Do not trust shape alone: route such
     // payloads through the compatibility normalizer so targets and verification
     // references are deterministically filled from the contract context.
-    if (looksLikeStrictFrontendContract(normalizedValue)) {
-        const strictRecord = asRecord(normalizedValue);
+    if (looksLikeStrictFrontendContract(normalizedOptionalFields)) {
+        const strictRecord = asRecord(normalizedOptionalFields);
         const strictMockApi = asRecord(strictRecord?.mockApi);
         if (strictMockApi &&
             typeof strictMockApi.strategy === "string" &&
@@ -730,10 +895,28 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
                         : verificationIds,
                 };
             });
-            return { ...strictRecord, requirements };
+            const strictMockApi = asRecord(strictRecord.mockApi);
+            const strictTargetFiles = asStringArray(asRecord(strictRecord.targets)?.files);
+            const mockEndpoints = Array.isArray(strictMockApi?.endpoints)
+                ? strictMockApi.endpoints.map((item) => {
+                    const endpoint = asRecord(item);
+                    if (!endpoint)
+                        return item;
+                    return {
+                        ...endpoint,
+                        consumer: asString(endpoint.consumer) ||
+                            strictTargetFiles[0],
+                    };
+                })
+                : strictMockApi?.endpoints;
+            return {
+                ...strictRecord,
+                requirements,
+                ...(strictMockApi ? { mockApi: { ...strictMockApi, endpoints: mockEndpoints } } : {}),
+            };
         }
     }
-    const record = asRecord(normalizedValue);
+    const record = asRecord(normalizedOptionalFields);
     if (!record)
         return value;
     const implementation = asRecord(record.implementation);
@@ -1069,10 +1252,10 @@ export async function materializeFrontendImplementationContract(input) {
     const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
     // There is exactly one post-security candidate. A fallback candidate would
     // allow malformed raw fields to bypass the boundary checks above.
-    const candidate = {
+    const candidate = deriveFrontendVerificationCoverage({
         ...(asRecord(normalizedContract) ?? parsed),
         sourceBinding: canonicalBinding,
-    };
+    }, canonicalBinding);
     const result = frontendImplementationContractSchema.safeParse(candidate);
     if (!result.success)
         throw new Error(`invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);

package/dist/workflows/dag/init-hybrid.js

@@ -1300,9 +1300,19 @@ async function discoverFrontendFallbackVerifyCommands(repoRoot) {
         "test:e2e",
         "e2e",
     ]);
+    if (staticCommands.length === 0 && behaviorCommands.length === 0) {
+        try {
+            await access(path.join(repoRoot, "node_modules", ".bin", "tsc"));
+            staticCommands.push("npx --no-install tsc --noEmit");
+        }
+        catch {
+            // No local TypeScript binary: leave verification unavailable rather
+            // than invoking a missing script or downloading a package.
+        }
+    }
     return {
-        staticCommands: staticCommands.length > 0 ? staticCommands : behaviorCommands,
-        behaviorCommands: behaviorCommands.length > 0 ? behaviorCommands : staticCommands,
+        staticCommands: staticCommands.length > 0 ? staticCommands : [],
+        behaviorCommands: behaviorCommands.length > 0 ? behaviorCommands : [],
     };
 }
 function deriveFrontendBehaviorPaths(taskConfig) {
@@ -5956,12 +5966,12 @@ async function buildSoftVerifyNode(sources) {
     const strategy = resolveDagVerifyStrategy(sources.taskConfig, "1");
     const fallbackCommands = sources.repoRoot
         ? (await discoverFrontendFallbackVerifyCommands(sources.repoRoot)).staticCommands
-        : ["npm run typecheck"];
+        : [];
     const candidatePlan = canonicalizeVerificationCommands([
         ...taskVerifyCommands(sources.repoRoot, sources.taskConfig),
         ...(sources.verifyCommands?.intermediate ?? []),
     ]);
-    const focusedCandidates = candidatePlan.commands.filter((command) => !isFullSuiteVerifyCommand(command));
+    const focusedCandidates = candidatePlan.commands.filter((command) => !isFullSuiteVerifyCommand(command) && !isFrontendLintVerifyCommand(command));
     const quota = verifyQuotaLimit(strategy.intermediateQuota ?? "full");
     const focusedIntermediate = quota
         ? focusedCandidates.slice(0, quota)
@@ -5971,11 +5981,14 @@ async function buildSoftVerifyNode(sources) {
         commands: focusedIntermediate,
         taskConfig: sources.taskConfig,
     });
-    const commands = buildVerifyShellCommands({
+    const commandsWithoutFallback = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
         commands: plannedIntermediate.commands,
         fallbackCommands,
     });
+    const commands = commandsWithoutFallback.length > 0
+        ? commandsWithoutFallback
+        : ["node -e \"console.log('No project verification command configured; verification skipped')\""];
     return {
         id: "soft-verify-shell",
         depends_on: [implementId],
@@ -5994,7 +6007,7 @@ async function buildSoftVerifyNode(sources) {
                 quota: strategy.intermediateQuota ?? "full",
                 commandSource: sources.verifyCommands ? "adapter" : "inline",
                 commands: plannedIntermediate.commands,
-                fallbackCommands,
+                fallbackCommands: commands,
                 commandTexts: commands,
                 commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
                 plan: candidatePlan,
@@ -6094,9 +6107,13 @@ function buildRepairNode(sources) {
             .join("\n\n"),
     };
 }
-function buildHardVerifyNode(sources) {
+async function buildHardVerifyNode(sources) {
     const repairId = repairNodeId();
+    const discoveredFallback = sources.repoRoot
+        ? await discoverFrontendFallbackVerifyCommands(sources.repoRoot)
+        : { staticCommands: [], behaviorCommands: [] };
     const fallbackCommands = [
+        ...discoveredFallback.staticCommands.filter((command) => /(?:^|\s)(?:npm|pnpm|yarn|bun)\s+run\s+build(?:\s|$)/.test(command)),
         "HARNESS_ALLOW_ACTIVE_DAG_RUNS=1 bash scripts/check-repo.sh",
     ];
     const finalPlan = canonicalizeVerificationCommands([
@@ -6105,7 +6122,7 @@ function buildHardVerifyNode(sources) {
     ]);
     const plannedFinal = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
-        commands: finalPlan.commands,
+        commands: finalPlan.commands.filter((command) => !isFrontendLintVerifyCommand(command)),
         taskConfig: sources.taskConfig,
     });
     const commands = buildVerifyShellCommands({
@@ -6274,7 +6291,7 @@ async function buildSupervisedHybridDag(standard, sources) {
             buildProcessSupervisorNode(sources),
             buildProcessGateNode(sources),
             buildRepairNode(sources),
-            buildHardVerifyNode(sources),
+            await buildHardVerifyNode(sources),
             ...(authorityDecision.enabled
                 ? [
                     buildAuthoritySurfaceAuditNode(sources),

package/dist/workflows/dag/output-protocol.js

@@ -62,23 +62,76 @@ export function firstNonEmptyLine(text) {
     }
     return undefined;
 }
-/**
- * Parse the JSON-only review verdict protocol. The complete trimmed output
- * must be exactly one JSON object: fences, prose, partial objects, and
- * concatenated objects are all rejected before schema validation.
- */
+function extractUniqueReviewJson(text) {
+    const source = String(text).trim();
+    const blocks = [...source.matchAll(/```(?:json|jsonc)?\s*([\s\S]*?)\s*```/gi)].map((match) => match[1].trim());
+    const candidates = blocks.length > 0 ? blocks : [source];
+    const parsed = [];
+    for (const candidate of candidates) {
+        let cursor = 0;
+        while (cursor < candidate.length) {
+            const start = candidate.indexOf("{", cursor);
+            if (start < 0)
+                break;
+            let depth = 0;
+            let inString = false;
+            let escaped = false;
+            let end = -1;
+            for (let index = start; index < candidate.length; index += 1) {
+                const character = candidate[index];
+                if (inString) {
+                    if (escaped)
+                        escaped = false;
+                    else if (character === "\\")
+                        escaped = true;
+                    else if (character === '"')
+                        inString = false;
+                    continue;
+                }
+                if (character === '"')
+                    inString = true;
+                else if (character === "{")
+                    depth += 1;
+                else if (character === "}" && --depth === 0) {
+                    try {
+                        const value = JSON.parse(candidate.slice(start, index + 1));
+                        if (value && typeof value === "object" && !Array.isArray(value))
+                            parsed.push(value);
+                    }
+                    catch {
+                        // Keep fail-closed behavior for malformed JSON.
+                    }
+                    end = index;
+                    break;
+                }
+            }
+            if (end < 0)
+                break;
+            cursor = end + 1;
+        }
+    }
+    if (parsed.length !== 1) {
+        throw new Error(parsed.length === 0
+            ? "output must contain one valid JSON review object"
+            : "output must contain exactly one JSON review object");
+    }
+    return parsed[0];
+}
+/** Parse a JSON review verdict after extracting one unambiguous JSON object.
+ * Prose and one Markdown fence are tolerated at this boundary; ambiguity and
+ * schema/semantic violations remain fail-closed. */
 export function parseJsonReviewVerdict(text) {
     const trimmed = String(text).trim();
     if (!trimmed)
         return { ok: false, reason: "missing JSON output" };
     let parsed;
     try {
-        parsed = JSON.parse(trimmed);
+        parsed = extractUniqueReviewJson(trimmed);
     }
     catch (error) {
         return {
             ok: false,
-            reason: `output must be exactly one JSON object: ${error instanceof Error ? error.message : String(error)}`,
+            reason: `output JSON extraction failed: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {

package/docs/templates/init-managed-agents.md

@@ -99,7 +99,7 @@ loop-agent task advance <task-id> "任务标题" \
   --prd <path-to-prd.md> \
   --allowed-path "<glob>" \
   --forbidden-path ".harness/**" \
-  --verify "typecheck:npm run typecheck" \
+  --verify "<label>:<command>" \
   --json
 # 审查 writeSet gate digest 后：
 loop-agent task advance <task-id> --approve-gate "write-set-review:<digest>" --json
@@ -108,6 +108,8 @@ loop-agent task status <task-id> --json
 # 有 plan 时收尾：loop-agent plan complete <plan-id> --summary "..."
 ```
 
+`--verify` 命令应取项目 `AGENTS.md` / `__LOOP_AGENT_GOVERNANCE_ROOT__/verification-matrix.md` 登记的验证命令（不要假定 `npm run typecheck` 存在）；`--verify` 可选，省略时自动从 package.json scripts 或既有 managed `task.json.verifyCommands` 推导建议。
+
 `source/需求.md` 与 `source/执行约束.md` 仍必需（M8/M9），但默认由 `task advance --prd` 投影生成，而不是主会话手写。`plan create` 不是 `task advance` 的硬依赖。写入前同步 `task.json.allowedPaths` / `task.json.forbiddenPaths` 并审查 writer `writeSet`。高级任意 DagSpec 才用 `dag validate|execute|report`，不进入标准 happy path。
 
 凡是影响项目公共契约、执行入口、交付流水线、自动化/治理、数据模型、安全或权限模型、跨模块行为、用户可见工作流的改动，都必须在编辑实现文件前先通过 `task advance` 建立 managed contract / writeSet gate，并审查 gate digest。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.28.11",
+  "version": "0.28.12",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/loop-agent/SKILL.md

@@ -32,12 +32,14 @@ references:
 ```bash
 loop-agent task advance <task-id> "Title" --prd <prd.md> \
   --allowed-path "<glob>" --forbidden-path ".harness/**" \
-  --verify "typecheck:npm run typecheck" --json
+  --verify "<label>:<command>" --json
 loop-agent task advance <task-id> \
   --approve-gate "write-set-review:<digest>" --json
 loop-agent task status <task-id> --json
 ```
 
+`--verify` 命令应取项目 `AGENTS.md` / 治理文档 verification-matrix.md 登记的验证命令（不要假定 `npm run typecheck` 存在）；`--verify` 可选，省略时自动从 package.json scripts 或既有 managed `task.json.verifyCommands` 推导建议。
+
 非微小跨会话任务可先 `plan create`。主会话只审 gate/writeSet 与验证证据，不拼低层 prepare/run-task/run-dag/promote/closeout 命令串。
 
 ## 主题路由

package/skills/loop-agent/references/command-reference.md

@@ -42,7 +42,7 @@ loop-agent doctor
      --accept-recommendations DIGEST \
      --allowed-path "src/**" \
      --forbidden-path ".harness/**" \
-     --verify "typecheck:npm run typecheck" \
+     --verify "<label>:<command>" \
      --json
 
    # 审查 gate.writeSet / gate.digest 后
@@ -55,6 +55,8 @@ loop-agent doctor
    loop-agent plan complete PLAN_ID --summary "..."
    ```
 
+   `--verify` 命令应取项目 `AGENTS.md` / `docs/governance/verification-matrix.md` 登记的验证命令（不要假定 `npm run typecheck` 存在）；`--verify` 可选，省略时自动从 package.json scripts 或既有 managed `task.json.verifyCommands` 推导建议。
+
    首次 `task advance` 内部完成 create、PRD 归档、managed contract 投影、DAG 生成与 strict validate，并停在 writeSet gate；批准后同一命令长跑到稳定终态并做确定性 promotion/closeout。决策表与反模式见 `source-and-plan-practice.md`。
 2. **Operator 工具**，用于 recovery、诊断、评测重放：
 
@@ -166,7 +168,7 @@ loop-agent examples copy <name> --output examples/<name>
 loop-agent task advance <task-id> "Task Title" \
   --prd path/to-prd.md \
   --allowed-path "src/**" \
-  --verify "typecheck:npm run typecheck" \
+  --verify "<label>:<command>" \
   --json
 loop-agent task advance <task-id> --approve-gate "write-set-review:<digest>" --json
 loop-agent task status <task-id> --json
@@ -218,7 +220,7 @@ loop-agent task advance <task-id> "标题" \
   --prd <path-to-original-prd.md> \
   --allowed-path "<glob>" \
   --forbidden-path ".harness/**" \
-  --verify "typecheck:npm run typecheck" \
+  --verify "<label>:<command>" \
   --json
 ```
 
@@ -566,6 +568,9 @@ agent-worker scheduler cancel <schedule-id> --repo <repo-root> [--reason <text>]
 agent-worker scheduler harvest <schedule-id> --repo <repo-root> [--json]
 agent-worker scheduler discard <schedule-id> --repo <repo-root> --reason <text> [--force] [--json]
 agent-worker scheduler tick --repo <repo-root> [--json]  # daemon/clock; not Operator Chat
+agent-worker scheduler clock install --repo <repo-root> [--interval-sec 60] [--loop-agent-bin <path>] [--json]  # OS timer; CLI-only
+agent-worker scheduler clock status --repo <repo-root> [--json]  # CLI-only
+agent-worker scheduler clock uninstall --repo <repo-root> [--json]  # CLI-only
 agent-worker scheduler submit --repo <repo-root> --feature-id <id> --task-id <id> ...  # low-level planning fact
 agent-worker scheduler transition <schedule-id> --repo <repo-root> --to <status> ...  # internal lifecycle
 agent-worker console [--repo <repo-root>] [--port 8790] [--host 127.0.0.1]  # Official 裸入口；repo 默认当前目录
@@ -596,7 +601,7 @@ agent-worker observe snapshot --repo <repo-root>  # 输出 GlobalSnapshot JSON
 - `task draft-followup` 会按全部 failure category 生成 TaskDraft 或人工行动卡：ProductBug/TestBug/FlakyTest/DependencyFailure 可批准；EnvFailure 连续两次后才生成 ENV-CHECK；Spec/Contract/Risk/Human/Unknown 只给行动卡。人工以 `feature approve-followup --dry-run` 预览，再带非空 `--owner` 批准 TaskDraft；行动卡不能批准。批准在 staging validation 后写 TaskSpec、graph、Ready/approval/event，原失败事实不改写，并有 rename/state/approval/index/event 回滚门禁。
 - `task retry` 是失败 Task 的唯一重试入口。它会保留原有运行记录和 failure handoff，并让下一次 `batch run-ready` 使用新的 `workerRunId`；不要删除运行态文件或手动修改状态来重试。
 - **推荐**裸入口 `agent-worker console`（repo 默认当前目录，默认 `127.0.0.1:8790`）提供 Operate + Inspect；`console serve` 是等价兼容入口。Inspect 路径为 `/inspect/#/...`，API 仍为根 `/api/**`。`observe serve` 为兼容入口（默认 `8787`，启动时 stderr 输出 `OBSERVE_SERVE_DEPRECATED`）；`observe snapshot` 保留。Inspect/Observe 本身不会启动、暂停或重试 Task / Worker / DAG。
-- Night Scheduler（本地夜间自治）：白天 `admission prepare` 冻结 worktree + DAG writeSet gate；`scheduler add` 消费 gate 并预约 Task Pool `Queued`（不立即执行）；`scheduler tick` 作为 Worker 时钟 claim/dispatch（CLI/cron，不进 Operator Chat）；成功后 `pending-harvest`，早晨 `scheduler harvest`（exact-base FF）或 `scheduler discard`；`report morning --window night` 与 Inspect `#/night` / Operate 夜间面板读取同一套 facts。
+- Night Scheduler（本地夜间自治）：白天 `admission prepare` 冻结 worktree + DAG writeSet gate；`scheduler add` 消费 gate 并预约 Task Pool `Queued`（不立即执行）；`scheduler clock install` 安装本机 user-level OS timer（launchd / systemd --user / schtasks）周期调用 `scheduler tick`；tick 写统一 Clock receipt，doctor/morning/status 可解释 missing/stale/error/busy/drift；成功后 `pending-harvest`，早晨 `scheduler harvest`（exact-base FF）或 `scheduler discard`；`report morning --window night` 与 Inspect `#/night` / Operate 夜间面板读取同一套 facts。Clock install/status/uninstall 为 CLI-only。
 - 当前 Worker 仍是 v0（库 + CLI + dogfood）；日间批处理未强制定时/CI 驱动；`report morning` 默认可从 Task Pool runs 汇总，并支持 `--window night` 投影 Scheduler facts。
 
 ### 查看 duration statistics / context usage

package/skills/loop-agent/references/harness-policy.md

@@ -57,7 +57,7 @@ Minimum governed path：
 loop-agent task advance <task-id> "Task Title" \
   --prd <path-to-original-prd.md> \
   --allowed-path "<glob>" \
-  --verify "typecheck:npm run typecheck" \
+  --verify "<label>:<command>" \
   --json \
   [--repo-root <target-repo>]
 
@@ -70,6 +70,8 @@ loop-agent task advance <task-id> \
 loop-agent task status <task-id> --json [--repo-root <target-repo>]
 ```
 
+The `--verify` command should reference verification commands registered in the project's `AGENTS.md` or its governance verification-matrix.md; do not assume `npm run typecheck` exists. `--verify` is optional; when omitted, suggestions are auto-derived from `package.json` scripts or existing managed `task.json.verifyCommands`.
+
 `loop-agent` is the preferred global CLI. For self-hosting loop-agent development, the controller must be an installed npm-published package. Use `npm install -g @tea-agent/loop-agent@latest` for first install or intentional upgrades, then treat the installed version as frozen for the current task and record `npm list -g @tea-agent/loop-agent --depth=0`. Do not repeatedly fetch `npx @latest` inside DAG nodes, and do not use the current working tree's `npm link` or `npm run dev` to control tasks that may edit CLI, DAG runtime, executors, package metadata, or build output. Use `npm run dev -- <args>` only for source debugging and focused CLI development.
 
 The npm package carries static capability assets: `skills/` (bundled in-package, containing `loop-agent` and `agent-worker`; `loop-agent init` mirrors them into the target project's `.agents/skills/`), `docs/templates/`, `docs/architecture/`, `docs/skills/`, `examples/`, `harness.json`, `AGENTS.md`, `README.md`, and `CHANGELOG.md`. `loop-agent init` creates `ai_workspace/loop-agent/` (the default governanceRoot) in the target project with `progress/`, `reports/`, `exec-plans/`, and `decisions/` directories plus their README files; the actual files under those directories belong to the target repository and are not shipped by the npm package.