Skip to content

Turn any idea, plan, or codebase into a beautiful interactive diagram. An agent skill for Claude Code, Codex, and more.

fix(dsh): preserve default skills across installation and upgrade

tt-a1i5f3446a1762a
diff --git a/integrations/deepseek-harness/README.md b/integrations/deepseek-harness/README.md
index c1af78f8..38811368 100644
--- a/integrations/deepseek-harness/README.md
+++ b/integrations/deepseek-harness/README.md
@@ -10,6 +10,16 @@ Version 1.0.0 was published on 2026-10-04: [npm package](https://www.npmjs.com/p
The adapter registers no native render/validate/deliver tools, custom Web client, Produced Files chips, telemetry, credentials handling, background services, or install hooks. The bundled Skill includes an optional, notification-only stable Archify update checker; it never upgrades the plugin. Authored remote brand assets may also use the Skill's bounded network path. The adapter itself makes no network requests.
+## Default Skill roots: unreleased fix
+
+Published **1.0.0** sets `includeDefaultRoots: false`. If its `archify-plugin` provider is the profile's only live filesystem Skill source, personal and project Skills disappear while Archify remains available. This was reported on macOS Desktop `0.2.0-rc.2` in [#906](https://github.com/tt-a1i/archify/issues/906).
+
+The **unreleased source fix** sets `includeDefaultRoots: true`, retaining the host's default personal and project roots alongside the packaged Archify root. The provider name and bundle directory are unchanged. The install command below still installs published 1.0.0, **not this fix**; no new adapter version has been published.
+
+The acceptance script now seeds distinct Skills in both DSH and shared-agent personal/project roots and checks their actual loaded bodies and paths after clean installation and same-profile upgrade. It repeats those checks with the base filesystem provider disabled, so the Archify provider must preserve the roots by itself. The immutable 0.1.0 upgrade baseline retains its original `false` expectation; the candidate requires `true`.
+
+These automated checks use the exact npm CLI host in `release.json` (`0.1.2-rc.1`). They do not establish macOS Desktop `0.2.0-rc.2` acceptance or explain why the reporter's original provider was inactive. That native Desktop verification remains pending; the published support statement is unchanged.
+
## Patch execution boundary
The `cordis.patch.yml` file is configuration consumed by the DSH host. Its `bundledSkillDir` value uses the host loader's `!!js` expression to resolve the installed package's `skills` directory when the entry is activated. This expression runs in the DSH host process, outside the agent sandbox; it is not an inert YAML value and should be treated as host-loaded code.
diff --git a/integrations/deepseek-harness/cordis.patch.yml b/integrations/deepseek-harness/cordis.patch.yml
index 66bc422b..5068054f 100644
--- a/integrations/deepseek-harness/cordis.patch.yml
+++ b/integrations/deepseek-harness/cordis.patch.yml
@@ -6,5 +6,5 @@
name: '@deepseek-ai/dsh-skill-filesystem'
config:
providerName: archify-plugin
- includeDefaultRoots: false
+ includeDefaultRoots: true
bundledSkillDir: !!js process.getBuiltinModule('node:path').join(process.getBuiltinModule('node:path').dirname(process.getBuiltinModule('node:module').createRequire(baseUrl).resolve('@tt-a1i/archify-dsh/package.json')), 'skills')
diff --git a/integrations/deepseek-harness/scripts/distribution-acceptance.mjs b/integrations/deepseek-harness/scripts/distribution-acceptance.mjs
index 28ff59dc..a7a816b6 100644
--- a/integrations/deepseek-harness/scripts/distribution-acceptance.mjs
+++ b/integrations/deepseek-harness/scripts/distribution-acceptance.mjs
@@ -23,6 +23,7 @@ const UPGRADE_PROFILE = 'archify-dsh-upgrade';
const PREVIOUS_RELEASE = Object.freeze({
version: '0.1.0',
skillVersion: '2.14.0',
+ includeDefaultRoots: false,
integrity: 'sha512-D8fDqV6DV/vo80Gj/3rgidd+hwBbhTVncaVoD5Uhh+DbgYlEoQQOmBVbhU5HW33wE5OqJP/2HkTRPJ0hf7W0tA==',
});
const DSH_RUNTIME_INSTALL_TIMEOUT = process.platform === 'win32' ? 600_000 : 300_000;
@@ -152,6 +153,23 @@ fs.mkdirSync(agentsHome);
fs.mkdirSync(dshRuntime);
fs.mkdirSync(workspace);
+// Distinct names and bodies make discovery-only and wrong-root successes fail.
+// All homes and the project are disposable; never use the caller's live Skills.
+const defaultSkills = [
+ ['personal-dsh-probe', path.join(dshHome, 'skills')],
+ ['personal-agents-probe', path.join(agentsHome, 'skills')],
+ ['project-dsh-probe', path.join(workspace, '.dsh', 'skills')],
+ ['project-agents-probe', path.join(workspace, '.agents', 'skills')],
+].map(([name, root]) => {
+ const directory = path.join(root, name);
+ const content = `Acceptance fixture body for ${name}.`;
+ fs.mkdirSync(directory, { recursive: true });
+ const file = path.join(directory, 'SKILL.md');
+ fs.writeFileSync(file, `---\nname: ${name}\ndescription: Disposable default-root fixture\n---\n\n${content}\n`);
+ return { name, file, contentSha256: createHash('sha256').update(content).digest('hex') };
+});
+const candidateSkills = ['archify', ...defaultSkills.map(({ name }) => name)];
+
function cleanup() {
fs.rmSync(scratch, { recursive: true, force: true });
}
@@ -311,12 +329,13 @@ if (!archifyProvider || extraProviders.length !== 1 || archifyLayer.rows.length
layerRows: archifyLayer.rows.map((row) => row.id),
});
}
-if (archifyProvider.config.includeDefaultRoots !== false || archifyProvider.config.providerName !== 'archify-plugin') {
- fail('compose', 'Archify provider config is not isolated', { archifyProvider });
+if (archifyProvider.config.includeDefaultRoots !== true || archifyProvider.config.providerName !== 'archify-plugin') {
+ fail('compose', 'Archify provider does not preserve default Skill roots', { archifyProvider });
}
pass('compose', {
extraIds: archifyLayer.rows.map((row) => row.id),
providerName: 'archify-plugin',
+ includeDefaultRoots: true,
});
const probePatch = path.join(scratch, 'probe.patch.yml');
@@ -326,11 +345,22 @@ fs.writeFileSync(probePatch, `- insert:
name: ${JSON.stringify(pathToFileURL(probeModule).href)}
inject: [skills]
`);
-async function probeProfile(profile, stage) {
+const isolatedProbePatch = path.join(scratch, 'isolated-probe.patch.yml');
+// Reproduce #906 without relying on why Desktop made its base provider inactive.
+fs.writeFileSync(isolatedProbePatch, `- id: skill-filesystem
+ disabled: true
+${fs.readFileSync(probePatch, 'utf8')}`);
+async function probeProfile(profile, stage, { isolated = false, expectedNames = candidateSkills } = {}) {
const probeOut = path.join(scratch, `${stage}-probe.json`);
- const child = spawnCli(process.execPath, [dshBin, '--profile', profile, '--patch', probePatch], {
+ const child = spawnCli(process.execPath, [dshBin, '--profile', profile, '--patch', isolated ? isolatedProbePatch : probePatch], {
cwd: workspace,
- env: { ...dshEnv, ARCHIFY_DSH_PROBE_OUT: probeOut },
+ env: {
+ ...dshEnv,
+ ARCHIFY_DSH_PROBE_OUT: probeOut,
+ // The host may change cwd to its profile while resolving plugin modules.
+ ARCHIFY_DSH_PROBE_CWD: workspace,
+ ARCHIFY_DSH_PROBE_SKILLS: JSON.stringify(expectedNames),
+ },
stdio: ['ignore', 'pipe', 'pipe'],
});
let stdout = '';
@@ -348,7 +378,42 @@ async function probeProfile(profile, stage) {
return { probe: JSON.parse(fs.readFileSync(probeOut, 'utf8')), stdout, stderr };
}
+function verifyDefaultSkills(stage, probe, { isolated = false } = {}) {
+ for (const fixture of defaultSkills) {
+ const hits = probe.skills.filter((skill) => skill.name === fixture.name);
+ const definition = probe.definitions[fixture.name];
+ if (hits.length !== 1 || !definition || definition.contentSha256 !== fixture.contentSha256
+ || !definition.path || sameEntry(fixture.file, definition.path).status !== 'match'
+ || (isolated && (hits[0].provider !== 'archify-plugin' || definition.provider !== 'archify-plugin'))) {
+ fail(stage, 'personal/project Skill was not uniquely discovered and loaded from its original root', {
+ skill: fixture.name, hits, definition, isolated,
+ });
+ }
+ }
+ pass(stage, { skills: defaultSkills.map(({ name }) => name), baseProviderDisabled: isolated });
+}
+
+async function verifyIsolatedRoots(profile, stage, includeDefaultRoots) {
+ const { probe } = await probeProfile(profile, stage, {
+ isolated: true,
+ expectedNames: includeDefaultRoots ? candidateSkills : ['archify'],
+ });
+ if (!probe.definitions.archify?.contentLength || probe.definitions.archify.provider !== 'archify-plugin') {
+ fail(stage, 'isolated provider did not load Archify', { probe });
+ }
+ if (includeDefaultRoots) {
+ verifyDefaultSkills(stage, probe, { isolated: true });
+ } else {
+ if (defaultSkills.some(({ name }) => probe.skills.some((skill) => skill.name === name))) {
+ fail(stage, 'published isolated baseline unexpectedly exposed default roots', { probe });
+ }
+ pass(stage, { baseProviderDisabled: true, defaultRootsVisible: false });
+ }
+}
+
const { probe: probeReceipt, stdout: probeStdout, stderr: probeStderr } = await probeProfile(PROFILE, 'skill-discovery');
+verifyDefaultSkills('default-skill-roots', probeReceipt);
+await verifyIsolatedRoots(PROFILE, 'isolated-default-skill-roots', true);
const archifyHits = (probeReceipt.skills || []).filter((skill) => skill.name === 'archify');
if (archifyHits.length !== 1 || archifyHits[0].provider !== 'archify-plugin') {
fail('skill-discovery', 'public Skill registry did not discover archify only from archify-plugin', {
@@ -359,12 +424,12 @@ if (archifyHits.length !== 1 || archifyHits[0].provider !== 'archify-plugin') {
}
pass('skill-discovery', { provider: 'archify-plugin' });
-if (!probeReceipt.definition?.contentLength || probeReceipt.definition.provider !== 'archify-plugin') {
- fail('skill-load', 'full Skill definition was not loaded', { definition: probeReceipt.definition });
+if (!probeReceipt.definitions.archify?.contentLength || probeReceipt.definitions.archify.provider !== 'archify-plugin') {
+ fail('skill-load', 'full Skill definition was not loaded', { definition: probeReceipt.definitions.archify });
}
-pass('skill-load', { contentLength: probeReceipt.definition.contentLength });
+pass('skill-load', { contentLength: probeReceipt.definitions.archify.contentLength });
-const resourcePath = probeReceipt.definition.resourceBase?.path || probeReceipt.definition.path;
+const resourcePath = probeReceipt.definitions.archify.resourceBase?.path || probeReceipt.definitions.archify.path;
const installedPackage = path.join(profileDir, 'node_modules', '@tt-a1i', 'archify-dsh');
let resourceReal;
let packageReal;
@@ -463,7 +528,7 @@ fs.mkdirSync(previousRoot);
requireStatus('upgrade-baseline-download', run('tar', ['-xzf', previousTarball, '-C', previousRoot]));
pass('upgrade-baseline-download', { spec: previousSpec, integrity: previousIntegrity });
-async function verifyUpgradeProfile(stage, version, skillVersion, expectedRoot) {
+async function verifyUpgradeProfile(stage, version, skillVersion, expectedRoot, includeDefaultRoots) {
const root = path.join(dshHome, 'profiles', UPGRADE_PROFILE);
const installed = path.join(root, 'node_modules', '@tt-a1i', 'archify-dsh');
const pkg = JSON.parse(fs.readFileSync(path.join(installed, 'package.json'), 'utf8'));
@@ -481,20 +546,24 @@ async function verifyUpgradeProfile(stage, version, skillVersion, expectedRoot)
requireStatus(stage, config);
const rows = parseDump(config.stdout).rows;
const providers = rows.filter((row) => row.config.providerName === 'archify-plugin');
- if (providers.length !== 1 || providers[0].config.includeDefaultRoots !== false
+ if (providers.length !== 1 || providers[0].config.includeDefaultRoots !== includeDefaultRoots
|| !rows.some((row) => row.id === 'skill-filesystem' && row.config.providerName !== 'archify-plugin')) {
- fail(stage, 'upgrade duplicated the provider or replaced the base Skill provider');
+ fail(stage, 'upgrade duplicated the provider, replaced the base Skill provider, or has the wrong default-root policy');
}
- const { probe } = await probeProfile(UPGRADE_PROFILE, stage);
+ const { probe } = await probeProfile(UPGRADE_PROFILE, stage, {
+ expectedNames: includeDefaultRoots ? candidateSkills : ['archify'],
+ });
const hits = (probe.skills || []).filter((entry) => entry.name === 'archify');
- const resource = probe.definition?.resourceBase?.path || probe.definition?.path;
+ const resource = probe.definitions.archify?.resourceBase?.path || probe.definitions.archify?.path;
const expectedRoots = [path.join(installed, 'skills'), skill];
if (hits.length !== 1 || hits[0].provider !== 'archify-plugin'
- || !probe.definition?.contentLength || probe.definition.provider !== 'archify-plugin'
+ || !probe.definitions.archify?.contentLength || probe.definitions.archify.provider !== 'archify-plugin'
|| !resource || !expectedRoots.some((entry) => sameEntry(entry, resource).status === 'match')) {
fail(stage, 'upgrade did not discover and load exactly one installed Archify Skill', { probe });
}
- pass(stage, { version, skillVersion, provider: 'archify-plugin', fileCount: expectedFiles.length });
+ pass(stage, { version, skillVersion, provider: 'archify-plugin', includeDefaultRoots, fileCount: expectedFiles.length });
+ if (includeDefaultRoots) verifyDefaultSkills(`${stage}-default-roots`, probe);
+ await verifyIsolatedRoots(UPGRADE_PROFILE, `${stage}-isolated-roots`, includeDefaultRoots);
return skill;
}
@@ -502,12 +571,12 @@ requireStatus('upgrade-baseline-install', dsh(['plugin', '--profile', UPGRADE_PR
timeout: PLUGIN_MUTATION_TIMEOUT,
}));
await verifyUpgradeProfile('upgrade-baseline-load', PREVIOUS_RELEASE.version, PREVIOUS_RELEASE.skillVersion,
- path.join(previousRoot, 'package'));
+ path.join(previousRoot, 'package'), PREVIOUS_RELEASE.includeDefaultRoots);
requireStatus('plugin-upgrade', dsh(['plugin', '--profile', UPGRADE_PROFILE, 'add', tarball], {
timeout: PLUGIN_MUTATION_TIMEOUT,
}));
const upgradedSkill = await verifyUpgradeProfile('plugin-upgrade-load', PACKAGE_VERSION, release.skillVersion,
- path.join(inspectRoot, 'package'));
+ path.join(inspectRoot, 'package'), true);
for (const args of [['doctor'], ['demo', path.join(workspace, 'upgraded-smoke')]]) {
requireStatus('upgraded-skill-smoke', run(process.execPath, [path.join(upgradedSkill, 'bin', 'archify.mjs'), ...args], {
cwd: workspace,
diff --git a/integrations/deepseek-harness/test/docs-contract.test.mjs b/integrations/deepseek-harness/test/docs-contract.test.mjs
index 57265c92..7077598c 100644
--- a/integrations/deepseek-harness/test/docs-contract.test.mjs
+++ b/integrations/deepseek-harness/test/docs-contract.test.mjs
@@ -59,6 +59,18 @@ test('DSH documentation identifies the published release and its pinned snapshot
assert.match(integration, /rather than entirely declarative data/);
});
+test('default-root fix is distinguished from the immutable published package and Desktop evidence', () => {
+ const integration = read('integrations/deepseek-harness/README.md');
+ const section = integration.split('## Default Skill roots: unreleased fix')[1]?.split('\n## ')[0];
+ assert.ok(section, 'keep the unpublished behavior separate from the published support statement');
+ assert.match(section, /Published \*\*1\.0\.0\*\* sets `includeDefaultRoots: false`/);
+ assert.match(section, /unreleased source fix/);
+ assert.match(section, /`includeDefaultRoots: true`/);
+ assert.match(section, /no new adapter version has been published/);
+ assert.match(section, /macOS Desktop `0\.2\.0-rc\.2` acceptance/);
+ assert.match(section, /verification remains pending/);
+});
+
test('English, Chinese, and Japanese docs cover install, invoke, uninstall, community wording, and Produced Files', () => {
const englishRoot = read('README.md');
const chineseRoot = read('README_ZH.md');
diff --git a/integrations/deepseek-harness/test/package-contract.test.mjs b/integrations/deepseek-harness/test/package-contract.test.mjs
index 8722b487..55735fbe 100644
--- a/integrations/deepseek-harness/test/package-contract.test.mjs
+++ b/integrations/deepseek-harness/test/package-contract.test.mjs
@@ -70,7 +70,7 @@ test('bundle patch inserts one uniquely named filesystem Skill provider resolved
assert.match(patch, /id:\s*archify-skill-filesystem/);
assert.match(patch, /name:\s*'@deepseek-ai\/dsh-skill-filesystem'/);
assert.match(patch, /providerName:\s*archify-plugin/);
- assert.match(patch, /includeDefaultRoots:\s*false/);
+ assert.match(patch, /includeDefaultRoots:\s*true/);
assert.match(patch, /bundledSkillDir:\s*!!js/);
assert.doesNotMatch(patch, /customSkillDirs/);
assert.match(
diff --git a/integrations/deepseek-harness/test/probe-skills.mjs b/integrations/deepseek-harness/test/probe-skills.mjs
index 8fe06132..29faf677 100644
--- a/integrations/deepseek-harness/test/probe-skills.mjs
+++ b/integrations/deepseek-harness/test/probe-skills.mjs
@@ -1,11 +1,12 @@
import fs from 'node:fs';
+import { createHash } from 'node:crypto';
import path from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
export const name = 'archify-dsh-skill-probe';
export const inject = ['skills'];
-export async function waitForArchify(skills, cwd, {
+export async function probeSkills(skills, cwd, expectedNames = ['archify'], {
timeoutMs = 30_000,
pollMs = 100,
sleep = delay,
@@ -14,36 +15,42 @@ export async function waitForArchify(skills, cwd, {
let list = [];
do {
list = await skills.list({ cwd });
- const archify = list.find((skill) => skill.name === 'archify');
- if (archify) return { list, archify };
+ if (expectedNames.every((name) => list.some((skill) => skill.name === name))) break;
if (Date.now() >= deadline) break;
await sleep(pollMs);
} while (true);
- return { list, archify: undefined };
-}
-
-export async function apply(ctx) {
- const out = process.env.ARCHIFY_DSH_PROBE_OUT;
- if (!out) throw new Error('ARCHIFY_DSH_PROBE_OUT is required for the test-only skill probe');
- const cwd = process.cwd();
- const { list, archify } = await waitForArchify(ctx.skills, cwd);
- const definition = archify ? await ctx.skills.get('archify', { cwd }) : null;
- fs.mkdirSync(path.dirname(out), { recursive: true });
- fs.writeFileSync(out, `${JSON.stringify({
+ const definitions = {};
+ for (const name of expectedNames) {
+ if (!list.some((skill) => skill.name === name)) continue;
+ const definition = await skills.get(name, { cwd });
+ if (!definition) continue;
+ definitions[name] = {
+ name: definition.name,
+ provider: definition.provider,
+ resourceBase: definition.resourceBase,
+ path: definition.path,
+ contentLength: definition.content?.length || 0,
+ contentSha256: createHash('sha256').update(definition.content || '').digest('hex'),
+ };
+ }
+ return {
skills: list.map((skill) => ({
name: skill.name,
provider: skill.provider,
resourceBase: skill.resourceBase,
path: skill.path,
})),
- definition: definition && {
- name: definition.name,
- provider: definition.provider,
- resourceBase: definition.resourceBase,
- path: definition.path,
- contentLength: definition.content?.length || 0,
- },
- }, null, 2)}\n`);
+ definitions,
+ };
+}
+
+export async function apply(ctx) {
+ const out = process.env.ARCHIFY_DSH_PROBE_OUT;
+ if (!out) throw new Error('ARCHIFY_DSH_PROBE_OUT is required for the test-only skill probe');
+ const expectedNames = JSON.parse(process.env.ARCHIFY_DSH_PROBE_SKILLS || '["archify"]');
+ const result = await probeSkills(ctx.skills, process.env.ARCHIFY_DSH_PROBE_CWD || process.cwd(), expectedNames);
+ fs.mkdirSync(path.dirname(out), { recursive: true });
+ fs.writeFileSync(out, `${JSON.stringify(result, null, 2)}\n`);
const exit = ctx.cmdlineArgs?.exit || ctx.appExit;
if (typeof exit === 'function') exit(0);
}
diff --git a/integrations/deepseek-harness/test/probe-skills.test.mjs b/integrations/deepseek-harness/test/probe-skills.test.mjs
index 962b0c8b..7a95712e 100644
--- a/integrations/deepseek-harness/test/probe-skills.test.mjs
+++ b/integrations/deepseek-harness/test/probe-skills.test.mjs
@@ -1,21 +1,78 @@
import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
import test from 'node:test';
-import { waitForArchify } from './probe-skills.mjs';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { apply, probeSkills } from './probe-skills.mjs';
-test('skill probe waits for a provider that registers during DSH boot', async () => {
+test('skill probe waits for every expected root and loads its current body through the registry', async () => {
let calls = 0;
+ const loaded = [];
const archify = { name: 'archify', provider: 'archify-plugin' };
+ const personal = { name: 'personal-probe', provider: 'archify-plugin' };
const skills = {
- async list() {
+ async list(options) {
+ assert.deepEqual(options, { cwd: '/workspace' });
calls += 1;
- return calls < 3 ? [] : [archify];
+ return calls === 1 ? [] : calls === 2 ? [archify] : [archify, personal];
+ },
+ async get(name, options) {
+ assert.deepEqual(options, { cwd: '/workspace' });
+ loaded.push(name);
+ return { name, provider: 'archify-plugin', content: `Current body of ${name}` };
},
};
- const result = await waitForArchify(skills, '/workspace', {
+ const result = await probeSkills(skills, '/workspace', ['archify', 'personal-probe'], {
timeoutMs: 1_000,
sleep: async () => {},
});
assert.equal(calls, 3);
- assert.equal(result.archify, archify);
- assert.deepEqual(result.list, [archify]);
+ assert.deepEqual(loaded, ['archify', 'personal-probe']);
+ assert.equal(result.definitions['personal-probe'].contentSha256,
+ createHash('sha256').update('Current body of personal-probe').digest('hex'));
+ assert.equal(result.definitions.archify.provider, 'archify-plugin');
+});
+
+test('missing roots and listed-but-unloadable skills remain absent from probe definitions', async () => {
+ const result = await probeSkills({
+ async list() { return [{ name: 'archify' }]; },
+ async get(name) { assert.equal(name, 'archify'); return null; },
+ }, '/workspace', ['archify', 'missing-personal'], { timeoutMs: 0 });
+ assert.deepEqual(result.skills.map((skill) => skill.name), ['archify']);
+ assert.deepEqual(result.definitions, {});
+});
+
+
+test('host probe uses the requested project even when the host process cwd differs', async (t) => {
+ const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-probe-cwd-'));
+ const out = path.join(scratch, 'probe.json');
+ const cwd = path.join(scratch, 'project');
+ const env = {
+ ARCHIFY_DSH_PROBE_OUT: out,
+ ARCHIFY_DSH_PROBE_CWD: cwd,
+ ARCHIFY_DSH_PROBE_SKILLS: '["project-probe"]',
+ };
+ const previous = Object.fromEntries(Object.keys(env).map((key) => [key, process.env[key]]));
+ t.after(() => {
+ for (const [key, value] of Object.entries(previous)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ fs.rmSync(scratch, { recursive: true, force: true });
+ });
+ Object.assign(process.env, env);
+ await apply({ skills: {
+ async list(options) {
+ assert.equal(options.cwd, cwd);
+ assert.notEqual(options.cwd, process.cwd());
+ return [{ name: 'project-probe' }];
+ },
+ async get(name, options) {
+ assert.equal(options.cwd, cwd);
+ return { name, content: 'Loaded project body' };
+ },
+ } });
+ const result = JSON.parse(fs.readFileSync(out, 'utf8'));
+ assert.ok(result.definitions['project-probe'].contentLength);
});