@tea-agent/loop-agent 0.28.10 → 0.28.12-beta.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [0.28.11] - 2026-08-06
+
+### 重点更新
+
+- 修复 Night Scheduler 收尾提交因前导空格处理不当导致变更路径截断、暂存失败的问题
+
+### 修复
+
+- Night Scheduler 收尾提交改用 trimEnd 替代 trim，保留 git porcelain 格式的前导空格，修复 worktree-only 变更路径被截断（如 src/hello.js 变为 rc/hello.js）导致 git add 失败的问题
+
 ## [0.28.10] - 2026-08-05
 
 ### 重点更新

package/dist/worker/scheduler/night-git-finalizer.js

@@ -26,11 +26,14 @@ export async function createNightClosingCommit(input) {
             reason: card.ok ? "task card required for closing commit" : card.reason,
         };
     }
+    // Never full String#trim() porcelain: a leading space is the index column for
+    // worktree-only changes (` M path`). Trimming turns ` M src/a` into `M src/a`,
+    // which parseGitStatusPorcelain then mis-reads as `rc/a`.
     const status = (await runGit(input.workspaceRoot, [
         "status",
         "--porcelain=v1",
         "--untracked-files=all",
-    ])).trim();
+    ])).trimEnd();
     if (!status) {
         return { ok: false, reason: "no changes to commit after execution" };
     }

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/package.json

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