@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

package/dist/shared/operator/capabilities.js

@@ -392,6 +392,147 @@ const COMMON_MUTATION_ERRORS = [
 ];
 export function buildOperatorCapabilitiesDocument() {
     const actions = [
+        {
+            action: "prepareScheduledTask", cli: "console scheduled task preparation", kind: "mutation",
+            inputSchemaVersion: 1, resultSchemaVersion: 1, envelopeSchemaVersion: 1, requiredErrorCodes: ["INVALID_INPUT"],
+            description: "Preferred entry for natural-language one-time scheduled tasks, including read-only inspection reports. Call this directly after understanding the goal, output scope, executable acceptance and time; the server uses the CURRENT project directory and creates the immutable PRD, managed Task and strict writeSet gate, binds THIS Chat automatically and returns a REAL planned goal/confirmation card. No pre-existing task, worktree or session ID is needed: never ask the user for these internal fields and do not manually create/edit them with bash/write/newTask/importPrd. Keep preparation concise: preserve the user goal without inventing extra requirements. Omit budget for ordinary tasks. Use minimal independent acceptance commands (AC-1, AC-2), preferably existing test/build scripts or test -s scheduled-report.md for a report; no compound shell/pipelines/substitution, language-specific grep checks or redundant scope assertions (the host enforces scope). Infer routine defaults and verification commands from the repository; ask only about genuinely ambiguous goal/scope/time. For read-only requests allow just an ordinary report file in the current project directory, e.g. scheduled-report.md, not .harness/. Use schedule.delayMinutes for relative time (counted after preparation finishes), or localAt + IANA timezone for an exact date/time. The current workspace must match committed HEAD; never auto-commit/stash/reset existing changes. The card exposes the exact time, bounded defaults and committed base before one human confirmation. Same request in this Chat is idempotent. Only a returned goalId with state=planned is a prepared reservation; textual drafts, Tasks or failed operations are NOT bookings. Never replace a requested schedule with immediate execution or sleep, never call runDag or self-confirm. On failure explain the returned stage, correct business inputs and retry this tool; do not mutate imported PRD/runtime artifacts. For a new distinct appointment, make its goal/time distinct.",
+            inputParams: [{ name: "request", type: "object", required: true, description: "Business goal, workflow, allowedPaths, acceptance and schedule; optional forbiddenPaths/budget. Runtime identity is server-owned." }],
+            modelCallable: "always", humanConfirmation: "none",
+        },
+        {
+            "action": "prepareScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Advanced entry ONLY for an already prepared Task. For a new natural-language reservation use prepareScheduledTask instead. Requires the current repository or its linked worktree at frozenBase and a managed Task already strict-prepared at its writeSet gate. booking must include managedTaskId, originalGoal, chatSessionRef, workflow, worktreeRef, frozenBase, allowedPaths, forbiddenPaths, acceptance {policy, criteria [{acId,description,command}]}, budget {maxTurns,maxDagRuns,maxSupervisorCalls}, time {executeAtUtc,latestStartUtc,stopAtUtc,expiresAt,timezone,allowedHours,misfirePolicy}. Resolve natural-language dates with the user timezone; ask about ambiguous time/AC/scope. No execution or authorization occurs. Show the complete scope/time/budget for one browser confirmation. Never call runDag for this reservation.",
+            "inputParams": [
+                {
+                    "name": "booking",
+                    "type": "object",
+                    "required": true,
+                    "description": "Complete frozen booking inputs; never supply prepared, controllerRef, approval or owner tokens."
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
+        {
+            "action": "confirmScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Human browser confirmation of the exact displayed ScheduledGoal envelope.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Prepared goal id"
+                },
+                {
+                    "name": "stateVersion",
+                    "type": "number",
+                    "required": true,
+                    "description": "Displayed state version"
+                },
+                {
+                    "name": "envelopeHash",
+                    "type": "string",
+                    "required": true,
+                    "description": "Displayed envelope hash"
+                }
+            ],
+            "modelCallable": "never",
+            "humanConfirmation": "required"
+        },
+        {
+            "action": "cancelScheduledGoal",
+            "cli": "console scheduled goal service",
+            "kind": "mutation",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Cancel future ScheduledGoal admission; in-flight/unknown ownership remains until reconciled.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Goal id"
+                },
+                {
+                    "name": "stateVersion",
+                    "type": "number",
+                    "required": true,
+                    "description": "Current state version"
+                },
+                {
+                    "name": "reason",
+                    "type": "string",
+                    "required": true,
+                    "description": "Human cancellation reason"
+                }
+            ],
+            "modelCallable": "never",
+            "humanConfirmation": "required"
+        },
+        {
+            "action": "scheduledGoalGet",
+            "cli": "console scheduled goal service",
+            "kind": "read",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "Read a durable ScheduledGoal booking and separate execution, acceptance, delivery and reconciliation results. Never implies authorization.",
+            "inputParams": [
+                {
+                    "name": "goalId",
+                    "type": "string",
+                    "required": true,
+                    "description": "Goal id"
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
+        {
+            "action": "scheduledGoalList",
+            "cli": "console scheduled goal service",
+            "kind": "read",
+            "inputSchemaVersion": 1,
+            "resultSchemaVersion": 1,
+            "envelopeSchemaVersion": 1,
+            "requiredErrorCodes": [
+                "INVALID_INPUT"
+            ],
+            "description": "List durable ScheduledGoals, including those whose original Chat was archived or deleted.",
+            "inputParams": [
+                {
+                    "name": "chatSessionRef",
+                    "type": "string",
+                    "required": false,
+                    "description": "Optional original Chat session id"
+                }
+            ],
+            "modelCallable": "always",
+            "humanConfirmation": "none"
+        },
         {
             action: "operatorCapabilities",
             cli: "loop-agent operator capabilities --json",
@@ -714,6 +855,24 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "optional verify commands (label:command or shell)",
                 },
+                {
+                    name: "requirementOwnership",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen requirement→file ownership for frontend-implementation DAGs: [{requirementIds, implementationFiles?, verificationFiles?}] — machine-enforced at plan finalize",
+                },
+                {
+                    name: "capabilityBoundary",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                },
+                {
+                    name: "interactionIds",
+                    type: "array",
+                    required: false,
+                    description: "optional frozen interaction id vocabulary — contract interaction names are machine-checked against it at plan finalize",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",
@@ -1069,6 +1228,27 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "verification entries as label:command strings",
                 },
+                {
+                    name: "requirementOwnership",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen requirement→file ownership: [{requirementIds, implementationFiles?, verificationFiles?}] — machine-enforced at plan finalize",
+                },
+                {
+                    name: "capabilityBoundary",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                },
+                {
+                    name: "interactionIds",
+                    type: "array",
+                    itemsType: "string",
+                    required: false,
+                    description: "frozen interaction id vocabulary — contract interaction names are machine-checked against it at plan finalize",
+                },
                 {
                     name: "approveGate",
                     type: "string",

package/dist/shared/package-metadata.js

@@ -134,8 +134,10 @@ export function computePackageFingerprint(packageRoot) {
         const bBuf = Buffer.from(b.relativePath, "utf-8");
         const minLen = Math.min(aBuf.length, bBuf.length);
         for (let i = 0; i < minLen; i++) {
-            if (aBuf[i] !== bBuf[i])
-                return aBuf[i] - bBuf[i];
+            const aByte = aBuf[i];
+            const bByte = bBuf[i];
+            if (aByte !== bByte)
+                return (aByte ?? 0) - (bByte ?? 0);
         }
         return aBuf.length - bBuf.length;
     });
@@ -183,8 +185,8 @@ export function resolveBinPaths(requested, resolvedAt, inputs) {
     // Search PATH
     const pathEnv = env.PATH ?? env.Path ?? env.path ?? "";
     const candidates = resolveFromPath(requested, pathEnv, osPlatform, env.PATHEXT ?? env.Pathext ?? env.pathext, cwd);
-    if (candidates.length > 0) {
-        const entry = candidates[0];
+    const entry = candidates[0];
+    if (entry !== undefined) {
         assertRegularFile(entry, requested);
         return { requested, entry, realEntry: realpathSync(entry), resolvedAt };
     }

package/dist/shared/pi-context-pressure/sift-bridge.js

@@ -268,7 +268,7 @@ export function sliceUtf8Range(text, offset, maxBytes) {
     }
     const buffer = Buffer.from(text, "utf8");
     let end = Math.min(totalBytes, start + limit);
-    while (end > start && (buffer[end] & 0b1100_0000) === 0b1000_0000) {
+    while (end > start && ((buffer[end] ?? 0) & 0b1100_0000) === 0b1000_0000) {
         end -= 1;
     }
     const slice = buffer.subarray(start, end).toString("utf8");

package/dist/shared/reference-context.js

@@ -186,6 +186,8 @@ function globToRegExp(glob) {
     let regex = '^';
     for (let i = 0; i < glob.length; i += 1) {
         const char = glob[i];
+        if (char === undefined)
+            continue;
         if (char === '*') {
             const next = glob[i + 1];
             if (next === '*') {

package/dist/task/config-types.js

@@ -286,6 +286,35 @@ const taskConfigObjectSchema = z.object({
     verifyPreset: verifyPresetSchema.optional().default("auto"),
     /** Task-contract commands that must be included in final DAG shell verification. */
     verifyCommands: z.array(taskVerifyCommandSchema).optional().default([]),
+    /** Generation-frozen requirement→file ownership for frontend-implementation
+     * DAGs. Machine-checked at plan finalize: a requirement's implementation
+     * targets (and its verification targets' files) must stay inside the
+     * declared sets, so ownership never depends on model compliance with prose.
+     */
+    requirementOwnership: z
+        .array(z
+        .object({
+        requirementIds: z.array(z.string().min(1)).min(1),
+        implementationFiles: z.array(z.string().min(1)).optional(),
+        verificationFiles: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .refine((entry) => (entry.implementationFiles?.length ?? 0) > 0 ||
+        (entry.verificationFiles?.length ?? 0) > 0, { message: "requirementOwnership entry needs implementationFiles or verificationFiles" }))
+        .optional(),
+    /** Generation-frozen test capability boundary composed into the canonical
+     * dependencyPolicy by the runtime (planner never maintains it). */
+    capabilityBoundary: z
+        .object({
+        allowed: z.array(z.string().min(1)).optional(),
+        forbidden: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .refine((entry) => (entry.allowed?.length ?? 0) > 0 || (entry.forbidden?.length ?? 0) > 0, { message: "capabilityBoundary needs allowed or forbidden entries" })
+        .optional(),
+    /** Generation-frozen interaction id vocabulary. Contract interaction names
+     * must come from this set (plan finalize deterministic check). */
+    interactionIds: z.array(z.string().min(1)).optional(),
     /** Verification selection policy. Intermediate loops may use quota; final gates still run full required verification. */
     verifyQuota: verifyQuotaSchema.optional().default("full"),
     /** DAG supervised verify strategy. Final quota is fixed to full; intermediate quota may reduce cost. */

package/dist/task/contract/project.js

@@ -187,6 +187,15 @@ export function mergeManagedTaskConfigFields(existing, draft) {
         ...(draft.frontendOpenspec !== undefined
             ? { frontendOpenspec: draft.frontendOpenspec }
             : {}),
+        ...(draft.requirementOwnership !== undefined
+            ? { requirementOwnership: draft.requirementOwnership }
+            : {}),
+        ...(draft.capabilityBoundary !== undefined
+            ? { capabilityBoundary: draft.capabilityBoundary }
+            : {}),
+        ...(draft.interactionIds !== undefined
+            ? { interactionIds: draft.interactionIds }
+            : {}),
     };
     if (draft.featureId !== undefined) {
         next.featureId = draft.featureId;

package/dist/task/contract/recover.js

@@ -70,6 +70,12 @@ export async function recoverTaskContract(input) {
             };
         }
         const txId = input.txId ?? unfinished[0];
+        if (txId === undefined) {
+            return {
+                action: "manual-required",
+                message: "no unfinished transactions to recover",
+            };
+        }
         if (!unfinished.includes(txId)) {
             return {
                 action: "manual-required",

package/dist/task/contract/schema.js

@@ -75,6 +75,23 @@ export const taskContractDraftSchema = z
     assumptions: z.array(z.string()).optional(),
     hardConstraints: z.array(z.string()).optional(),
     frontendOpenspec: frontendOpenspecConfigSchema.optional(),
+    requirementOwnership: z
+        .array(z
+        .object({
+        requirementIds: z.array(z.string().min(1)).min(1),
+        implementationFiles: z.array(z.string().min(1)).optional(),
+        verificationFiles: z.array(z.string().min(1)).optional(),
+    })
+        .strict())
+        .optional(),
+    capabilityBoundary: z
+        .object({
+        allowed: z.array(z.string().min(1)).optional(),
+        forbidden: z.array(z.string().min(1)).optional(),
+    })
+        .strict()
+        .optional(),
+    interactionIds: z.array(z.string().min(1)).optional(),
     interviewAssessmentRef: z
         .object({
         draftSha256: z.string().min(1),

package/dist/task/source-prepare/artifact-meta.js

@@ -17,7 +17,10 @@ function parseSimpleFrontmatter(block) {
         const match = /^([A-Za-z0-9_-]+)\s*:\s*(.+?)\s*$/u.exec(line);
         if (!match)
             continue;
-        out[match[1]] = parseYamlishScalar(match[2]);
+        const [, key, value] = match;
+        if (key === undefined || value === undefined)
+            continue;
+        out[key] = parseYamlishScalar(value);
     }
     return out;
 }
@@ -46,7 +49,11 @@ export function detectProductArtifactMeta(markdown) {
     if (!match) {
         return { artifactType: "unknown", recognized: false };
     }
-    const fields = parseSimpleFrontmatter(match[1]);
+    const [, frontmatter] = match;
+    if (frontmatter === undefined) {
+        return { artifactType: "unknown", recognized: false };
+    }
+    const fields = parseSimpleFrontmatter(frontmatter);
     const artifactType = normalizeArtifactType(fields.artifact_type);
     const recognized = artifactType !== "unknown" || Boolean(fields.artifact_version);
     return {

package/dist/task/source-prepare/build-draft.js

@@ -90,6 +90,42 @@ function resolveAllowedRoots(input) {
         return normalized.ok ? normalized.value : raw.trim();
     });
 }
+function resolveInteractionIds(input) {
+    if (input.flags.interactionIds !== undefined) {
+        return input.flags.interactionIds;
+    }
+    if (input.baseDraft?.interactionIds?.length) {
+        return input.baseDraft.interactionIds;
+    }
+    if (input.existing?.interactionIds?.length) {
+        return input.existing.interactionIds;
+    }
+    return undefined;
+}
+function resolveCapabilityBoundary(input) {
+    if (input.flags.capabilityBoundary !== undefined) {
+        return input.flags.capabilityBoundary;
+    }
+    if (input.baseDraft?.capabilityBoundary) {
+        return input.baseDraft.capabilityBoundary;
+    }
+    if (input.existing?.capabilityBoundary) {
+        return input.existing.capabilityBoundary;
+    }
+    return undefined;
+}
+function resolveRequirementOwnership(input) {
+    if (input.flags.requirementOwnership !== undefined) {
+        return input.flags.requirementOwnership;
+    }
+    if (input.baseDraft?.requirementOwnership?.length) {
+        return input.baseDraft.requirementOwnership;
+    }
+    if (input.existing?.requirementOwnership?.length) {
+        return input.existing.requirementOwnership;
+    }
+    return undefined;
+}
 function resolveVerifyCommands(input) {
     if (input.flags.verifyCommands !== undefined) {
         return input.flags.verifyCommands.map((cmd) => ({
@@ -178,6 +214,21 @@ export function buildPrepareDraft(input) {
         baseDraft,
         existing: existingTaskConfig,
     });
+    const interactionIds = resolveInteractionIds({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    const capabilityBoundary = resolveCapabilityBoundary({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    const requirementOwnership = resolveRequirementOwnership({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
     const pathAssessment = assessPreparePaths({
         allowedPaths,
         forbiddenPaths: finalForbidden,
@@ -215,6 +266,15 @@ export function buildPrepareDraft(input) {
             })),
         },
     };
+    if (requirementOwnership !== undefined) {
+        draft.requirementOwnership = requirementOwnership;
+    }
+    if (capabilityBoundary !== undefined) {
+        draft.capabilityBoundary = capabilityBoundary;
+    }
+    if (interactionIds !== undefined && interactionIds.length > 0) {
+        draft.interactionIds = interactionIds;
+    }
     if (featureId)
         draft.featureId = featureId;
     const backendTest = resolveBackendTest(flags, baseDraft, existingTaskConfig);

package/dist/task/source-prepare/fragment-inventory.js

@@ -122,7 +122,10 @@ function isAtxHeading(line) {
     const match = /^(#{1,6})\s+(.+?)\s*$/u.exec(line);
     if (!match)
         return null;
-    return { level: match[1].length, text: match[2].trim() };
+    const [, hashes, text] = match;
+    if (hashes === undefined || text === undefined)
+        return null;
+    return { level: hashes.length, text: text.trim() };
 }
 function isListItem(line) {
     return /^\s*(?:[-*+]|\d+[.)])\s+(?:\[(?: |x|X)\]\s+)?/.test(line);

package/dist/task/source-prepare/parse-intent.js

@@ -59,11 +59,21 @@ function stripFencedAndComments(text) {
         .replace(/<!--[\s\S]*?-->/g, "\n");
 }
 function normalizeAcceptanceId(raw) {
-    return raw
+    return (raw
         .trim()
         .toUpperCase()
         .replace(/_/g, "-")
-        .replace(/^(AC)(FE|BE|UI|API)(?=-|\d)/u, "$1-$2");
+        .replace(/^(AC)(FE|BE|UI|API)(?=-|\d)/u, "$1-$2")
+        // A PRD writes `AC1` as naturally as `AC-1` or `AC_1`. Only the two earlier
+        // rules canonicalized a separator, so a bare `AC1` escaped verbatim — and the
+        // generated DAG's requirement-id schema requires a hyphen after the prefix
+        // (`/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/`). Other consumers already
+        // assume `AC-...` (e.g. the frontend-test checklist demands `AC-FE-001`).
+        // The result was a meaningless split: the same PRD style generated fine under
+        // `taskKind: standard` and failed DAG generation under
+        // `taskKind: frontend-implementation`. Canonicalize here, once, so every
+        // workflow reads the same ids.
+        .replace(/^AC(?=\d)/u, "AC-"));
 }
 function parseEmbeddedAcHeading(headingText) {
     const normalized = headingText
@@ -77,7 +87,10 @@ function parseEmbeddedAcHeading(headingText) {
     const match = EMBEDDED_AC_HEADING.exec(normalized);
     if (!match)
         return null;
-    const id = normalizeAcceptanceId(match[1]);
+    const [, rawId] = match;
+    if (rawId === undefined)
+        return null;
+    const id = normalizeAcceptanceId(rawId);
     // Bold-wrapped ids leave their closing marker inside the captured text
     // ("**AC-FE-INS-001**：xxx" captures "**：xxx"); strip emphasis remnants
     // and leading separators so the bound text is clean prose.
@@ -154,13 +167,17 @@ function isAtxHeading(line) {
     const match = /^(#{1,6})\s+(.+?)\s*$/u.exec(line);
     if (!match)
         return null;
-    return { level: match[1].length, text: match[2] };
+    const [, hashes, text] = match;
+    if (hashes === undefined || text === undefined)
+        return null;
+    return { level: hashes.length, text };
 }
 function parseListItem(line) {
     const match = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[(?: |x|X)\]\s+)?(.+?)\s*$/u.exec(line);
     if (!match)
         return null;
-    return match[1].trim();
+    const [, item] = match;
+    return item === undefined ? null : item.trim();
 }
 function parseAcceptanceLine(line, nextId) {
     const checklist = /^\s*[-*+]\s+\[(?: |x|X)\]\s+(.+?)\s*$/u.exec(line);
@@ -173,14 +190,20 @@ function parseAcceptanceLine(line, nextId) {
         return embedded;
     const withId = /^(AC[-_]?\d+)\s*[:：]\s*(.+)$/iu.exec(body);
     if (withId) {
-        return { id: normalizeAcceptanceId(withId[1]), text: withId[2].trim() };
+        const [, rawId, rawText] = withId;
+        if (rawId !== undefined && rawText !== undefined) {
+            return { id: normalizeAcceptanceId(rawId), text: rawText.trim() };
+        }
     }
     const bareAc = /^(AC[-_]?\d+)\s+(.+)$/iu.exec(body);
     if (bareAc) {
-        return {
-            id: normalizeAcceptanceId(bareAc[1]),
-            text: bareAc[2].trim(),
-        };
+        const [, rawId, rawText] = bareAc;
+        if (rawId !== undefined && rawText !== undefined) {
+            return {
+                id: normalizeAcceptanceId(rawId),
+                text: rawText.trim(),
+            };
+        }
     }
     return { id: nextId(), text: body };
 }
@@ -395,7 +418,9 @@ export function mergeAcceptanceCriteria(parts) {
     for (const id of order) {
         const texts = [...(byId.get(id) ?? [])];
         if (texts.length === 1) {
-            items.push({ id, text: texts[0] });
+            const [onlyText] = texts;
+            if (onlyText !== undefined)
+                items.push({ id, text: onlyText });
         }
         else if (texts.length > 1) {
             conflicts.push({ id, texts });

package/dist/task/task-demand-routing.js

@@ -102,11 +102,14 @@ function stripOutOfScopeSections(markdown) {
     for (const line of markdown.split(/\r?\n/)) {
         const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line.trim());
         if (heading) {
-            const level = heading[1].length;
+            const [, hashes, title] = heading;
+            if (hashes === undefined || title === undefined)
+                continue;
+            const level = hashes.length;
             if (skippedHeadingLevel !== null && level <= skippedHeadingLevel) {
                 skippedHeadingLevel = null;
             }
-            if (OUT_OF_SCOPE_HEADING.test(heading[2].trim())) {
+            if (OUT_OF_SCOPE_HEADING.test(title.trim())) {
                 skippedHeadingLevel = level;
                 continue;
             }