@yagni-app/code-staging 1.2.13-staging.2190.1 → 1.2.13-staging.2198.1

package/dist/cli.js

@@ -32,6 +32,7 @@ import { buildLaunch } from "./launch.js";
 import { resolveOtelLaunchWithWorkspace } from "./otel.js";
 import { parseOutputFormat, parseJsonEvents, buildResultObject, readGuardianEvents, } from "./outputFormat.js";
 import { feedbackCommand } from "./feedback.js";
+import { envCommand } from "./env.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
@@ -705,6 +706,10 @@ export const HELP_TEXT = [
     "                           add, install, uninstall, update, list — run",
     "                           `yagni plugin` for details. Skills, commands,",
     "                           agents, and bundled MCP servers load on launch.",
+    "  yagni env check [--repo owner/name]  Validate the repository's environment",
+    "                           as it stands, without repair, printing each step.",
+    "                           The repository defaults to the origin remote.",
+    "                           Exits 0 ready, 1 needs attention, 2 request error.",
     "  yagni token              Output the active environment's API token (for helpers).",
     "  yagni use <name>         Switch the active environment (sticky).",
     "                           Presets: prod, local. Others need --base-url <url>.",
@@ -866,6 +871,9 @@ export async function main(argv) {
     if (command === "feedback") {
         return feedbackCommand(rest, {}, cliVersion());
     }
+    if (command === "env") {
+        return envCommand(rest, {}, cliVersion());
+    }
     if (command === "token") {
         return tokenCommand({}, rest);
     }

package/dist/env.d.ts

@@ -0,0 +1,116 @@
+/**
+ * `yagni env check [--repo owner/name]` (YAG-1109): validate a repository's
+ * environment as it stands, without repair, and print each step as it runs.
+ *
+ * The repository defaults to the current directory's `origin` remote. The
+ * command starts the check (`POST /api/yagni-code/environment/check`), then
+ * polls the run (`GET /api/yagni-code/environment/runs/:revisionId`) every
+ * 3 s. Exit codes: 0 ready, 1 needs attention, 2 a request or usage error.
+ *
+ * The remote parser, the step formatter and the poll loop are pure, with
+ * `fetch` and `sleep` injected, so they test without a network.
+ */
+export type EnvRunStatus = "validating" | "ready" | "needs_attention";
+export type EnvStepState = "pending" | "running" | "done" | "failed" | "skipped";
+/** One step of the run, as the server returns it (`QaRunStep`). */
+export interface EnvRunStep {
+    index: number;
+    kind?: string;
+    label: string;
+    path?: string;
+    line?: number;
+    state: EnvStepState;
+    durationMs?: number;
+    exitCode?: number;
+    outputTail?: string;
+}
+export interface EnvRun {
+    status: EnvRunStatus;
+    message: string;
+    steps: EnvRunStep[];
+    notes: string[];
+    outputTail?: string;
+    /** The declared system the run validated in, or why it ran alone. */
+    system?: EnvRunSystem;
+}
+export interface EnvRunSystem {
+    name: string;
+    applied?: boolean;
+    reason?: "not_member" | "unreadable" | "missing";
+}
+/** `in system gpx`, or `ran alone: <why>` when the system was not applied. */
+export declare function formatSystem(system: EnvRunSystem): string;
+export declare const ENV_POLL_INTERVAL_MS = 3000;
+export declare const ENV_USAGE: string;
+/**
+ * `owner/name` from a git remote URL: https (`https://github.com/o/n.git`),
+ * ssh (`ssh://git@github.com/o/n`) or scp-like (`git@github.com:o/n.git`).
+ * The `.git` suffix and a trailing slash are optional. Undefined otherwise.
+ */
+export declare function parseRemoteRepo(url: string): string | undefined;
+/**
+ * A remote URL safe to print: the username and password (a token, often)
+ * are dropped from a URL remote, and the user from an scp-like one.
+ */
+export declare function redactRemote(url: string): string;
+/** A validated `owner/name` given on the command line, `.git` allowed. */
+export declare function parseRepoArg(raw: string): string | undefined;
+/**
+ * A step's time as a person reads it: `41 s`, `11 m 20 s`, `2 h 5 m`. Mirrors
+ * `qaStepDuration` in `@yagni/shared` (`packages/shared/src/qa.ts`), which this
+ * self-contained package cannot import; keep the two in step.
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * The lines one step prints when it reaches a state. `pending` prints
+ * nothing; a failed step prints its output tail, indented.
+ */
+export declare function formatStep(step: EnvRunStep): string[];
+/**
+ * The lines this read adds: every step whose state moved since the last
+ * read. `seen` is updated in place.
+ */
+export declare function stepTransitions(steps: EnvRunStep[], seen: Map<number, EnvStepState>): string[];
+export interface EnvRequest {
+    baseUrl: string;
+    token: string;
+    fetchImpl: typeof fetch;
+}
+/** Start the check: the run's revision id, or the reason it did not start. */
+export declare function startCheck(req: EnvRequest, repo: string): Promise<{
+    revisionId: string;
+} | {
+    error: string;
+}>;
+export interface PollOptions extends EnvRequest {
+    revisionId: string;
+    sleep: (ms: number) => Promise<void>;
+    writeOut: (line: string) => void;
+    writeErr: (line: string) => void;
+    intervalMs?: number;
+}
+/** Poll the run until it settles; the command's exit code. */
+export declare function pollRun(opts: PollOptions): Promise<number>;
+export interface EnvDeps {
+    loadCredentials?: () => Promise<{
+        token?: string;
+        baseUrl: string;
+        name: string;
+    }>;
+    fetchImpl?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    /** The current directory's `origin` remote URL, or undefined. */
+    originUrl?: (cwd: string) => Promise<string | undefined>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    writeOut?: (line: string) => void;
+    writeErr?: (line: string) => void;
+}
+/** `--repo owner/name` or `--repo=owner/name`; `error` names a bad argument. */
+export declare function parseEnvCheckArgs(args: string[]): {
+    repo?: string;
+    error?: string;
+};
+/** `yagni env <subcommand>`; only `check` exists. */
+export declare function envCommand(args: string[], deps?: EnvDeps, _cliVersion?: string): Promise<number>;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.js

@@ -0,0 +1,332 @@
+/**
+ * `yagni env check [--repo owner/name]` (YAG-1109): validate a repository's
+ * environment as it stands, without repair, and print each step as it runs.
+ *
+ * The repository defaults to the current directory's `origin` remote. The
+ * command starts the check (`POST /api/yagni-code/environment/check`), then
+ * polls the run (`GET /api/yagni-code/environment/runs/:revisionId`) every
+ * 3 s. Exit codes: 0 ready, 1 needs attention, 2 a request or usage error.
+ *
+ * The remote parser, the step formatter and the poll loop are pure, with
+ * `fetch` and `sleep` injected, so they test without a network.
+ */
+import { execFile } from "node:child_process";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+/** `in system gpx`, or `ran alone: <why>` when the system was not applied. */
+export function formatSystem(system) {
+    if (system.applied !== false)
+        return `in system ${system.name}`;
+    const why = system.reason === "not_member"
+        ? `not a member of system ${system.name}`
+        : system.reason === "unreadable"
+            ? `system ${system.name} could not be read`
+            : system.reason === "missing"
+                ? `system ${system.name} no longer exists`
+                : `system ${system.name} was not applied`;
+    return `ran alone: ${why}`;
+}
+export const ENV_POLL_INTERVAL_MS = 3_000;
+/** Consecutive failed reads of the run before the command gives up. */
+const MAX_READ_FAILURES = 3;
+export const ENV_USAGE = [
+    "Usage: yagni env check [--repo owner/name]",
+    "",
+    "Validates the repository's environment as it stands, without repair.",
+    "The repository defaults to this directory's origin remote.",
+    "Exits 0 when ready, 1 when it needs attention, 2 on a request error.",
+].join("\n");
+/**
+ * `owner/name` from a git remote URL: https (`https://github.com/o/n.git`),
+ * ssh (`ssh://git@github.com/o/n`) or scp-like (`git@github.com:o/n.git`).
+ * The `.git` suffix and a trailing slash are optional. Undefined otherwise.
+ */
+export function parseRemoteRepo(url) {
+    const trimmed = url
+        .trim()
+        .replace(/\/+$/, "")
+        .replace(/\.git$/, "");
+    let path;
+    if (trimmed.includes("://")) {
+        try {
+            path = new URL(trimmed).pathname;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        const scp = /^(?:[^@/\s]+@)?[^:/\s]+:(.+)$/.exec(trimmed);
+        if (!scp)
+            return undefined;
+        path = scp[1];
+    }
+    // Exactly owner and name: a longer path (an Azure DevOps `_git` path, a
+    // nested group) is never guessed at.
+    const segments = path.split("/").filter(Boolean);
+    if (segments.length !== 2)
+        return undefined;
+    const [owner, name] = segments;
+    const part = /^[A-Za-z0-9._-]+$/;
+    return part.test(owner) && part.test(name) ? `${owner}/${name}` : undefined;
+}
+/**
+ * A remote URL safe to print: the username and password (a token, often)
+ * are dropped from a URL remote, and the user from an scp-like one.
+ */
+export function redactRemote(url) {
+    const trimmed = url.trim();
+    if (trimmed.includes("://")) {
+        try {
+            const parsed = new URL(trimmed);
+            parsed.username = "";
+            parsed.password = "";
+            return parsed.toString();
+        }
+        catch {
+            return trimmed.replace(/^([^:/]+:\/\/)[^/]*@/, "$1");
+        }
+    }
+    return trimmed.replace(/^[^/\s]*@/, "");
+}
+/** A validated `owner/name` given on the command line, `.git` allowed. */
+export function parseRepoArg(raw) {
+    const repo = raw.trim().replace(/\.git$/, "");
+    return /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(repo) ? repo : undefined;
+}
+/**
+ * A step's time as a person reads it: `41 s`, `11 m 20 s`, `2 h 5 m`. Mirrors
+ * `qaStepDuration` in `@yagni/shared` (`packages/shared/src/qa.ts`), which this
+ * self-contained package cannot import; keep the two in step.
+ */
+export function formatDuration(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds} s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return seconds % 60 ? `${minutes} m ${seconds % 60} s` : `${minutes} m`;
+    const hours = Math.floor(minutes / 60);
+    return minutes % 60 ? `${hours} h ${minutes % 60} m` : `${hours} h`;
+}
+/**
+ * The lines one step prints when it reaches a state. `pending` prints
+ * nothing; a failed step prints its output tail, indented.
+ */
+export function formatStep(step) {
+    const line = step.line !== undefined ? ` (line ${step.line})` : "";
+    const took = step.durationMs !== undefined ? ` ${formatDuration(step.durationMs)}` : "";
+    switch (step.state) {
+        case "running":
+            return [`… ${step.label}`];
+        case "done":
+            return [`✓ ${step.label}${took}`];
+        case "skipped":
+            return [`- ${step.label} skipped`];
+        case "failed": {
+            const tail = (step.outputTail ?? "")
+                .split("\n")
+                .filter((l) => l.trim().length > 0)
+                .map((l) => `    ${l}`);
+            return [`✗ ${step.label}${line}${took}`, ...tail];
+        }
+        default:
+            return [];
+    }
+}
+/**
+ * The lines this read adds: every step whose state moved since the last
+ * read. `seen` is updated in place.
+ */
+export function stepTransitions(steps, seen) {
+    const out = [];
+    for (const step of [...steps].sort((a, b) => a.index - b.index)) {
+        if (seen.get(step.index) === step.state)
+            continue;
+        seen.set(step.index, step.state);
+        out.push(...formatStep(step));
+    }
+    return out;
+}
+function apiUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/$/, "")}/api/yagni-code${path}`;
+}
+async function errorText(res) {
+    const body = (await res.json().catch(() => ({})));
+    const detail = typeof body.error === "string" ? body.error : "";
+    if (res.status === 401)
+        return "Your login has expired. Run `yagni login` and try again.";
+    return detail ? `${detail} (HTTP ${res.status})` : `The server answered HTTP ${res.status}.`;
+}
+/** Start the check: the run's revision id, or the reason it did not start. */
+export async function startCheck(req, repo) {
+    try {
+        const res = await req.fetchImpl(apiUrl(req.baseUrl, "/environment/check"), {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${req.token}` },
+            body: JSON.stringify({ repo }),
+            signal: AbortSignal.timeout(60_000),
+        });
+        if (!res.ok)
+            return { error: await errorText(res) };
+        const body = (await res.json());
+        return typeof body.revisionId === "string"
+            ? { revisionId: body.revisionId }
+            : { error: "The server did not say which run started." };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function readRun(req, revisionId) {
+    try {
+        const res = await req.fetchImpl(apiUrl(req.baseUrl, `/environment/runs/${encodeURIComponent(revisionId)}`), {
+            headers: { authorization: `Bearer ${req.token}` },
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok)
+            return { error: await errorText(res) };
+        const body = (await res.json());
+        return {
+            status: body.status ?? "validating",
+            message: body.message ?? "",
+            steps: Array.isArray(body.steps) ? body.steps : [],
+            notes: Array.isArray(body.notes) ? body.notes : [],
+            ...(body.outputTail ? { outputTail: body.outputTail } : {}),
+            ...(body.system && typeof body.system.name === "string" ? { system: body.system } : {}),
+        };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** Poll the run until it settles; the command's exit code. */
+export async function pollRun(opts) {
+    const seen = new Map();
+    let failures = 0;
+    let systemSaid = false;
+    for (;;) {
+        const run = await readRun(opts, opts.revisionId);
+        if ("error" in run) {
+            failures += 1;
+            if (failures >= MAX_READ_FAILURES) {
+                opts.writeErr(`Could not read the run: ${run.error}`);
+                return 2;
+            }
+        }
+        else {
+            failures = 0;
+            if (run.system && !systemSaid) {
+                systemSaid = true;
+                opts.writeOut(formatSystem(run.system));
+            }
+            for (const line of stepTransitions(run.steps, seen))
+                opts.writeOut(line);
+            if (run.status !== "validating") {
+                const failedTail = run.steps.some((s) => s.state === "failed" && s.outputTail);
+                if (run.status === "needs_attention" && run.outputTail && !failedTail) {
+                    for (const line of run.outputTail.split("\n").filter((l) => l.trim()))
+                        opts.writeOut(`    ${line}`);
+                }
+                for (const note of run.notes)
+                    opts.writeOut(`note: ${note}`);
+                if (run.status === "ready") {
+                    opts.writeOut(run.message ? `Ready. ${run.message}` : "Ready.");
+                    return 0;
+                }
+                opts.writeOut(run.message ? `Needs attention: ${run.message}` : "Needs attention.");
+                return 1;
+            }
+        }
+        await opts.sleep(opts.intervalMs ?? ENV_POLL_INTERVAL_MS);
+    }
+}
+function gitOriginUrl(cwd) {
+    return new Promise((resolve) => {
+        execFile("git", ["remote", "get-url", "origin"], { cwd, timeout: 10_000 }, (err, stdout) => resolve(err ? undefined : stdout.trim() || undefined));
+    });
+}
+/** `--repo owner/name` or `--repo=owner/name`; `error` names a bad argument. */
+export function parseEnvCheckArgs(args) {
+    let repo;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            const value = args[++i];
+            if (!value)
+                return { error: "--repo needs owner/name" };
+            repo = value;
+        }
+        else if (a.startsWith("--repo=")) {
+            repo = a.slice("--repo=".length);
+        }
+        else {
+            return { error: `Unknown argument: ${a}` };
+        }
+    }
+    if (repo === undefined)
+        return {};
+    const parsed = parseRepoArg(repo);
+    return parsed ? { repo: parsed } : { error: `Not a repository: ${repo} (expected owner/name)` };
+}
+/** `yagni env <subcommand>`; only `check` exists. */
+export async function envCommand(args, deps = {}, _cliVersion) {
+    const writeOut = deps.writeOut ?? ((line) => void process.stdout.write(`${line}\n`));
+    const writeErr = deps.writeErr ?? ((line) => void process.stderr.write(`${line}\n`));
+    const [sub, ...rest] = args;
+    if (sub !== "check") {
+        (sub === undefined ? writeOut : writeErr)(ENV_USAGE);
+        return sub === undefined ? 0 : 2;
+    }
+    const parsed = parseEnvCheckArgs(rest);
+    if (parsed.error) {
+        writeErr(parsed.error);
+        writeErr(ENV_USAGE);
+        return 2;
+    }
+    const cwd = deps.cwd ?? process.cwd();
+    let repo = parsed.repo;
+    if (!repo) {
+        const url = await (deps.originUrl ?? gitOriginUrl)(cwd);
+        repo = url ? parseRemoteRepo(url) : undefined;
+        if (!repo) {
+            writeErr(url
+                ? `Could not read the repository from the origin remote (${redactRemote(url)}). Pass --repo owner/name.`
+                : "This directory has no origin remote. Pass --repo owner/name.");
+            return 2;
+        }
+    }
+    const env = deps.env ?? process.env;
+    const profile = await (deps.loadCredentials ??
+        (async () => {
+            const active = await readActiveProfile(env);
+            const creds = credentialsFromProfile(active);
+            return {
+                name: active.name,
+                baseUrl: active.baseUrl,
+                ...(creds?.token ? { token: creds.token } : {}),
+            };
+        }))();
+    if (!profile.token) {
+        writeErr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.`);
+        return 2;
+    }
+    const req = {
+        baseUrl: profile.baseUrl,
+        token: profile.token,
+        fetchImpl: deps.fetchImpl ?? fetch,
+    };
+    const started = await startCheck(req, repo);
+    if ("error" in started) {
+        writeErr(`Could not start the check for ${repo}: ${started.error}`);
+        return 2;
+    }
+    writeOut(`Validating ${repo} as it stands, without repair.`);
+    return pollRun({
+        ...req,
+        revisionId: started.revisionId,
+        sleep: deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+        writeOut,
+        writeErr,
+    });
+}
+//# sourceMappingURL=env.js.map

package/dist/extension/index.js

@@ -48,6 +48,7 @@ import { createGrantCensus } from "./permission/grantCensus.js";
 import { runsInSandboxHarness, toolchainBashToolDefinition, toolchainSpawnHookFromEnv, toolchainUserBashOperations, } from "./toolchain/spawnHook.js";
 import { CLOUD_SESSION_ENV } from "./pipeline/cloud.js";
 import { registerStageClock } from "./pipeline/stageClock.js";
+import { registerBashDefaultTimeout } from "./toolchain/bashDefaultTimeout.js";
 import { scrubSecrets } from "./pipeline/scrubSecrets.js";
 import { registerTelemetry as defaultRegisterTelemetry } from "./telemetry/register.js";
 import { loadHooksConfig, makeHookRunner, registerHooks } from "./hooks.js";
@@ -176,6 +177,9 @@ export async function registerYagni(pi, deps = {}) {
     // not matter: pi runs every tool_call handler until one blocks, and an allow
     // (a result without `block`) never ends the loop, so this block always lands.
     registerStageClock(pi, env, now);
+    // A sandbox session's bash call without a timeout gets a default one, so a
+    // command that never exits cannot hold the session. It never blocks.
+    registerBashDefaultTimeout(pi, env);
     // The grounding settings switch (the judgment-loop kill switch): resolved
     // ONCE at boot from the USER-tier config (default on; a malformed config
     // fails soft to on with a sink warn). Eval mode is its own carve-out and

package/dist/extension/toolchain/bashDefaultTimeout.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A default timeout for bash in a sandbox session. Pi's bash has none, so a
+ * command that never exits (a server, an interactive prompt) holds the whole
+ * session until an outer clock stops it. A rails build session on staging
+ * went quiet for 35 minutes after one such call (YAG-1130).
+ */
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/**
+ * Ten minutes: long enough for an install or a test suite, short enough that a
+ * command that never exits does not hold the session. The model can pass a
+ * longer `timeout`, and pi's timed-out result tells it so.
+ */
+export declare const SANDBOX_BASH_TIMEOUT_SECONDS = 600;
+/**
+ * Give every bash call without a positive timeout the default one. pi's bash
+ * treats 0 as no timeout, so 0, negatives and non-numbers get it too; every
+ * positive number the model asked for stays. A background call
+ * (`run_in_background`) is left alone: it returns at once, so it cannot hold
+ * the session, and the sandbox's background job (`sandbox/session.ts`) kills
+ * the job when its timeout runs out, which would stop a backgrounded server.
+ * It never blocks. A developer's own terminal (no sandbox harness) gets
+ * nothing.
+ */
+export declare function registerBashDefaultTimeout(pi: Pick<ExtensionAPI, "on">, env: NodeJS.ProcessEnv, seconds?: number): void;
+//# sourceMappingURL=bashDefaultTimeout.d.ts.map

package/dist/extension/toolchain/bashDefaultTimeout.js

@@ -0,0 +1,40 @@
+/**
+ * A default timeout for bash in a sandbox session. Pi's bash has none, so a
+ * command that never exits (a server, an interactive prompt) holds the whole
+ * session until an outer clock stops it. A rails build session on staging
+ * went quiet for 35 minutes after one such call (YAG-1130).
+ */
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import { runsInSandboxHarness } from "./spawnHook.js";
+/**
+ * Ten minutes: long enough for an install or a test suite, short enough that a
+ * command that never exits does not hold the session. The model can pass a
+ * longer `timeout`, and pi's timed-out result tells it so.
+ */
+export const SANDBOX_BASH_TIMEOUT_SECONDS = 600;
+/**
+ * Give every bash call without a positive timeout the default one. pi's bash
+ * treats 0 as no timeout, so 0, negatives and non-numbers get it too; every
+ * positive number the model asked for stays. A background call
+ * (`run_in_background`) is left alone: it returns at once, so it cannot hold
+ * the session, and the sandbox's background job (`sandbox/session.ts`) kills
+ * the job when its timeout runs out, which would stop a backgrounded server.
+ * It never blocks. A developer's own terminal (no sandbox harness) gets
+ * nothing.
+ */
+export function registerBashDefaultTimeout(pi, env, seconds = SANDBOX_BASH_TIMEOUT_SECONDS) {
+    if (!runsInSandboxHarness(env))
+        return;
+    pi.on("tool_call", async (event) => {
+        if (!isToolCallEventType("bash", event))
+            return undefined;
+        const input = event.input;
+        if (input.run_in_background === true)
+            return undefined;
+        if (typeof input.timeout === "number" && input.timeout > 0)
+            return undefined;
+        event.input.timeout = seconds;
+        return undefined;
+    });
+}
+//# sourceMappingURL=bashDefaultTimeout.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.13-staging.2190.1",
+  "version": "1.2.13-staging.2198.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "515314459213f3e3acff697e5807da8ae3c5ce4a"
+  "yagniSourceSha": "a784a903593e5a0174b06dff4e34cc21fff4be4b"
 }