@tea-agent/loop-agent 0.28.2-beta.1 → 0.28.3

package/dist/task/worktree.js

@@ -1,12 +1,14 @@
-import { access, mkdir, realpath } from 'node:fs/promises';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
+import { createHash, randomBytes } from "node:crypto";
+import { access, appendFile, mkdir, readFile, realpath, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+const OWNERSHIP_FILENAME = ".loop-agent-worktree-ownership.json";
 /**
  * Resolve the worktree root directory from a harness manifest.
  * Falls back to `<repoRoot>/.worktrees` when not configured.
  */
 export function resolveWorktreeRoot(repoRoot, manifest) {
-    const relativePath = manifest?.worktree?.rootRelativePath ?? '.worktrees';
+    const relativePath = manifest?.worktree?.rootRelativePath ?? ".worktrees";
     return path.resolve(repoRoot, relativePath);
 }
 /**
@@ -37,66 +39,215 @@ export async function createWorktree(repoRoot, manifest, opts) {
     const resolvedRoot = await resolveRepoRoot(repoRoot);
     const worktreePath = resolveWorktreePath(resolvedRoot, manifest, opts.taskId);
     const branch = opts.branch ?? `task/${opts.taskId}`;
-    const base = opts.base ?? 'HEAD';
+    const base = opts.base ?? "HEAD";
     // Check if worktree path already exists
     try {
         await access(worktreePath);
         throw new Error(`worktree path already exists: ${worktreePath}`);
     }
     catch (error) {
-        if (error.code !== 'ENOENT') {
+        if (error.code !== "ENOENT") {
             throw error;
         }
     }
     // Ensure parent directory exists
     await mkdir(path.dirname(worktreePath), { recursive: true });
     // Build git worktree add arguments
-    const addArgs = ['worktree', 'add', worktreePath];
+    const addArgs = ["worktree", "add", worktreePath];
     // Check if branch already exists; if so, don't pass -b
     const branchExists = await gitBranchExists(resolvedRoot, branch);
     if (!branchExists) {
-        addArgs.push('-b', branch);
+        addArgs.push("-b", branch);
     }
     addArgs.push(base);
     await runGit(resolvedRoot, addArgs);
     return { path: worktreePath, branch, base };
 }
+/**
+ * Idempotent ensure for a schedule-owned worktree.
+ * Validates path ↔ branch ↔ baseCommit and ownership token; never reuses an
+ * unowned path/branch with the same names.
+ */
+export async function ensureOwnedWorktree(repoRoot, options) {
+    const resolvedRoot = await resolveRepoRoot(repoRoot);
+    const worktreePath = resolveAgainstCanonicalRepoRoot(repoRoot, resolvedRoot, options.worktreePath);
+    assertOwnedWorktreePath(resolvedRoot, worktreePath);
+    const ownershipPath = path.join(worktreePath, OWNERSHIP_FILENAME);
+    const now = options.now ?? new Date();
+    let pathExists = false;
+    try {
+        await access(worktreePath);
+        pathExists = true;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (pathExists) {
+        const ownership = await readOwnershipRecord(ownershipPath);
+        if (!ownership) {
+            throw new Error(`worktree path exists without ownership record: ${worktreePath}`);
+        }
+        if (ownership.scheduleId !== options.scheduleId) {
+            throw new Error(`worktree ownership schedule mismatch: expected ${options.scheduleId}, found ${ownership.scheduleId}`);
+        }
+        if (options.ownershipToken &&
+            ownership.ownershipToken !== options.ownershipToken) {
+            throw new Error(`worktree ownership token mismatch at ${worktreePath}`);
+        }
+        if (ownership.branch !== options.branch ||
+            ownership.baseCommit !== options.baseCommit ||
+            ownership.baseBranch !== options.baseBranch) {
+            throw new Error(`worktree ownership triple mismatch at ${worktreePath}: expected branch=${options.branch} base=${options.baseBranch}@${options.baseCommit}`);
+        }
+        const entries = await listWorktrees(resolvedRoot);
+        const registered = entries.find((entry) => path.normalize(entry.path) === path.normalize(worktreePath));
+        if (!registered) {
+            throw new Error(`worktree path exists but is not registered in git worktree list: ${worktreePath}`);
+        }
+        if (registered.branch && registered.branch !== options.branch) {
+            throw new Error(`worktree registry branch mismatch: expected ${options.branch}, found ${registered.branch}`);
+        }
+        const head = (await runGit(worktreePath, ["rev-parse", "HEAD"])).trim();
+        if (head !== options.baseCommit) {
+            throw new Error(`worktree HEAD drift at ${worktreePath}: expected ${options.baseCommit}, found ${head}`);
+        }
+        await ensureOwnershipFileIgnored(worktreePath);
+        return {
+            path: worktreePath,
+            branch: options.branch,
+            baseBranch: options.baseBranch,
+            baseCommit: options.baseCommit,
+            ownershipToken: ownership.ownershipToken,
+            created: false,
+            reused: true,
+            head,
+        };
+    }
+    // Create path: branch must not already exist without our ownership.
+    const branchExists = await gitBranchExists(resolvedRoot, options.branch);
+    if (branchExists) {
+        throw new Error(`branch already exists without owned worktree: ${options.branch}`);
+    }
+    await mkdir(path.dirname(worktreePath), { recursive: true });
+    await runGit(resolvedRoot, [
+        "worktree",
+        "add",
+        worktreePath,
+        "-b",
+        options.branch,
+        options.baseCommit,
+    ]);
+    const ownershipToken = options.ownershipToken ??
+        `sha256:${createHash("sha256")
+            .update(`${options.scheduleId}\0${options.branch}\0${options.baseCommit}\0${randomBytes(8).toString("hex")}`)
+            .digest("hex")}`;
+    const ownership = {
+        schemaVersion: 1,
+        scheduleId: options.scheduleId,
+        branch: options.branch,
+        baseBranch: options.baseBranch,
+        baseCommit: options.baseCommit,
+        ownershipToken,
+        createdAt: now.toISOString(),
+        worktreePath,
+    };
+    await writeFile(ownershipPath, `${JSON.stringify(ownership, null, 2)}\n`, "utf-8");
+    await ensureOwnershipFileIgnored(worktreePath);
+    const head = (await runGit(worktreePath, ["rev-parse", "HEAD"])).trim();
+    return {
+        path: worktreePath,
+        branch: options.branch,
+        baseBranch: options.baseBranch,
+        baseCommit: options.baseCommit,
+        ownershipToken,
+        created: true,
+        reused: false,
+        head,
+    };
+}
+export async function readWorktreeOwnership(worktreePath) {
+    return readOwnershipRecord(path.join(worktreePath, OWNERSHIP_FILENAME));
+}
+export async function verifyOwnedWorktree(input) {
+    const resolvedRoot = await resolveRepoRoot(input.repoRoot);
+    const worktreePath = resolveAgainstCanonicalRepoRoot(input.repoRoot, resolvedRoot, input.worktreePath);
+    assertOwnedWorktreePath(resolvedRoot, worktreePath);
+    const ownership = await readWorktreeOwnership(worktreePath);
+    if (!ownership) {
+        throw new Error(`missing worktree ownership at ${worktreePath}`);
+    }
+    if (ownership.scheduleId !== input.scheduleId) {
+        throw new Error(`worktree ownership schedule mismatch: expected ${input.scheduleId}, found ${ownership.scheduleId}`);
+    }
+    if (ownership.ownershipToken !== input.ownershipToken) {
+        throw new Error(`worktree ownership token mismatch at ${worktreePath}`);
+    }
+    if (ownership.branch !== input.branch ||
+        ownership.baseCommit !== input.baseCommit) {
+        throw new Error(`worktree ownership branch/base mismatch at ${worktreePath}`);
+    }
+    const entries = await listWorktrees(resolvedRoot);
+    const registered = entries.find((entry) => path.normalize(entry.path) === path.normalize(worktreePath));
+    if (!registered) {
+        throw new Error(`worktree not registered: ${worktreePath}`);
+    }
+    if (registered.branch && registered.branch !== input.branch) {
+        throw new Error(`worktree registry branch mismatch: expected ${input.branch}, found ${registered.branch}`);
+    }
+    const head = (await runGit(worktreePath, ["rev-parse", "HEAD"])).trim();
+    if (head !== input.baseCommit) {
+        throw new Error(`worktree HEAD drift at ${worktreePath}: expected ${input.baseCommit}, found ${head}`);
+    }
+    await ensureOwnershipFileIgnored(worktreePath);
+    return { head, ownership };
+}
 /**
  * List git worktrees by parsing `git worktree list --porcelain`.
  */
 export async function listWorktrees(repoRoot) {
     const resolvedRoot = await resolveRepoRoot(repoRoot);
-    const stdout = await runGit(resolvedRoot, ['worktree', 'list', '--porcelain']);
+    const stdout = await runGit(resolvedRoot, [
+        "worktree",
+        "list",
+        "--porcelain",
+    ]);
     const entries = [];
-    const blocks = stdout.split('\n\n').filter((b) => b.trim().length > 0);
+    const blocks = stdout.split("\n\n").filter((b) => b.trim().length > 0);
     for (const block of blocks) {
-        const lines = block.trim().split('\n');
-        let entryPath = '';
+        const lines = block.trim().split("\n");
+        let entryPath = "";
         let branch;
-        let head = '';
+        let head = "";
         let bare = false;
         let locked = false;
         for (const line of lines) {
-            if (line.startsWith('worktree ')) {
-                entryPath = line.slice('worktree '.length);
+            if (line.startsWith("worktree ")) {
+                entryPath = line.slice("worktree ".length);
             }
-            else if (line.startsWith('branch ')) {
-                const ref = line.slice('branch '.length);
+            else if (line.startsWith("branch ")) {
+                const ref = line.slice("branch ".length);
                 // Convert refs/heads/<name> to <name>
-                branch = ref.replace(/^refs\/heads\//, '');
+                branch = ref.replace(/^refs\/heads\//, "");
             }
-            else if (line.startsWith('HEAD ')) {
-                head = line.slice('HEAD '.length);
+            else if (line.startsWith("HEAD ")) {
+                head = line.slice("HEAD ".length);
             }
-            else if (line === 'bare') {
+            else if (line === "bare") {
                 bare = true;
             }
-            else if (line === 'locked') {
+            else if (line === "locked") {
                 locked = true;
             }
         }
         if (entryPath) {
-            entries.push({ path: path.normalize(entryPath), branch, head, bare, locked });
+            entries.push({
+                path: path.normalize(entryPath),
+                branch,
+                head,
+                bare,
+                locked,
+            });
         }
     }
     return entries.sort((a, b) => a.path.localeCompare(b.path));
@@ -107,13 +258,16 @@ export async function listWorktrees(repoRoot) {
  */
 export async function removeWorktree(repoRoot, manifest, opts) {
     const resolvedRoot = await resolveRepoRoot(repoRoot);
-    const worktreePath = opts.path ?? (opts.taskId ? resolveWorktreePath(resolvedRoot, manifest, opts.taskId) : undefined);
+    const worktreePath = opts.path ??
+        (opts.taskId
+            ? resolveWorktreePath(resolvedRoot, manifest, opts.taskId)
+            : undefined);
     if (!worktreePath) {
-        throw new Error('removeWorktree requires either taskId or path');
+        throw new Error("removeWorktree requires either taskId or path");
     }
-    const removeArgs = ['worktree', 'remove'];
+    const removeArgs = ["worktree", "remove"];
     if (opts.force) {
-        removeArgs.push('--force');
+        removeArgs.push("--force");
     }
     removeArgs.push(worktreePath);
     await runGit(resolvedRoot, removeArgs);
@@ -121,7 +275,7 @@ export async function removeWorktree(repoRoot, manifest, opts) {
     if (opts.deleteBranch && opts.taskId) {
         const branch = `task/${opts.taskId}`;
         try {
-            await runGit(resolvedRoot, ['branch', '-d', branch]);
+            await runGit(resolvedRoot, ["branch", "-d", branch]);
         }
         catch {
             // Branch may already be deleted or not exist; ignore
@@ -136,21 +290,21 @@ export async function removeWorktree(repoRoot, manifest, opts) {
  */
 async function runGit(cwd, args) {
     return new Promise((resolve, reject) => {
-        const child = spawn('git', ['-C', cwd, ...args], {
-            stdio: ['ignore', 'pipe', 'pipe'],
+        const child = spawn("git", ["-C", cwd, ...args], {
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const stdoutChunks = [];
         const stderrChunks = [];
-        child.stdout?.on('data', (chunk) => stdoutChunks.push(chunk));
-        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
-        child.on('error', (err) => {
-            reject(new Error(`git ${args.join(' ')} spawn error: ${err.message}`));
+        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+        child.on("error", (err) => {
+            reject(new Error(`git ${args.join(" ")} spawn error: ${err.message}`));
         });
-        child.on('close', (code) => {
-            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
-            const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+        child.on("close", (code) => {
+            const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+            const stderr = Buffer.concat(stderrChunks).toString("utf-8");
             if (code !== 0) {
-                reject(new Error(`git ${args.join(' ')} failed (exit ${code}): ${stderr.trim()}`));
+                reject(new Error(`git ${args.join(" ")} failed (exit ${code}): ${stderr.trim()}`));
                 return;
             }
             resolve(stdout);
@@ -162,10 +316,73 @@ async function runGit(cwd, args) {
  */
 async function gitBranchExists(cwd, branchName) {
     try {
-        const stdout = await runGit(cwd, ['branch', '--list', branchName]);
+        const stdout = await runGit(cwd, ["branch", "--list", branchName]);
         return stdout.trim().length > 0;
     }
     catch {
         return false;
     }
 }
+function resolveAgainstCanonicalRepoRoot(providedRepoRoot, resolvedRepoRoot, candidatePath) {
+    if (!path.isAbsolute(candidatePath)) {
+        return path.resolve(resolvedRepoRoot, candidatePath);
+    }
+    const relativeToProvided = path.relative(path.resolve(providedRepoRoot), path.resolve(candidatePath));
+    if (!relativeToProvided.startsWith("..") &&
+        !path.isAbsolute(relativeToProvided)) {
+        return path.resolve(resolvedRepoRoot, relativeToProvided);
+    }
+    return path.resolve(candidatePath);
+}
+function assertOwnedWorktreePath(resolvedRepoRoot, worktreePath) {
+    const worktreeRoot = path.resolve(resolvedRepoRoot, ".worktrees");
+    const relative = path.relative(worktreeRoot, path.resolve(worktreePath));
+    if (relative.length === 0 ||
+        relative.startsWith("..") ||
+        path.isAbsolute(relative)) {
+        throw new Error(`owned worktree path must be a child of ${worktreeRoot}: ${worktreePath}`);
+    }
+}
+async function ensureOwnershipFileIgnored(worktreePath) {
+    const excludeRef = (await runGit(worktreePath, ["rev-parse", "--git-path", "info/exclude"])).trim();
+    const excludePath = path.isAbsolute(excludeRef)
+        ? excludeRef
+        : path.resolve(worktreePath, excludeRef);
+    const ignoreLine = `/${OWNERSHIP_FILENAME}`;
+    let existing = "";
+    try {
+        existing = await readFile(excludePath, "utf-8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (existing
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .includes(ignoreLine)) {
+        return;
+    }
+    await mkdir(path.dirname(excludePath), { recursive: true });
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    await appendFile(excludePath, `${separator}${ignoreLine}\n`, "utf-8");
+}
+async function readOwnershipRecord(ownershipPath) {
+    try {
+        const raw = await readFile(ownershipPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.schemaVersion !== 1 ||
+            typeof parsed.scheduleId !== "string" ||
+            typeof parsed.ownershipToken !== "string" ||
+            typeof parsed.branch !== "string" ||
+            typeof parsed.baseCommit !== "string") {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}

package/dist/worker/cli.js

@@ -31,12 +31,13 @@ import { approveFollowUp } from "./follow-up/approve.js";
 import { prepareFeatureDelivery } from "./delivery/package.js";
 import { previewFeatureCloseout, renderCloseoutPreview, } from "./closeout/preview.js";
 import { applyFeatureCloseout } from "./closeout/apply.js";
-import { advanceFeature, renderFeatureAdvance, } from "./feature/advance.js";
-import { diagnoseFeature, renderFeatureDoctor, } from "./feature/doctor.js";
+import { advanceFeature, renderFeatureAdvance } from "./feature/advance.js";
+import { diagnoseFeature, renderFeatureDoctor } from "./feature/doctor.js";
 import { FEATURE_SCAFFOLD_TEMPLATES, ScaffoldError, scaffoldFeaturePacket, } from "./feature/scaffold.js";
 import { projectMonthlyMetrics } from "./metrics/projector.js";
 import { defaultFeatureEvidencePaths, runFeatureFinalVerification, } from "./delivery/final-verification.js";
 import { advanceGitCheckpoint } from "./delivery/git-transaction.js";
+import { registerSchedulerCommands } from "./scheduler/cli.js";
 export function buildAgentWorkerProgram() {
     const program = new Command();
     program
@@ -65,6 +66,7 @@ export function buildAgentWorkerProgram() {
     const pool = program
         .command("pool")
         .description("Task Pool state doctor and migration utilities");
+    registerSchedulerCommands(program);
     pool
         .command("mark-failed")
         .requiredOption("--repo <repo-root>", "Target repo root")
@@ -285,9 +287,7 @@ export function buildAgentWorkerProgram() {
             controllerIdentity: client.getIdentity(),
             controllerExpectation: buildIdentityExpectation(options),
             evidenceMode: options.evidenceMode,
-            ...(options.qaEvidence
-                ? { qaEvidencePath: options.qaEvidence }
-                : {}),
+            ...(options.qaEvidence ? { qaEvidencePath: options.qaEvidence } : {}),
             ...(options.finalVerification
                 ? { finalVerificationPath: options.finalVerification }
                 : {}),
@@ -299,8 +299,7 @@ export function buildAgentWorkerProgram() {
         process.stdout.write(options.json
             ? `${JSON.stringify(result, null, 2)}\n`
             : renderFeatureAdvance(result));
-        if (result.status === "failed" ||
-            result.status === "blocked") {
+        if (result.status === "failed" || result.status === "blocked") {
             process.exitCode = 1;
         }
     });
@@ -350,8 +349,7 @@ export function buildAgentWorkerProgram() {
                     feature: {
                         featureId: options.featureId ?? "",
                         title: options.title ?? "",
-                        template: (options.template ??
-                            ""),
+                        template: (options.template ?? ""),
                         description: options.description,
                         bePaths: options.bePath,
                         fePaths: options.fePath,
@@ -791,18 +789,30 @@ export function buildAgentWorkerProgram() {
         .command("morning")
         .requiredOption("--repo <repo-root>", "Target repo root")
         .option("--batch-run-id <id>", "Filter to one batch run id")
+        .option("--window <window>", "Report window: all (Task Pool classic) or night (Night Scheduler)", "all")
+        .option("--date <yyyy-mm-dd>", "Local calendar date for --window night (default today)")
+        .option("--tz <timezone>", "IANA timezone for --window night", "Asia/Shanghai")
         .option("--output <path>", "Write markdown report to this path")
         .description("Render a markdown morning report from Task Pool runs")
         .action(async (options) => {
         const repoRoot = path.resolve(options.repo);
+        if (options.window !== "all" && options.window !== "night") {
+            throw new Error(`--window must be all or night, got ${options.window ?? ""}`);
+        }
+        const window = options.window;
         const outputPath = options.output ??
-            path.join(getTaskPoolRoot(repoRoot), "reports", "morning-report.md");
+            path.join(getTaskPoolRoot(repoRoot), "reports", window === "night"
+                ? `morning-night-${options.date ?? "latest"}.md`
+                : "morning-report.md");
         await writeMorningReport({
             repoRoot,
             ...(options.batchRunId ? { batchRunId: options.batchRunId } : {}),
+            window,
+            ...(options.date ? { date: options.date } : {}),
+            ...(options.tz ? { timezone: options.tz } : {}),
             outputPath: path.resolve(outputPath),
         });
-        process.stdout.write(`${JSON.stringify({ ok: true, outputPath }, null, 2)}\n`);
+        process.stdout.write(`${JSON.stringify({ ok: true, outputPath, window }, null, 2)}\n`);
     });
     report
         .command("metrics")
@@ -945,7 +955,7 @@ function isDirectRun() {
 }
 if (isDirectRun()) {
     main().catch((error) => {
-        console.error(error instanceof Error ? error.message : String(error));
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
         process.exit(1);
     });
 }

package/dist/worker/console/chat/workspace-landing.js

@@ -10,8 +10,12 @@ function configuredLanding(value) {
 }
 function configuredWorkspace(value) {
     const normalized = value?.trim().toLowerCase();
-    if (normalized === "chat" || normalized === "tasks" || normalized === "recovery")
+    if (normalized === "chat" ||
+        normalized === "tasks" ||
+        normalized === "recovery" ||
+        normalized === "night") {
         return normalized;
+    }
     return undefined;
 }
 function workspaceFromLocation(location) {
@@ -21,14 +25,16 @@ function workspaceFromLocation(location) {
     const queryValue = configuredLanding(query.get("landing") ?? query.get("workspace"));
     if (queryValue)
         return queryValue;
-    const hash = location.hash.startsWith("#") ? location.hash.slice(1) : location.hash;
+    const hash = location.hash.startsWith("#")
+        ? location.hash.slice(1)
+        : location.hash;
     return configuredLanding(new URLSearchParams(hash).get("workspace"));
 }
 export function resolveDefaultLanding(input) {
-    return workspaceFromLocation(input.location) ??
+    return (workspaceFromLocation(input.location) ??
         configuredLanding(input.storage?.getItem(DEFAULT_LANDING_STORAGE_KEY)) ??
         configuredLanding(input.env) ??
-        "tasks";
+        "tasks");
 }
 export function buildWorkspaceHref(workspace, params = {}) {
     const query = new URLSearchParams({ workspace });
@@ -40,9 +46,13 @@ export function buildWorkspaceHref(workspace, params = {}) {
 }
 export function parseWorkspaceHref(location) {
     const query = new URLSearchParams(location.search);
-    const hash = location.hash.startsWith("#") ? location.hash.slice(1) : location.hash;
+    const hash = location.hash.startsWith("#")
+        ? location.hash.slice(1)
+        : location.hash;
     const hashQuery = new URLSearchParams(hash);
-    const workspace = configuredWorkspace(query.get("workspace") ?? query.get("landing") ?? hashQuery.get("workspace"));
+    const workspace = configuredWorkspace(query.get("workspace") ??
+        query.get("landing") ??
+        hashQuery.get("workspace"));
     if (!workspace)
         return null;
     const read = (key) => query.get(key)?.trim() || undefined;

package/dist/worker/console/observe-health-match.js

@@ -16,6 +16,8 @@ export function capabilityForObserveTarget(target) {
             return "workerRun";
         case "batch":
             return "batch";
+        case "night":
+            return "nightJobs";
         default: {
             const _exhaustive = target;
             throw new Error(`capabilityForObserveTarget: unsupported ${JSON.stringify(_exhaustive)}`);

package/dist/worker/console/observe-link.js

@@ -26,6 +26,10 @@ export function buildObserveDeepLink(baseUrl, target) {
             return `${base}/#/run/${encodeURIComponent(target.workerRunId)}`;
         case "batch":
             return `${base}/#/batch/${encodeURIComponent(target.batchRunId)}`;
+        case "night":
+            return target.scheduleId
+                ? `${base}/#/night/${encodeURIComponent(target.scheduleId)}`
+                : `${base}/#/night`;
         default: {
             const _exhaustive = target;
             throw new Error(`buildObserveDeepLink: unsupported target ${JSON.stringify(_exhaustive)}`);