@@ -13,15 +13,21 @@ const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 const allowedDir = tmpdir.path;
 const allowedFile = path.join(allowedDir, 'ok.txt');
-const subFile = path.join(allowedDir, 'sub', 'nested.txt');
-fs.mkdirSync(path.dirname(subFile), { recursive: true });
+const subDir = path.join(allowedDir, 'sub');
+const subFile = path.join(subDir, 'nested.txt');
+fs.mkdirSync(subDir, { recursive: true });
 const deniedDir = fs.mkdtempSync(path.join(path.dirname(tmpdir.path), 'perm-deny-'));
 const deniedFile = path.join(deniedDir, 'secret.txt');
 fs.writeFileSync(allowedFile, 'allowed\n');
 fs.writeFileSync(subFile, 'nested\n');
 fs.writeFileSync(deniedFile, 'secret\n');
 
-function runWorkerCase(workerBody, execArgvFragment) {
+// Trailing-slash allow path (NormalizePathForCompare)
+const allowedDirSlash = allowedDir.endsWith(path.sep)
+  ? allowedDir
+  : allowedDir + path.sep;
+
+function runWithParent(parentArgs, workerBody, execArgvFragment) {
   const code = `
     const { Worker } = require('worker_threads');
     const w = new Worker(${JSON.stringify(workerBody)}, {
@@ -36,14 +42,23 @@ function runWorkerCase(workerBody, execArgvFragment) {
   `;
   return spawnSync(
     process.execPath,
-    ['--permission', `--allow-fs-read=${allowedDir}`, '--allow-worker', '-e', code],
+    parentArgs.concat(['-e', code]),
     { encoding: 'utf8', timeout: 30000, env: { ...process.env } },
   );
 }
 
+function baseParent(extra = []) {
+  return [
+    '--permission',
+    `--allow-fs-read=${allowedDir}`,
+    '--allow-worker',
+    ...extra,
+  ];
+}
+
 function parseLastJsonLine(stdout) {
   const lines = stdout.trim().split('\n').filter(Boolean);
-  assert.ok(lines.length > 0, 'expected worker JSON output');
+  assert.ok(lines.length > 0, `expected JSON, got: ${stdout}`);
   return JSON.parse(lines[lines.length - 1]);
 }
 
@@ -62,6 +77,19 @@ function workerRead(filePath) {
   `;
 }
 
+function workerWrite(filePath) {
+  return `
+    const { parentPort } = require('worker_threads');
+    const fs = require('fs');
+    try {
+      fs.writeFileSync(${JSON.stringify(filePath)}, 'w');
+      parentPort.postMessage({ ok: true });
+    } catch (err) {
+      parentPort.postMessage({ ok: false, code: err.code });
+    }
+  `;
+}
+
 function assertAccessDenied(msg) {
   assert.strictEqual(msg.ok, false, JSON.stringify(msg));
   assert.strictEqual(msg.code, 'ERR_ACCESS_DENIED');
@@ -72,63 +100,189 @@ function assertOk(msg) {
 }
 
 try {
+  // default Worker inherits
   {
-    const r = runWorkerCase(workerRead(deniedFile), '');
+    const r = runWithParent(baseParent(), workerRead(deniedFile), '');
     assert.strictEqual(r.status, 0, r.stderr);
     assertAccessDenied(parseLastJsonLine(r.stdout));
   }
+
+  // execArgv: []
   {
-    const denied = runWorkerCase(workerRead(deniedFile), 'execArgv: [],');
+    const denied = runWithParent(baseParent(), workerRead(deniedFile), 'execArgv: [],');
     assert.strictEqual(denied.status, 0, denied.stderr);
     assertAccessDenied(parseLastJsonLine(denied.stdout));
-    const allowed = runWorkerCase(workerRead(allowedFile), 'execArgv: [],');
+    const allowed = runWithParent(baseParent(), workerRead(allowedFile), 'execArgv: [],');
     assert.strictEqual(allowed.status, 0, allowed.stderr);
     assertOk(parseLastJsonLine(allowed.stdout));
-    const nested = runWorkerCase(workerRead(subFile), 'execArgv: [],');
+    const nested = runWithParent(baseParent(), workerRead(subFile), 'execArgv: [],');
     assert.strictEqual(nested.status, 0, nested.stderr);
     assertOk(parseLastJsonLine(nested.stdout));
   }
+
+  // non-permission flag preserved + ceiling
   {
-    const denied = runWorkerCase(workerRead(deniedFile), 'execArgv: ["--no-warnings"],');
+    const denied = runWithParent(
+      baseParent(),
+      workerRead(deniedFile),
+      'execArgv: ["--no-warnings"],',
+    );
     assert.strictEqual(denied.status, 0, denied.stderr);
     assertAccessDenied(parseLastJsonLine(denied.stdout));
-    const allowed = runWorkerCase(workerRead(allowedFile), 'execArgv: ["--no-warnings"],');
+    const allowed = runWithParent(
+      baseParent(),
+      workerRead(allowedFile),
+      'execArgv: ["--no-warnings"],',
+    );
     assert.strictEqual(allowed.status, 0, allowed.stderr);
     assertOk(parseLastJsonLine(allowed.stdout));
   }
+
+  // worker permission on, no fs-read → empty grants
   {
     const frag = `execArgv: ${JSON.stringify(['--permission', '--allow-worker'])},`;
-    const d = runWorkerCase(workerRead(deniedFile), frag);
+    const d = runWithParent(baseParent(), workerRead(deniedFile), frag);
     assert.strictEqual(d.status, 0, d.stderr);
     assertAccessDenied(parseLastJsonLine(d.stdout));
-    const a = runWorkerCase(workerRead(allowedFile), frag);
+    const a = runWithParent(baseParent(), workerRead(allowedFile), frag);
     assert.strictEqual(a.status, 0, a.stderr);
     assertAccessDenied(parseLastJsonLine(a.stdout));
   }
+
+  // escalate * clamped
   {
-    const frag = `execArgv: ${JSON.stringify(['--permission', '--allow-fs-read=*', '--allow-worker'])},`;
-    const r = runWorkerCase(workerRead(deniedFile), frag);
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission', '--allow-fs-read=*', '--allow-worker',
+    ])},`;
+    const r = runWithParent(baseParent(), workerRead(deniedFile), frag);
     assert.strictEqual(r.status, 0, r.stderr);
     assertAccessDenied(parseLastJsonLine(r.stdout));
   }
+
+  // repeated allow flags cannot exceed parent
   {
     const frag = `execArgv: ${JSON.stringify([
       '--permission',
       `--allow-fs-read=${allowedDir}`,
       `--allow-fs-read=${deniedFile}`,
       '--allow-worker',
     ])},`;
-    const r = runWorkerCase(workerRead(deniedFile), frag);
+    const r = runWithParent(baseParent(), workerRead(deniedFile), frag);
     assert.strictEqual(r.status, 0, r.stderr);
     assertAccessDenied(parseLastJsonLine(r.stdout));
   }
+
+  // subset path under parent dir
   {
     const frag = `execArgv: ${JSON.stringify([
       '--permission',
       `--allow-fs-read=${subFile}`,
       '--allow-worker',
     ])},`;
-    const r = runWorkerCase(workerRead(subFile), frag);
+    const r = runWithParent(baseParent(), workerRead(subFile), frag);
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertOk(parseLastJsonLine(r.stdout));
+  }
+
+  // trailing slash parent allow (NormalizePathForCompare)
+  {
+    const parent = [
+      '--permission',
+      `--allow-fs-read=${allowedDirSlash}`,
+      '--allow-worker',
+    ];
+    const r = runWithParent(parent, workerRead(allowedFile), 'execArgv: [],');
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertOk(parseLastJsonLine(r.stdout));
+  }
+
+  // parent has wildcard * → worker * / paths not stripped by Filter
+  {
+    const parent = ['--permission', '--allow-fs-read=*', '--allow-worker'];
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission',
+      `--allow-fs-read=${deniedFile}`,
+      '--allow-worker',
+    ])},`;
+    const r = runWithParent(parent, workerRead(deniedFile), frag);
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertOk(parseLastJsonLine(r.stdout));
+  }
+
+  // permission-audit on parent + empty execArgv
+  {
+    const parent = [
+      '--permission',
+      '--permission-audit',
+      `--allow-fs-read=${allowedDir}`,
+      '--allow-worker',
+    ];
+    const r = runWithParent(parent, workerRead(allowedFile), 'execArgv: [],');
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertOk(parseLastJsonLine(r.stdout));
+  }
+
+  // fs-write: parent no write → worker cannot escalate write
+  {
+    const writeTarget = path.join(allowedDir, 'w.txt');
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission',
+      `--allow-fs-write=${allowedDir}`,
+      '--allow-worker',
+    ])},`;
+    const r = runWithParent(baseParent(), workerWrite(writeTarget), frag);
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertAccessDenied(parseLastJsonLine(r.stdout));
+  }
+
+  // fs-write allowed when parent grants write
+  {
+    const writeTarget = path.join(allowedDir, 'w2.txt');
+    const parent = [
+      '--permission',
+      `--allow-fs-read=${allowedDir}`,
+      `--allow-fs-write=${allowedDir}`,
+      '--allow-worker',
+    ];
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission',
+      `--allow-fs-write=${allowedDir}`,
+      '--allow-worker',
+    ])},`;
+    const r = runWithParent(parent, workerWrite(writeTarget), frag);
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertOk(parseLastJsonLine(r.stdout));
+  }
+
+  // boolean allow intersection: worker asks allow-net, parent does not
+  {
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission',
+      `--allow-fs-read=${allowedDir}`,
+      '--allow-net',
+      '--allow-worker',
+    ])},`;
+    // still cannot read denied; net flag just exercises Intersect path
+    const r = runWithParent(baseParent(), workerRead(deniedFile), frag);
+    assert.strictEqual(r.status, 0, r.stderr);
+    assertAccessDenied(parseLastJsonLine(r.stdout));
+  }
+
+  // multiple boolean flags in rebuild path
+  {
+    const parent = [
+      '--permission',
+      `--allow-fs-read=${allowedDir}`,
+      '--allow-worker',
+      '--allow-addons',
+    ];
+    const frag = `execArgv: ${JSON.stringify([
+      '--permission',
+      `--allow-fs-read=${allowedDir}`,
+      '--allow-worker',
+      '--allow-addons',
+    ])},`;
+    const r = runWithParent(parent, workerRead(allowedFile), frag);
     assert.strictEqual(r.status, 0, r.stderr);
     assertOk(parseLastJsonLine(r.stdout));
   }