@deftai/directive-core 0.66.2 → 0.68.0

package/dist/swarm/routing-verify.d.ts

@@ -9,7 +9,7 @@ export interface VerifyRoutingOptions {
     advise?: boolean;
     /** Override the resolved provider (else derived from the runtime). */
     provider?: string | null;
-    /** Inject the runtime descriptor (else getPlatformCapabilities().runtimeMode). */
+    /** Inject the runtime descriptor (legacy test seam; else resolveDispatchProvider). */
     runtimeProbe?: () => string;
 }
 export interface VerifyRoutingResult {

package/dist/swarm/routing-verify.js

@@ -8,9 +8,8 @@
  *       1 = at least one in-scope role is undecided / not dispatchable
  *       2 = config error (unreadable / malformed route file)
  */
-import { getPlatformCapabilities } from "../intake/platform-capabilities.js";
 import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
-import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
+import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
 export const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export const DEFAULT_GATED_ROLES = ["leaf-implementation"];
@@ -18,15 +17,17 @@ function resolveProvider(options) {
     if (options.provider !== undefined && options.provider !== null && options.provider.length > 0) {
         return options.provider;
     }
-    const probe = options.runtimeProbe ?? (() => getPlatformCapabilities().runtimeMode);
-    let runtimeMode = "";
-    try {
-        runtimeMode = probe();
-    }
-    catch {
-        runtimeMode = "";
+    if (options.runtimeProbe !== undefined) {
+        let runtimeMode = "";
+        try {
+            runtimeMode = options.runtimeProbe();
+        }
+        catch {
+            runtimeMode = "";
+        }
+        return dispatchProviderFromRuntime(runtimeMode);
     }
-    return dispatchProviderFromRuntime(runtimeMode);
+    return resolveDispatchProvider(options.environ ?? process.env);
 }
 export function verifyRouting(options) {
     const roles = options.roles && options.roles.length > 0 ? options.roles : DEFAULT_GATED_ROLES;

package/dist/swarm/routing.d.ts

@@ -9,6 +9,8 @@ export declare const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export declare const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export declare const HARNESS_BOUND_PROVIDERS: Set<string>;
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877). */
+export declare const ROUTING_GATED_DISPATCH_PROVIDERS: Set<string>;
 export interface RouteDecision {
     model: string | null;
     mode?: string;
@@ -48,6 +50,13 @@ export declare function loadRoutingFile(path: string): {
 export declare function resolveModelRoute(file: RoutingFile | null, provider: string, role: string): RouteResolution;
 /** Map a runtime descriptor (platform-capabilities.runtimeMode) to a route key. */
 export declare function dispatchProviderFromRuntime(runtimeMode: string): string;
+/**
+ * Resolve the `dispatch_provider` routing key from the active runtime envelope.
+ * Separate from `runtime_mode` (#1557): Cursor sessions may carry
+ * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
+ * `cursor` for model selection (#1877).
+ */
+export declare function resolveDispatchProvider(environ?: NodeJS.ProcessEnv): string;
 /**
  * Write a decision back to the route file (create-if-missing). Stamps
  * `decidedAt` when the caller did not supply one. Used by the interactive

package/dist/swarm/routing.js

@@ -31,6 +31,12 @@ export const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export const HARNESS_BOUND_PROVIDERS = new Set(["grok"]);
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877). */
+export const ROUTING_GATED_DISPATCH_PROVIDERS = new Set(["cursor", "grok"]);
+const TRUTHY_ENV = new Set(["1", "true", "yes", "on"]);
+function envTruthy(environ, name) {
+    return TRUTHY_ENV.has((environ[name] ?? "").trim().toLowerCase());
+}
 /**
  * Resolve the route-file path. Honors the `DEFT_ROUTING_PATH` override first
  * (keeps both maintainer and consumer testable), then reads from the MAIN
@@ -150,12 +156,52 @@ export function dispatchProviderFromRuntime(runtimeMode) {
     }
     return normalized;
 }
+/**
+ * Resolve the `dispatch_provider` routing key from the active runtime envelope.
+ * Separate from `runtime_mode` (#1557): Cursor sessions may carry
+ * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
+ * `cursor` for model selection (#1877).
+ */
+export function resolveDispatchProvider(environ = process.env) {
+    if (envTruthy(environ, "CURSOR_COMPOSER") || envTruthy(environ, "CURSOR_AGENT")) {
+        return "cursor";
+    }
+    const runtime = (environ.DEFT_AGENT_RUNTIME ?? "").trim().toLowerCase();
+    if (envTruthy(environ, "GROK_BUILD") || runtime === "grok-build") {
+        return "grok";
+    }
+    if (runtime === "cloud" || runtime === "headless") {
+        return "cloud-headless";
+    }
+    if (envTruthy(environ, "GITHUB_ACTIONS") ||
+        envTruthy(environ, "BUILDKITE") ||
+        (envTruthy(environ, "CI") &&
+            !envTruthy(environ, "CURSOR_COMPOSER") &&
+            !envTruthy(environ, "CURSOR_AGENT"))) {
+        return "cloud-headless";
+    }
+    return "unknown";
+}
+/**
+ * Keys that would mutate the prototype chain rather than set an own property
+ * if used as a computed object key. Rejected for provider/role names so a
+ * malicious routing input cannot pollute `Object.prototype` (CodeQL
+ * js/prototype-polluting-assignment).
+ */
+const FORBIDDEN_ROUTING_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function assertSafeRoutingKey(kind, key) {
+    if (FORBIDDEN_ROUTING_KEYS.has(key)) {
+        throw new Error(`routing ${kind} name "${key}" is not allowed`);
+    }
+}
 /**
  * Write a decision back to the route file (create-if-missing). Stamps
  * `decidedAt` when the caller did not supply one. Used by the interactive
  * resolver path (resolver step 5) and the `swarm:routing-set` task.
  */
 export function writeModelDecision(path, provider, role, decision) {
+    assertSafeRoutingKey("provider", provider);
+    assertSafeRoutingKey("role", role);
     const { data } = loadRoutingFile(path);
     const file = data ?? {};
     const existing = providerBlockOf(file, provider);

package/dist/swarm/verify-review-clean-cli.js

@@ -4,8 +4,11 @@ import { verifyReviewClean } from "./verify-review-clean.js";
 export function verifyReviewCleanMain(argv = process.argv.slice(2)) {
     const prNumbers = [];
     const cohortGlobs = [];
+    const ciIgnoreChecks = [];
     let repo = null;
     let emitJson = false;
+    let skipCi = false;
+    let skipSlizard = false;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--cohort" && argv[i + 1] !== undefined) {
@@ -19,11 +22,32 @@ export function verifyReviewCleanMain(argv = process.argv.slice(2)) {
         else if (arg === "--json") {
             emitJson = true;
         }
+        else if (arg === "--skip-ci") {
+            skipCi = true;
+        }
+        else if (arg === "--skip-slizard") {
+            skipSlizard = true;
+        }
+        else if (arg === "--ci-ignore-check" && argv[i + 1] !== undefined) {
+            ciIgnoreChecks.push(argv[i + 1] ?? "");
+            i += 1;
+        }
+        else if (arg?.startsWith("--ci-ignore-check=")) {
+            ciIgnoreChecks.push(arg.slice("--ci-ignore-check=".length));
+        }
         else if (arg !== undefined && /^\d+$/.test(arg)) {
             prNumbers.push(Number.parseInt(arg, 10));
         }
     }
-    const result = verifyReviewClean({ prNumbers, cohortGlobs, repo, emitJson });
+    const result = verifyReviewClean({
+        prNumbers,
+        cohortGlobs,
+        repo,
+        emitJson,
+        skipCi,
+        skipSlizard,
+        ciIgnoreChecks,
+    });
     if (result.stdout.length > 0) {
         process.stdout.write(result.stdout);
     }

package/dist/swarm/verify-review-clean.d.ts

@@ -1,4 +1,7 @@
+import type { CiGateOptions } from "../pr-merge-readiness/ci-gate.js";
+import type { SlizardGateOptions } from "../pr-merge-readiness/slizard-gate.js";
 import type { RunGhFn } from "../pr-merge-readiness/types.js";
+type ReviewGateOptions = CiGateOptions & SlizardGateOptions;
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 export interface CohortResolutionError {
     vbrief_path: string;
@@ -10,6 +13,8 @@ export interface CohortPRResult {
     verdict: Record<string, unknown>;
     failures: string[];
     clean: boolean;
+    ci_summary: Record<string, unknown> | null;
+    slizard_summary: Record<string, unknown> | null;
 }
 export interface CohortResult {
     repo: string | null;
@@ -21,7 +26,7 @@ export declare function resolveCohortFromVbriefs(vbriefGlobs: readonly string[])
     prNumbers: number[];
     failures: CohortResolutionError[];
 };
-export declare function evaluatePr(prNumber: number, repo: string | null, runGh?: RunGhFn): CohortPRResult | null;
+export declare function evaluatePr(prNumber: number, repo: string | null, runGh?: RunGhFn, options?: ReviewGateOptions): CohortPRResult | null;
 export declare function cohortResultToDict(cohort: CohortResult): Record<string, unknown>;
 export declare function renderReviewCleanText(cohort: CohortResult): string;
 export interface VerifyReviewCleanArgs {
@@ -29,6 +34,9 @@ export interface VerifyReviewCleanArgs {
     cohortGlobs?: readonly string[];
     repo?: string | null;
     emitJson?: boolean;
+    skipCi?: boolean;
+    skipSlizard?: boolean;
+    ciIgnoreChecks?: readonly string[];
     runGh?: RunGhFn;
 }
 export declare function verifyReviewClean(args: VerifyReviewCleanArgs): {

package/dist/swarm/verify-review-clean.js

@@ -1,8 +1,10 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { hasArtifactSuffix } from "../layout/resolve.js";
-import { defaultRunGh, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
+import { buildCiSummaryLine, evaluateCiGate } from "../pr-merge-readiness/ci-gate.js";
+import { defaultRunGh, fetchCheckRunsRest, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
 import { evaluateGates, parseGreptileBody } from "../pr-merge-readiness/index.js";
+import { evaluateSlizardGate, isSlizardCheck } from "../pr-merge-readiness/slizard-gate.js";
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 function extractPrFromUri(uri) {
     const pullIdx = uri.indexOf("/pull/");
@@ -101,7 +103,7 @@ export function resolveCohortFromVbriefs(vbriefGlobs) {
     }
     return { prNumbers: seenPrs, failures };
 }
-export function evaluatePr(prNumber, repo, runGh = defaultRunGh) {
+export function evaluatePr(prNumber, repo, runGh = defaultRunGh, options = {}) {
     const headSha = fetchPrHeadSha(prNumber, repo, runGh);
     if (headSha === null) {
         return null;
@@ -112,12 +114,71 @@ export function evaluatePr(prNumber, repo, runGh = defaultRunGh) {
     }
     const verdict = parseGreptileBody(body);
     const failures = evaluateGates(prNumber, headSha, verdict);
+    let ciSummary = null;
+    let slizardSummary = null;
+    if (failures.length === 0) {
+        if (repo === null) {
+            failures.push("Could not resolve repo for required CI check-run gate. " +
+                "Use --repo OWNER/REPO or run from a checked-out repository.");
+            ciSummary = {
+                ready_state: "blocked",
+                error: "repo unresolved for check-runs lookup",
+            };
+            slizardSummary = { ready_state: "skipped", present: false };
+        }
+        else if (options.skipCi === true) {
+            const ci = evaluateCiGate([], { skipCi: true });
+            ciSummary = {
+                ...ci.summary,
+                summary_line: "CI check-runs: skipped (--skip-ci)",
+            };
+            const slizard = evaluateSlizardGate([], options);
+            failures.push(...slizard.failures);
+            slizardSummary = { ...slizard.summary };
+        }
+        else {
+            const checks = fetchCheckRunsRest(headSha, repo, runGh);
+            if (checks.summary === null) {
+                failures.push("Required CI check-runs could not be fetched; fail closed by default (#2169). " +
+                    `Root cause: ${checks.error}`);
+                ciSummary = {
+                    ready_state: "blocked",
+                    error: checks.error,
+                    checked_count: 0,
+                    ignored_checks: [...(options.ignoreCheckNames ?? [])],
+                    failed_required: [],
+                    pending_required: [],
+                    conclusions: [],
+                };
+                slizardSummary = { ready_state: "skipped", present: false };
+            }
+            else {
+                const slizard = evaluateSlizardGate(checks.checkRuns, options);
+                // SLizard is scored by the structured gate; exclude it from the generic CI set.
+                const slizardNames = checks.checkRuns
+                    .filter((r) => isSlizardCheck(r.name))
+                    .map((r) => r.name);
+                const ci = evaluateCiGate(checks.checkRuns, {
+                    skipCi: options.skipCi,
+                    ignoreCheckNames: [...(options.ignoreCheckNames ?? []), ...slizardNames],
+                });
+                failures.push(...ci.failures, ...slizard.failures);
+                ciSummary = {
+                    ...ci.summary,
+                    summary_line: buildCiSummaryLine(ci.summary),
+                };
+                slizardSummary = { ...slizard.summary };
+            }
+        }
+    }
     return {
         pr_number: prNumber,
         head_sha: headSha,
         verdict: { ...verdict },
         failures: [...failures],
         clean: failures.length === 0,
+        ci_summary: ciSummary,
+        slizard_summary: slizardSummary,
     };
 }
 export function cohortResultToDict(cohort) {
@@ -131,6 +192,8 @@ export function cohortResultToDict(cohort) {
             clean: r.clean,
             verdict: r.verdict,
             failures: r.failures,
+            ci_summary: r.ci_summary,
+            slizard_summary: r.slizard_summary,
         })),
         resolution_errors: cohort.resolution_errors,
     };
@@ -159,6 +222,12 @@ export function renderReviewCleanText(cohort) {
         lines.push(`    Findings:           P0=${String(v.p0Count ?? 0)}  ` +
             `P1=${String(v.p1Count ?? 0)}  P2=${String(v.p2Count ?? 0)}`);
         lines.push(`    Errored sentinel:   ${v.errored === true ? "True" : "False"}`);
+        if (r.ci_summary && typeof r.ci_summary.summary_line === "string") {
+            lines.push(`    ${r.ci_summary.summary_line}`);
+        }
+        if (r.slizard_summary && typeof r.slizard_summary.summary_line === "string") {
+            lines.push(`    ${r.slizard_summary.summary_line}`);
+        }
         r.failures.forEach((fail, index) => {
             lines.push(`      [${index + 1}] ${fail}`);
         });
@@ -212,7 +281,11 @@ export function verifyReviewClean(args) {
     const runGh = args.runGh ?? defaultRunGh;
     const prResults = [];
     for (const prNum of prNumbers) {
-        const perPr = evaluatePr(prNum, args.repo ?? null, runGh);
+        const perPr = evaluatePr(prNum, args.repo ?? null, runGh, {
+            skipCi: args.skipCi,
+            skipSlizard: args.skipSlizard,
+            ignoreCheckNames: args.ciIgnoreChecks,
+        });
         if (perPr === null) {
             return { exitCode: EXIT_EXTERNAL_ERROR, stdout: "", stderr: "" };
         }

package/dist/triage/queue/index.d.ts

@@ -4,6 +4,7 @@ export * from "./cache.js";
 export * from "./constants.js";
 export * from "./derive-group.js";
 export * from "./ranking-labels.js";
+export * from "./reconcile-live-state.js";
 export * from "./render.js";
 export * from "./repo.js";
 export * from "./scope-ignores-filter.js";

package/dist/triage/queue/index.js

@@ -4,6 +4,7 @@ export * from "./cache.js";
 export * from "./constants.js";
 export * from "./derive-group.js";
 export * from "./ranking-labels.js";
+export * from "./reconcile-live-state.js";
 export * from "./render.js";
 export * from "./repo.js";
 export * from "./scope-ignores-filter.js";

package/dist/triage/queue/project.d.ts

@@ -1,6 +1,11 @@
 export interface ProjectDefinition {
     readonly plan?: unknown;
 }
-/** Read vbrief/PROJECT-DEFINITION.vbrief.json. Returns null if absent/invalid. */
+/**
+ * Read the layout-resolved PROJECT-DEFINITION artifact (#2207). Resolves the
+ * `xbrief/` layout on migrated trees and falls back to `vbrief/` otherwise, so
+ * `plan.policy.triageRankingLabels` load correctly after the #2109 rename.
+ * Returns null if absent/invalid.
+ */
 export declare function loadProjectDefinition(projectRoot: string): ProjectDefinition | null;
 //# sourceMappingURL=project.d.ts.map

package/dist/triage/queue/project.js

@@ -1,9 +1,14 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { PROJECT_DEFINITION_REL_PATH } from "./constants.js";
-/** Read vbrief/PROJECT-DEFINITION.vbrief.json. Returns null if absent/invalid. */
+import { resolve } from "node:path";
+import { resolveProjectDefinitionPath } from "../../layout/resolve.js";
+/**
+ * Read the layout-resolved PROJECT-DEFINITION artifact (#2207). Resolves the
+ * `xbrief/` layout on migrated trees and falls back to `vbrief/` otherwise, so
+ * `plan.policy.triageRankingLabels` load correctly after the #2109 rename.
+ * Returns null if absent/invalid.
+ */
 export function loadProjectDefinition(projectRoot) {
-    const path = join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+    const path = resolveProjectDefinitionPath(resolve(projectRoot));
     if (!existsSync(path)) {
         return null;
     }

package/dist/triage/queue/reconcile-live-state.d.ts

@@ -0,0 +1,42 @@
+import type { CachedIssue } from "./types.js";
+/**
+ * Resolve the set of issue numbers that are currently OPEN on the live SCM.
+ *
+ * Returns `null` when the live state could not be determined (offline, gh
+ * missing / unauthenticated, REST error). Callers MUST treat `null` as "do not
+ * reconcile" and fall back to the cached view -- a transient read failure must
+ * never empty the queue.
+ */
+export type LiveOpenIssuesReader = (repo: string) => ReadonlySet<number> | null;
+/**
+ * Default reader: one batched, paginated REST list (`state=open`, PRs excluded)
+ * routed through the scm gh-rest shim. Prefers REST over GraphQL and issues a
+ * single logical lookup for the whole open set rather than N per-issue calls.
+ * Any failure is swallowed to `null` so the queue degrades to cached rendering.
+ *
+ * Latency ceiling: no explicit `limit` is passed ON PURPOSE. The reconcile drops
+ * any candidate absent from this set, so a truncated page would incorrectly drop
+ * genuinely-open issues (a false-negative is worse than the latency). The set is
+ * therefore the COMPLETE live-open list, bounded only by `restIssueListPaginated`'s
+ * pagination cap (`REST_PAGINATION_MAX_PAGES` * per-page = 100 * 100 = 10,000 open
+ * issues); a repo with more open issues than that raises rather than silently
+ * truncating. In practice open-issue counts are 10^1-10^2, so this is 1-2 REST
+ * pages. Batch here, never per-candidate.
+ */
+export declare function defaultLiveOpenIssuesReader(repo: string): ReadonlySet<number> | null;
+/**
+ * Reconcile cached candidate issues against live open/closed state before the
+ * queue renders (#2238). The cached candidate set records `state`, but that
+ * value goes stale as soon as an issue is closed/merged and the cache has not
+ * yet refreshed -- so honoring the cached flag alone is insufficient.
+ *
+ * Drops any candidate whose number is NOT in the live-open set. When the reader
+ * returns `null` (state undeterminable) the candidates pass through unchanged so
+ * a network / auth failure never silently empties the queue.
+ *
+ * `reader` defaults to {@link defaultLiveOpenIssuesReader}; tests (and the CLI)
+ * inject a stub via this optional parameter -- there is no module-level mutable
+ * seam, so nothing test-only leaks into the package's public API.
+ */
+export declare function reconcileLiveOpenState(issues: readonly CachedIssue[], repo: string, reader?: LiveOpenIssuesReader): readonly CachedIssue[];
+//# sourceMappingURL=reconcile-live-state.d.ts.map

package/dist/triage/queue/reconcile-live-state.js

@@ -0,0 +1,54 @@
+import { restIssueListPaginated } from "../../scm/gh-rest.js";
+/**
+ * Default reader: one batched, paginated REST list (`state=open`, PRs excluded)
+ * routed through the scm gh-rest shim. Prefers REST over GraphQL and issues a
+ * single logical lookup for the whole open set rather than N per-issue calls.
+ * Any failure is swallowed to `null` so the queue degrades to cached rendering.
+ *
+ * Latency ceiling: no explicit `limit` is passed ON PURPOSE. The reconcile drops
+ * any candidate absent from this set, so a truncated page would incorrectly drop
+ * genuinely-open issues (a false-negative is worse than the latency). The set is
+ * therefore the COMPLETE live-open list, bounded only by `restIssueListPaginated`'s
+ * pagination cap (`REST_PAGINATION_MAX_PAGES` * per-page = 100 * 100 = 10,000 open
+ * issues); a repo with more open issues than that raises rather than silently
+ * truncating. In practice open-issue counts are 10^1-10^2, so this is 1-2 REST
+ * pages. Batch here, never per-candidate.
+ */
+export function defaultLiveOpenIssuesReader(repo) {
+    try {
+        const rows = restIssueListPaginated(repo, { state: "open", excludePulls: true });
+        const open = new Set();
+        for (const row of rows) {
+            const n = row.number;
+            if (typeof n === "number" && Number.isInteger(n)) {
+                open.add(n);
+            }
+        }
+        return open;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Reconcile cached candidate issues against live open/closed state before the
+ * queue renders (#2238). The cached candidate set records `state`, but that
+ * value goes stale as soon as an issue is closed/merged and the cache has not
+ * yet refreshed -- so honoring the cached flag alone is insufficient.
+ *
+ * Drops any candidate whose number is NOT in the live-open set. When the reader
+ * returns `null` (state undeterminable) the candidates pass through unchanged so
+ * a network / auth failure never silently empties the queue.
+ *
+ * `reader` defaults to {@link defaultLiveOpenIssuesReader}; tests (and the CLI)
+ * inject a stub via this optional parameter -- there is no module-level mutable
+ * seam, so nothing test-only leaks into the package's public API.
+ */
+export function reconcileLiveOpenState(issues, repo, reader = defaultLiveOpenIssuesReader) {
+    const liveOpen = reader(repo);
+    if (liveOpen === null) {
+        return issues;
+    }
+    return issues.filter((issue) => liveOpen.has(issue.number));
+}
+//# sourceMappingURL=reconcile-live-state.js.map