@intentic/sandbox-contract 1.326.0 → 1.328.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/sandbox-contract",
-  "version": "1.326.0",
+  "version": "1.328.0",
   "description": "oRPC wire contract for the intentic sandbox daemon, shared by the daemon and its browser client",
   "license": "MIT",
   "type": "module",
@@ -40,6 +40,28 @@
         "default": "./dist/chores/index.js"
       }
     },
+    "./message-limits": {
+      "types": "./dist/policy/message-limits.d.ts",
+      "import": {
+        "@intentic/src": "./src/policy/message-limits.ts",
+        "default": "./dist/policy/message-limits.js"
+      },
+      "require": {
+        "@intentic/src": "./src/policy/message-limits.ts",
+        "default": "./dist/policy/message-limits.js"
+      }
+    },
+    "./workspace-state": {
+      "types": "./dist/state/workspace-state.d.ts",
+      "import": {
+        "@intentic/src": "./src/state/workspace-state.ts",
+        "default": "./dist/state/workspace-state.js"
+      },
+      "require": {
+        "@intentic/src": "./src/state/workspace-state.ts",
+        "default": "./dist/state/workspace-state.js"
+      }
+    },
     "./batch-runs": {
       "types": "./dist/policy/batch-runs.d.ts",
       "import": {
@@ -106,6 +128,39 @@
         "default": "./dist/ids/tunnel-ids.js"
       }
     },
+    "./headers": {
+      "types": "./dist/protocol/headers.d.ts",
+      "import": {
+        "@intentic/src": "./src/protocol/headers.ts",
+        "default": "./dist/protocol/headers.js"
+      },
+      "require": {
+        "@intentic/src": "./src/protocol/headers.ts",
+        "default": "./dist/protocol/headers.js"
+      }
+    },
+    "./listener-protocol": {
+      "types": "./dist/protocol/doors/listener-protocol.d.ts",
+      "import": {
+        "@intentic/src": "./src/protocol/doors/listener-protocol.ts",
+        "default": "./dist/protocol/doors/listener-protocol.js"
+      },
+      "require": {
+        "@intentic/src": "./src/protocol/doors/listener-protocol.ts",
+        "default": "./dist/protocol/doors/listener-protocol.js"
+      }
+    },
+    "./extension-protocol": {
+      "types": "./dist/protocol/raw/extension-protocol.d.ts",
+      "import": {
+        "@intentic/src": "./src/protocol/raw/extension-protocol.ts",
+        "default": "./dist/protocol/raw/extension-protocol.js"
+      },
+      "require": {
+        "@intentic/src": "./src/protocol/raw/extension-protocol.ts",
+        "default": "./dist/protocol/raw/extension-protocol.js"
+      }
+    },
     "./edge-verdict": {
       "types": "./dist/protocol/edge-verdict.d.ts",
       "import": {
@@ -161,26 +216,26 @@
         "default": "./dist/policy/owner-ticket.js"
       }
     },
-    "./front-wire": {
-      "types": "./dist/front/front-wire.d.ts",
+    "./netd-wire": {
+      "types": "./dist/netd/netd-wire.d.ts",
       "import": {
-        "@intentic/src": "./src/front/front-wire.ts",
-        "default": "./dist/front/front-wire.js"
+        "@intentic/src": "./src/netd/netd-wire.ts",
+        "default": "./dist/netd/netd-wire.js"
       },
       "require": {
-        "@intentic/src": "./src/front/front-wire.ts",
-        "default": "./dist/front/front-wire.js"
+        "@intentic/src": "./src/netd/netd-wire.ts",
+        "default": "./dist/netd/netd-wire.js"
       }
     },
     "./browser-wire": {
-      "types": "./dist/front/browser-wire.d.ts",
+      "types": "./dist/netd/browser-wire.d.ts",
       "import": {
-        "@intentic/src": "./src/front/browser-wire.ts",
-        "default": "./dist/front/browser-wire.js"
+        "@intentic/src": "./src/netd/browser-wire.ts",
+        "default": "./dist/netd/browser-wire.js"
       },
       "require": {
-        "@intentic/src": "./src/front/browser-wire.ts",
-        "default": "./dist/front/browser-wire.js"
+        "@intentic/src": "./src/netd/browser-wire.ts",
+        "default": "./dist/netd/browser-wire.js"
       }
     },
     "./share-paths": {
@@ -239,22 +294,22 @@
       }
     },
     "./webext-links": {
-      "types": "./dist/protocol/webext-links.d.ts",
+      "types": "./dist/protocol/doors/webext-links.d.ts",
       "import": {
-        "@intentic/src": "./src/protocol/webext-links.ts",
-        "default": "./dist/protocol/webext-links.js"
+        "@intentic/src": "./src/protocol/doors/webext-links.ts",
+        "default": "./dist/protocol/doors/webext-links.js"
       },
       "require": {
-        "@intentic/src": "./src/protocol/webext-links.ts",
-        "default": "./dist/protocol/webext-links.js"
+        "@intentic/src": "./src/protocol/doors/webext-links.ts",
+        "default": "./dist/protocol/doors/webext-links.js"
       }
     }
   },
   "dependencies": {
-    "@intentic/base": "1.326.0",
-    "@intentic/constants": "1.326.0",
-    "@intentic/extension-manifest": "1.326.0",
-    "@intentic/registry": "1.326.0",
+    "@intentic/base": "1.328.0",
+    "@intentic/constants": "1.328.0",
+    "@intentic/extension-manifest": "1.328.0",
+    "@intentic/registry": "1.328.0",
     "@orpc/contract": "1.15.4",
     "tslib": "2.8.1",
     "zod": "4.6.5"
@@ -263,7 +318,7 @@
     "@intentic/testing": "0.0.0",
     "@intentic/tsconfig": "0.0.0",
     "@types/bun": "1.4.2",
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2"
   },
   "scripts": {

package/src/chores/chores.ts

@@ -1,6 +1,7 @@
 import type { Advisory, ChoreSignals, OutdatedPackage, ProbeId, ProbeResult } from "../schemas/maintenance.js";
-import { plural } from "@intentic/base/format";
+import { plural, sizeLabel } from "@intentic/base/format";
 import { bucketOf, digestOf } from "./digest.js";
+import { AUDIT_COMMAND } from "./probes.js";
 import { CHORE_INVARIANTS, composeAsk, REPORT_INVARIANTS, TRIAGE_NOTE } from "./prompt.js";
 import { componentStem, frameworksOf, idiomRule, normalizePath, UI_FRAMEWORKS, usesTailwind } from "./stack.js";
 import { WORKSPACE_ROOT_JSCPD_EXCLUDE_ARG } from "./workspace-scope.js";
@@ -97,9 +98,18 @@ export const repoLabel = (repo: string): string => (repo === `root` || repo ===
 // workspace root reposi…").
 export const repoName = (repo: string): string => (repo === `root` || repo === `` ? `workspace root` : repo);
 
+// Where a finding lives when it is not the workspace's own tree: a package pnpm-workspace.yaml leaves out, whose fix
+// goes in its own package.json. Empty for the workspace, so its lines read as they always did.
+const whereOf = (finding: { readonly standalone?: string | undefined }): string =>
+    finding.standalone === undefined ? `` : ` in ${finding.standalone}`;
+// The same folder prefixed to a digest identity; a workspace finding keeps the identity it always had, so this change
+// rebadges nothing that was already settled.
+const identityOf = (finding: { readonly standalone?: string | undefined }, identity: string): string =>
+    finding.standalone === undefined ? identity : `${finding.standalone}:${identity}`;
+
 // One outdated dependency, as the panel lists it; the semver step leads, since it decides whether the row is a
 // morning's work or a project.
-const outdatedLine = (entry: OutdatedPackage): string => `${entry.kind} · ${entry.name} ${entry.current} → ${entry.latest}`;
+const outdatedLine = (entry: OutdatedPackage): string => `${entry.kind} · ${entry.name}${whereOf(entry)} ${entry.current} → ${entry.latest}`;
 
 // The facts of a probe that actually ran; anything else (never run, unavailable, failed) reads as absent, so
 // assess() can't mistake an unmeasured repo for a clean one.
@@ -124,7 +134,7 @@ const security: Chore = {
     icon: `shield`,
     description: `Published advisories against this dependency tree, and the ones whose fix is a version bump.`,
     kind: `carrying`,
-    criterion: `pnpm audit reports an advisory of high or critical severity against the resolved tree.`,
+    criterion: `pnpm audit reports an advisory of high or critical severity against the resolved tree, or against a package the workspace leaves out.`,
     applies: (signals) => (signals.shape.lockfile ? undefined : `no lockfile`),
     stance: `act`,
     needs: [`audit`],
@@ -132,11 +142,14 @@ const security: Chore = {
     automation: {
         cron: `0 4 * * *`,
         guard:
-            `pnpm audit --json > ${AUDIT_REPORT} 2>/dev/null; ` +
-            `[ "$(jq '(.metadata.vulnerabilities.high // 0) + (.metadata.vulnerabilities.critical // 0)' ${AUDIT_REPORT} 2>/dev/null || echo 0)" -gt 0 ]`,
+            `{ ${AUDIT_COMMAND}; } > ${AUDIT_REPORT}; ` +
+            `[ "$(jq -s '[.[] | .metadata.vulnerabilities? // empty | (.high // 0) + (.critical // 0)] | add // 0' ${AUDIT_REPORT} 2>/dev/null || echo 0)" -gt 0 ]`,
         note: `nightly · high + critical only`,
         report: AUDIT_REPORT,
-        woke: `pnpm audit's report for this workspace is in ${AUDIT_REPORT} (JSON), and it woke you because it carries a high or critical advisory.`,
+        woke:
+            `pnpm audit's report for this workspace is in ${AUDIT_REPORT}, a stream of JSON documents (read it with \`jq -s\`): pnpm's own ` +
+            `report first, then for each package the workspace leaves out a \`{"standalone": dir}\` line and that package's report. ` +
+            `It woke you because it carries a high or critical advisory.`,
     },
     assess: (context) => {
         const facts = factsOf(context, `audit`);
@@ -155,18 +168,18 @@ const security: Chore = {
                 .toSorted((left, right) => left.name.localeCompare(right.name))
                 .map(
                     (advisory) =>
-                        `${advisory.severity} · ${advisory.name}, ${advisory.title}${advisory.patched === undefined ? ` (no patch yet)` : ``}`,
+                        `${advisory.severity} · ${advisory.name}${whereOf(advisory)}, ${advisory.title}${advisory.patched === undefined ? ` (no patch yet)` : ``}`,
                 ),
             // Identities, not counts: every advisory that appears or is fixed is genuinely news, with no ordinary drift
             // to absorb.
-            digest: digestOf(...blocking.map((advisory) => `${advisory.name}@${advisory.severity}`).toSorted()),
+            digest: digestOf(...blocking.map((advisory) => identityOf(advisory, `${advisory.name}@${advisory.severity}`)).toSorted()),
             severity: production.length > 0 ? `warning` : `info`,
             // Named, not counted; re-deriving the list itself would be slow, and pnpm audit would read a different tree
             // by then.
             why:
                 `pnpm audit reports ${plural(blocking.length, `high or critical advisory`, `high or critical advisories`)} against ` +
                 `${repoLabel(context.repo)}, ${production.length} reaching a production dependency path, ${patchable.length} with a published patched range: ` +
-                `${blocking.map((advisory) => `${advisory.name} (${advisory.severity}${advisory.dev ? `, dev-only` : ``}${advisory.patched === undefined ? `, no patch` : `, fixed in ${advisory.patched}`})`).join(`; `)}.`,
+                `${blocking.map((advisory) => `${advisory.name}${whereOf(advisory)} (${advisory.severity}${advisory.dev ? `, dev-only` : ``}${advisory.patched === undefined ? `, no patch` : `, fixed in ${advisory.patched}`})`).join(`; `)}.`,
         };
     },
     diagnosis: `An advisory with a published fix is a version bump someone has to actually make; one without is a risk to decide about.`,
@@ -174,8 +187,12 @@ const security: Chore = {
         `For each advisory, establish whether this workspace reaches the vulnerable code path at all: a transitive dependency of a ` +
         `build-time tool is a different problem from one in a running service. Where the fix is a version bump the lockfile can absorb, ` +
         `make it. Where it needs a real upgrade or has no patch published, leave it and say what it would take. Never rewrite ` +
-        `application code to route around a CVE.`,
-    done: `Done when \`pnpm audit\` reports fewer high/critical advisories than it did, and the type-check and tests of what it changed pass.`,
+        `application code to route around a CVE. An advisory named "in <folder>" is in a package the pnpm workspace leaves out ` +
+        `and installs on its own: bump it in that folder's package.json, and check it by auditing a scratch copy of the folder ` +
+        `(\`pnpm install --lockfile-only --ignore-workspace\`, then \`pnpm audit --ignore-workspace\`), never by leaving a lockfile in it.`,
+    done:
+        `Done when \`pnpm audit\`, and the scratch-copy audit of any folder you touched, reports fewer high/critical advisories than ` +
+        `it did, and the type-check and tests of what it changed pass.`,
 };
 
 // Majors are the finding, the total is context: the digest is keyed to which packages have a major waiting, with
@@ -210,14 +227,17 @@ const dependencies: Chore = {
                     ? `${plural(facts.packages.length, `package`)} behind`
                     : `${plural(majors.length, `major`)} waiting, ${facts.packages.length} behind in total`,
             detail: majors.toSorted((left, right) => left.name.localeCompare(right.name)).map(outdatedLine),
-            digest: digestOf(...majors.map((entry) => `${entry.name}@${entry.latest}`).toSorted(), `total:${bucketOf(facts.packages.length)}`),
+            digest: digestOf(
+                ...majors.map((entry) => identityOf(entry, `${entry.name}@${entry.latest}`)).toSorted(),
+                `total:${bucketOf(facts.packages.length)}`,
+            ),
             severity: `info`,
             // Majors are named since they are what the turn is about; minors and patches are a bulk operation the agent
             // enumerates itself.
             why:
                 `pnpm outdated reports ${plural(facts.packages.length, `dependency`, `dependencies`)} behind the registry in ` +
                 `${repoLabel(context.repo)}, ${majors.length} of them by a major version` +
-                `${majors.length === 0 ? `` : `: ${majors.map((entry) => `${entry.name} ${entry.current} → ${entry.latest}`).join(`; `)}`}.`,
+                `${majors.length === 0 ? `` : `: ${majors.map((entry) => `${entry.name}${whereOf(entry)} ${entry.current} → ${entry.latest}`).join(`; `)}`}.`,
         };
     },
     diagnosis: `Version drift is cheap to fix continuously and expensive to fix in one go, because the majors start depending on each other.`,
@@ -225,7 +245,9 @@ const dependencies: Chore = {
         `Take the patch and minor upgrades in one pass: those are what the lockfile can absorb without argument. Then take the majors ` +
         `ONE AT A TIME, reading each one's changelog for breaking changes before you touch anything, and stop at the first one that ` +
         `needs more than a mechanical fix: leave it, and say what it would take. Do not batch majors; a failing test after eight of them ` +
-        `is a bisect nobody wanted.`,
+        `is a bisect nobody wanted. Where a manifest says \`catalog:\`, the version lives in the catalog in pnpm-workspace.yaml: bump ` +
+        `it there, once, then \`pnpm install\`. A dependency named "in <folder>" is in a package the workspace leaves out and installs ` +
+        `on its own, so it is bumped in that folder's package.json.`,
     done: `Done when the type-check and tests of what it changed pass, and your summary names every major you took and every one you left, with the reason.`,
 };
 
@@ -609,8 +631,6 @@ const FRAMEWORK_LABELS = UI_FRAMEWORKS.map((framework) => framework.label).join(
 const needsFramework = (signals: ChoreSignals): string | undefined =>
     frameworksOf(signals.shape.deps).length > 0 ? undefined : `no ${FRAMEWORK_LABELS}`;
 
-const bytesLabel = (bytes: number): string => (bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(bytes / 1024)} kB`);
-
 // The criterion is a share of total size, not a byte threshold, since a byte value would need a different number
 // per app. Report-stance: where to split is a product decision no unattended agent should make.
 const BUNDLE_SHARE_FLOOR = 50;
@@ -653,10 +673,10 @@ const bundleWeight: Chore = {
             return undefined;
         }
         return {
-            headline: `${largest.path} is ${Math.round(share)}% of the ${bytesLabel(totalGzip)} this build ships`,
+            headline: `${largest.path} is ${Math.round(share)}% of the ${sizeLabel(totalGzip)} this build ships`,
             detail: ranked
                 .slice(0, DETAIL_LIMIT)
-                .map((asset) => `${bytesLabel(asset.gzip)} gzipped · ${asset.path} (${bytesLabel(asset.bytes)} on disk)`),
+                .map((asset) => `${sizeLabel(asset.gzip)} gzipped · ${asset.path} (${sizeLabel(asset.bytes)} on disk)`),
             // The bucketed total and hash-stripped identities of the biggest chunks; a rebuild of the same code stays
             // silent, a new heavy chunk doesn't.
             digest: digestOf(
@@ -669,11 +689,11 @@ const bundleWeight: Chore = {
             // Not a risk being carried, however large; `warning` is reserved for something with a clock on it.
             severity: `info`,
             why:
-                `The build output in ${dir}/ of ${repoLabel(context.repo)} is ${bytesLabel(totalGzip)} gzipped across ` +
-                `${plural(assets.length, `asset`)}, and ${largest.path} alone is ${bytesLabel(largest.gzip)} of it: ${Math.round(share)}%. ` +
+                `The build output in ${dir}/ of ${repoLabel(context.repo)} is ${sizeLabel(totalGzip)} gzipped across ` +
+                `${plural(assets.length, `asset`)}, and ${largest.path} alone is ${sizeLabel(largest.gzip)} of it: ${Math.round(share)}%. ` +
                 `The next largest are ${ranked
                     .slice(1, 4)
-                    .map((asset) => `${asset.path} (${bytesLabel(asset.gzip)})`)
+                    .map((asset) => `${asset.path} (${sizeLabel(asset.gzip)})`)
                     .join(`, `)}. ` +
                 `This is the last build someone ran, read off disk; nothing rebuilt it to measure.`,
         };

package/src/chores/{probes.test.ts → probes.integration.test.ts}

@@ -1,5 +1,9 @@
+import { execFileSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 import { choreById } from "./chores.js";
-import { probeSpec } from "./probes.js";
+import { AUDIT_COMMAND, probeSpec } from "./probes.js";
 import { IDIOM_RULES } from "./stack.js";
 import { WORKSPACE_ROOT_JSCPD_EXCLUDE_ARG, WORKSPACE_ROOT_RG_EXCLUDE_ARG } from "./workspace-scope.js";
 
@@ -53,6 +57,49 @@ describe(`outdated`, () => {
     test(`output that is not JSON at all is a failure, never a clean result`, () => {
         expect(parse(`outdated`, `ERR_PNPM_NO_LOCKFILE  Cannot proceed`)).toBeUndefined();
     });
+
+    // pnpm 12's recursive report, verbatim in shape: a package seen as both a dependency and a devDependency is keyed
+    // `name@version` and `name@version (dev)`, which once surfaced as two rows under names no registry knows.
+    test(`reads pnpm 12's disambiguated keys as the package they name, one row per upgrade`, () => {
+        const facts = parse(
+            `outdated`,
+            JSON.stringify({
+                "mermaid@12.0.0 (dev)": { current: `12.0.0`, latest: `12.1.0`, dependencyType: `devDependencies` },
+                "mermaid@12.0.0": { current: `12.0.0`, latest: `12.1.0`, dependencyType: `dependencies` },
+                "@scope/tool@1.0.0 (dev)": { current: `1.0.0`, latest: `2.0.0`, dependencyType: `devDependencies` },
+                "@scope/tool@1.1.0": { current: `1.1.0`, latest: `2.0.0`, dependencyType: `dependencies` },
+            }),
+        );
+        expect(facts).toEqual({
+            id: `outdated`,
+            packages: [
+                // The shipped copy wins the section, whichever order pnpm listed them in.
+                { name: `mermaid`, current: `12.0.0`, latest: `12.1.0`, kind: `minor`, section: `dependencies` },
+                // Two versions in the tree are two upgrades, so they stay two rows.
+                { name: `@scope/tool`, current: `1.0.0`, latest: `2.0.0`, kind: `major`, section: `devDependencies` },
+                { name: `@scope/tool`, current: `1.1.0`, latest: `2.0.0`, kind: `major`, section: `dependencies` },
+            ],
+        });
+    });
+
+    test(`a package the workspace leaves out is measured too, and says which folder it is`, () => {
+        const stdout = [
+            JSON.stringify({ vue: { current: `3.4.1`, latest: `3.4.2`, dependencyType: `dependencies` } }, null, 2),
+            `{"standalone":"_editor/ios-app"}`,
+            JSON.stringify({ "@capacitor/ios": { current: `8.5.0`, latest: `8.5.2`, dependencyType: `dependencies` } }, null, 2),
+        ].join(`\n`);
+        expect(parse(`outdated`, stdout)).toEqual({
+            id: `outdated`,
+            packages: [
+                { name: `vue`, current: `3.4.1`, latest: `3.4.2`, kind: `patch`, section: `dependencies` },
+                { name: `@capacitor/ios`, current: `8.5.0`, latest: `8.5.2`, kind: `patch`, section: `dependencies`, standalone: `_editor/ios-app` },
+            ],
+        });
+    });
+
+    test(`a standalone package that printed nothing fails the probe rather than reading as up to date`, () => {
+        expect(parse(`outdated`, `{}\n{"standalone":"_editor/ios-app"}\n`)).toBeUndefined();
+    });
 });
 
 describe(`audit`, () => {
@@ -89,6 +136,92 @@ describe(`audit`, () => {
     });
 });
 
+// The audit command run for real, against a fake `pnpm` on PATH: what is under test is the shell (which folders count
+// as standalone, the scratch copy, the markers), not pnpm, and not the network.
+describe(`the audit command across packages the workspace leaves out`, () => {
+    const roots: string[] = [];
+    afterEach(() => {
+        for (const root of roots.splice(0)) {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+
+    // Reports one advisory named after the package it was run in, so the test can see where each run happened.
+    // `FAIL_INSTALL` stands in for a registry that cannot be reached.
+    const FAKE_PNPM = `#!/bin/sh
+name=$(sed -n 's/.*"name": *"\\([^"]*\\)".*/\\1/p' package.json)
+case "$*" in
+  *"install --lockfile-only"*) [ -z "$FAIL_INSTALL" ] || exit 1; echo "lockfileVersion: '9.0'" > pnpm-lock.yaml ;;
+  *audit*) printf '{"advisories":{"1":{"module_name":"%s","severity":"critical","title":"ran in %s","findings":[{"dev":false}]}}}\\n' "$name" "$PWD"; exit 1 ;;
+esac
+`;
+
+    const repo = (files: Record<string, string>): string => {
+        const root = mkdtempSync(join(tmpdir(), `probe-standalone-`));
+        roots.push(root);
+        for (const [path, text] of Object.entries({ ...files, "bin/pnpm": FAKE_PNPM })) {
+            mkdirSync(dirname(join(root, path)), { recursive: true });
+            writeFileSync(join(root, path), text);
+        }
+        chmodSync(join(root, `bin/pnpm`), 0o755);
+        return root;
+    };
+
+    const audit = (root: string, env: Record<string, string> = {}) =>
+        probeSpec(`audit`).parse(
+            execFileSync(`sh`, [`-c`, AUDIT_COMMAND], {
+                cwd: root,
+                encoding: `utf8`,
+                env: { ...process.env, ...env, PATH: `${join(root, `bin`)}:${process.env[`PATH`] ?? ``}` },
+            }),
+        );
+
+    const WORKSPACE = [
+        `packages:`,
+        `  - "app"`,
+        `  # The shell is installed on its own.`,
+        `  - "!shell"`,
+        `  - '!native/**'`,
+        `  - "!**/fixtures/**"`,
+        `  - "!gone"`,
+        `publicHoistPattern:`,
+        `  - "!app"`,
+        ``,
+    ].join(`\n`);
+
+    test(`audits each literal exclusion with a manifest, in a scratch copy, and names the folder`, () => {
+        const root = repo({
+            "pnpm-workspace.yaml": WORKSPACE,
+            "package.json": `{"name": "root"}`,
+            "app/package.json": `{"name": "app"}`,
+            "shell/package.json": `{"name": "shell"}`,
+            "native/package.json": `{"name": "native"}`,
+            "fixtures/x/package.json": `{"name": "fixture"}`,
+        });
+        const facts = audit(root);
+        const advisories = facts?.id === `audit` ? facts.advisories : [];
+        // The workspace's own report carries no folder; a fixture, a hoist pattern and a folder that is gone are not packages.
+        expect(advisories.map((advisory) => [advisory.name, advisory.standalone])).toEqual([
+            [`root`, undefined],
+            [`shell`, `shell`],
+            [`native`, `native`],
+        ]);
+        // Measured in a copy: nothing was written into the folder pnpm deliberately does not manage.
+        expect(existsSync(join(root, `shell/pnpm-lock.yaml`))).toBe(false);
+        expect(JSON.stringify(facts)).not.toContain(`ran in ${join(root, `shell`)}`);
+    });
+
+    test(`a standalone package that cannot be resolved fails the probe, never reads as clean`, () => {
+        const root = repo({ "pnpm-workspace.yaml": WORKSPACE, "package.json": `{"name": "root"}`, "shell/package.json": `{"name": "shell"}` });
+        expect(audit(root, { FAIL_INSTALL: `1` })).toBeUndefined();
+    });
+
+    test(`a repo with no workspace file is audited as it always was`, () => {
+        const root = repo({ "package.json": `{"name": "root"}` });
+        expect(audit(root)).toMatchObject({ advisories: [{ name: `root` }] });
+    });
+});
+
 describe(`knip`, () => {
     test(`sums the per-file issue arrays and samples the wholly unreferenced files`, () => {
         const facts = parse(