gsd-pi 2.75.0 → 2.76.0-dev.b072ebb73

package/src/resources/extensions/gsd/tests/init-prefs-routing.test.ts

@@ -0,0 +1,190 @@
+// GSD — /gsd init → unified preferences-write routing tests.
+//
+// Verifies the refactor that routes init's preferences write through the same
+// writePreferencesFile helper used by handlePrefsWizard, and that the typed
+// ProjectPreferences shape maps correctly into the wizard's
+// Record<string, unknown> shape.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { mapInitPrefsToWizardShape } from "../init-wizard.ts";
+import { writePreferencesFile } from "../commands-prefs-wizard.ts";
+
+test("mapInitPrefsToWizardShape — full roundtrip with all fields", () => {
+  const out = mapInitPrefsToWizardShape({
+    mode: "team",
+    gitIsolation: "branch",
+    mainBranch: "develop",
+    verificationCommands: ["npm test", "npm run lint"],
+    customInstructions: ["Use TypeScript strict mode", "Always write tests"],
+    tokenProfile: "quality",
+    skipResearch: true,
+    autoPush: false,
+  });
+
+  assert.equal(out.mode, "team");
+  assert.deepEqual(out.git, { isolation: "branch", main_branch: "develop", auto_push: false });
+  assert.deepEqual(out.verification_commands, ["npm test", "npm run lint"]);
+  assert.deepEqual(out.custom_instructions, ["Use TypeScript strict mode", "Always write tests"]);
+  assert.equal(out.token_profile, "quality");
+  assert.deepEqual(out.phases, { skip_research: true });
+});
+
+test("mapInitPrefsToWizardShape — omits defaults to keep YAML clean", () => {
+  const out = mapInitPrefsToWizardShape({
+    mode: "solo",
+    gitIsolation: "worktree",
+    mainBranch: "main",
+    verificationCommands: [],
+    customInstructions: [],
+    tokenProfile: "balanced",
+    skipResearch: false,
+    autoPush: true,
+  });
+
+  // tokenProfile=balanced is the default — should not be serialized.
+  assert.equal(out.token_profile, undefined);
+  // skipResearch=false is the default — phases should not appear.
+  assert.equal(out.phases, undefined);
+  // Empty arrays should not be serialized.
+  assert.equal(out.verification_commands, undefined);
+  assert.equal(out.custom_instructions, undefined);
+});
+
+test("writePreferencesFile — writes valid frontmatter from prefill", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-init-prefs-routing-"));
+  const path = join(tmp, "PREFERENCES.md");
+
+  try {
+    const prefs = mapInitPrefsToWizardShape({
+      mode: "solo",
+      gitIsolation: "worktree",
+      mainBranch: "main",
+      verificationCommands: ["npm test"],
+      customInstructions: [],
+      tokenProfile: "balanced",
+      skipResearch: false,
+      autoPush: true,
+    });
+
+    await writePreferencesFile(path, prefs, null, { scope: "project" });
+
+    const content = readFileSync(path, "utf-8");
+    assert.match(content, /^---/);
+    assert.match(content, /mode: solo/);
+    assert.match(content, /git:/);
+    assert.match(content, /isolation: worktree/);
+    assert.match(content, /main_branch: main/);
+    assert.match(content, /auto_push: true/);
+    assert.match(content, /verification_commands:/);
+    assert.match(content, /- npm test/);
+    // version: 1 is added by writePreferencesFile if missing
+    assert.match(content, /version: 1/);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("writePreferencesFile — preserves existing markdown body", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-init-prefs-routing-"));
+  const path = join(tmp, "PREFERENCES.md");
+  const customBody = "\n# My Custom Notes\n\nUser-edited content here.\n";
+
+  try {
+    // Seed file with frontmatter + custom body
+    writeFileSync(path, `---\nmode: solo\nversion: 1\n---${customBody}`, "utf-8");
+
+    await writePreferencesFile(path, { mode: "team", version: 1 }, null);
+
+    const content = readFileSync(path, "utf-8");
+    assert.match(content, /mode: team/);
+    assert.match(content, /My Custom Notes/);
+    assert.match(content, /User-edited content here/);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("writePreferencesFile — falls back to default body for new files", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-init-prefs-routing-"));
+  const path = join(tmp, "PREFERENCES.md");
+  const initBody = "\n# Init body marker\n";
+
+  try {
+    await writePreferencesFile(path, { mode: "solo" }, null, { defaultBody: initBody });
+    const content = readFileSync(path, "utf-8");
+    assert.match(content, /Init body marker/);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Regression tests from #4457 codex adversarial review ──────────────────
+
+test("init — Step 9b shape: 'not_yet' option is recognized as defer (#4457 review)", async () => {
+  // The init wizard relies on showNextAction always appending a `not_yet` action
+  // and mapping Escape to it. The Step 9b code must explicitly handle `not_yet`
+  // as defer (return without bootstrapping or persisting prefs). This test
+  // documents the contract — it doesn't drive the full wizard, but it locks in
+  // that "not_yet" is the canonical defer signal so a future refactor can't
+  // silently drop the explicit branch.
+  const { showNextAction } = await import("../../shared/tui.ts") as { showNextAction: unknown };
+  assert.equal(typeof showNextAction, "function");
+
+  // Read the source to assert Step 9b explicitly handles not_yet — a static
+  // smoke test cheaper than spinning up the full wizard with a mocked ctx.
+  const src = readFileSync(
+    new URL("../init-wizard.ts", import.meta.url),
+    "utf-8",
+  );
+  assert.match(
+    src,
+    /reviewChoice === "not_yet"[\s\S]*?return \{ completed: false, bootstrapped: false \}/,
+    "init Step 9b must short-circuit on not_yet without writing preferences",
+  );
+});
+
+test("init — preferences path is basePath-derived, not cwd-derived (#4457 review)", async () => {
+  // If basePath !== process.cwd(), preferences must still write to
+  // join(gsdRoot(basePath), "PREFERENCES.md"), not the cwd-derived path.
+  // Static check: the post-#4457-review code constructs the path from gsdRoot(basePath).
+  const src = readFileSync(
+    new URL("../init-wizard.ts", import.meta.url),
+    "utf-8",
+  );
+  assert.match(
+    src,
+    /projectPrefsPath\s*=\s*join\(gsdRoot\(basePath\),\s*"PREFERENCES\.md"\)/,
+    "init must derive the project preferences path from basePath",
+  );
+  // And neither write site should call getProjectGSDPreferencesPath() (which
+  // resolves from process.cwd()).
+  assert.doesNotMatch(
+    src,
+    /getProjectGSDPreferencesPath\s*\(/,
+    "init must not use the cwd-derived getProjectGSDPreferencesPath()",
+  );
+});
+
+test("handlePrefsWizard — accepts pathOverride to target a non-cwd location", async () => {
+  // The wizard's signature must support pathOverride so /gsd init can route
+  // both the review and skip branches to the basePath-derived path.
+  const { handlePrefsWizard } = await import("../commands-prefs-wizard.ts");
+  assert.equal(handlePrefsWizard.length >= 2, true);
+  // Read source to confirm the opts.pathOverride wiring exists — calling
+  // handlePrefsWizard end-to-end requires a full ExtensionCommandContext
+  // mock, which is heavier than this contract check warrants.
+  const src = readFileSync(
+    new URL("../commands-prefs-wizard.ts", import.meta.url),
+    "utf-8",
+  );
+  assert.match(
+    src,
+    /opts\?\.pathOverride[\s\S]*?\?\?[\s\S]*?(getProjectGSDPreferencesPath|getGlobalGSDPreferencesPath)/,
+    "handlePrefsWizard must honor opts.pathOverride before falling back to scope-derived path",
+  );
+});

package/src/resources/extensions/gsd/tests/integration/doctor-git-symlink-cwd.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { execSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { runGSDDoctor } from "../../doctor.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createRepoWithCompletedMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-symlink-cwd-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "ROADMAP.md"), `---
+id: M001
+title: "Test Milestone"
+---
+
+# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
+`);
+
+  run("git add -A", dir);
+  run("git commit -m \"add milestone\"", dir);
+
+  return dir;
+}
+
+test("doctor removes orphaned milestone worktree when cwd uses a symlink alias", { skip: process.platform === "win32" }, async (t) => {
+  const previousCwd = process.cwd();
+  const dir = createRepoWithCompletedMilestone();
+  const alias = join(tmpdir(), `doc-git-alias-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+
+  t.after(() => {
+    try { process.chdir(previousCwd); } catch { process.chdir(tmpdir()); }
+    rmSync(alias, { recursive: true, force: true });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+  run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+  symlinkSync(dir, alias);
+  process.chdir(join(alias, ".gsd", "worktrees", "M001"));
+
+  const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
+  assert.ok(
+    fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+    `removes orphaned worktree even when cwd uses a symlink alias (got: ${JSON.stringify(fixed.fixesApplied)})`,
+  );
+
+  const wtList = run("git worktree list", dir);
+  assert.ok(!wtList.includes("milestone/M001"), "worktree removed after symlink-cwd fix");
+});

package/src/resources/extensions/gsd/tests/integration/doctor-git.test.ts

@@ -16,6 +16,7 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { runGSDDoctor } from "../../doctor.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../../gsd-db.ts";
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -55,6 +56,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+  writeFileSync(join(msDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
 
   // Commit .gsd files
@@ -64,6 +76,47 @@ _None_
   return dir;
 }
 
+/** Create a repo whose slices are done but milestone closeout is still pending. */
+function createRepoWithSlicesDoneButNoMilestoneSummary(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const msDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "ROADMAP.md"), `---
+id: M001
+title: "Completing Milestone"
+---
+
+# M001: Completing Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m \"add completing milestone\"", dir);
+
+  return dir;
+}
+
 /** Write a .gsd/PREFERENCES.md with the given git isolation mode. */
 function writePreferencesFile(dir: string, isolation: "none" | "worktree" | "branch"): void {
   const gsdDir = join(dir, ".gsd");
@@ -299,6 +352,31 @@ describe('doctor-git', async () => {
     } else {
     }
 
+    // ─── Test 6b: completing-milestone worktree NOT flagged ────────────
+    if (process.platform !== "win32") {
+    test('completing-milestone worktree safety (DB-backed, no summary)', async () => {
+      const dir = createRepoWithSlicesDoneButNoMilestoneSummary();
+      cleanups.push(dir);
+
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      const dbPath = join(dir, ".gsd", "gsd.db");
+      assert.equal(openDatabase(dbPath), true, "opens gsd.db");
+      try {
+        insertMilestone({ id: "M001", title: "Completing Milestone", status: "active" });
+        insertSlice({ id: "S01", milestoneId: "M001", title: "Test slice", status: "complete", risk: "low", depends: [] });
+
+        const detect = await runGSDDoctor(dir, { isolationMode: "worktree" });
+        const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
+        assert.deepStrictEqual(orphanIssues.length, 0, "completing milestone NOT flagged as orphaned");
+      } finally {
+        closeDatabase();
+      }
+    });
+    } else {
+    }
+
     // ─── Test 7: none-mode skips orphaned worktree check ───────────────
     // NOTE: loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH
     // at module load time from process.cwd(). We write the prefs file to
@@ -696,6 +774,45 @@ describe('doctor-git', async () => {
       assert.deepStrictEqual(staleIssues.length, 0, "recent commit with dirty tree NOT flagged as stale");
     });
 
+    // ─── Test: stale_uncommitted_changes suppressed by git.snapshots:false (#4420) ──
+    test('stale_uncommitted_changes (suppressed by git.snapshots:false)', async () => {
+      const dir = createRepoWithActiveMilestone();
+      cleanups.push(dir);
+
+      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
+      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
+      execSync(`git commit --amend --no-edit`, {
+        cwd: dir,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
+      });
+
+      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
+      writeFileSync(join(dir, ".gsd", "PREFERENCES.md"), `---\ngit:\n  snapshots: false\n---\n`);
+
+      const commitsBefore = run("git rev-list --count HEAD", dir);
+
+      const previousCwd = process.cwd();
+      process.chdir(dir);
+      try {
+        const detect = await runGSDDoctor(dir);
+        const staleIssues = detect.issues.filter(i => i.code === "stale_uncommitted_changes");
+        assert.deepStrictEqual(staleIssues.length, 0, "git.snapshots:false suppresses stale detection");
+
+        const fixed = await runGSDDoctor(dir, { fix: true });
+        assert.ok(
+          !fixed.fixesApplied.some(f => f.includes("gsd snapshot")),
+          `git.snapshots:false suppresses snapshot fix (got: ${JSON.stringify(fixed.fixesApplied)})`,
+        );
+      } finally {
+        process.chdir(previousCwd);
+      }
+
+      const commitsAfter = run("git rev-list --count HEAD", dir);
+      assert.strictEqual(commitsAfter, commitsBefore, "no snapshot commit was created when git.snapshots:false");
+    });
+
     // ─── Test: stale_uncommitted_changes NOT flagged when tree is clean ──
     test('stale_uncommitted_changes (no false positive on clean tree)', async () => {
       const dir = createRepoWithActiveMilestone();

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -316,6 +316,50 @@ describe('doctor-proactive', async () => {
       }
     });
 
+    test('health gate: git.snapshots:false suppresses stale-commit snapshot (#4420)', async () => {
+      // Build a repo whose HEAD commit is far enough in the past that the
+      // default stale-commit threshold (30 min) is exceeded, then dirty the
+      // tracked file so the snapshot path has material to commit.
+      const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-4420-")));
+      cleanups.push(dir);
+      const oldDate = "2020-01-01T00:00:00Z";
+      const env = { ...process.env, GIT_AUTHOR_DATE: oldDate, GIT_COMMITTER_DATE: oldDate };
+      execSync("git init", { cwd: dir, stdio: "ignore", env });
+      execSync("git config user.email test@test.com", { cwd: dir, stdio: "ignore", env });
+      execSync("git config user.name Test", { cwd: dir, stdio: "ignore", env });
+      writeFileSync(join(dir, "README.md"), "# test\n");
+      execSync("git add .", { cwd: dir, stdio: "ignore", env });
+      execSync('git commit -m init', { cwd: dir, stdio: "ignore", env });
+      execSync("git branch -M main", { cwd: dir, stdio: "ignore", env });
+      mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+      writeFileSync(join(dir, "README.md"), "# test\n\ndirty\n");
+      assert.ok(run("git status --porcelain", dir).length > 0, "working tree is dirty");
+
+      writeFileSync(
+        join(dir, ".gsd", "PREFERENCES.md"),
+        `---\ngit:\n  snapshots: false\n---\n`,
+      );
+
+      const commitCountBefore = run("git rev-list --count HEAD", dir);
+
+      const previousCwd = process.cwd();
+      process.chdir(dir);
+      try {
+        const result = await preDispatchHealthGate(dir);
+        assert.ok(result.proceed, "gate proceeds when snapshots are disabled");
+        assert.ok(
+          !result.fixesApplied.some(f => f.includes("gsd snapshot")),
+          `no snapshot fix reported when git.snapshots:false (got: ${JSON.stringify(result.fixesApplied)})`,
+        );
+      } finally {
+        process.chdir(previousCwd);
+      }
+
+      const commitCountAfter = run("git rev-list --count HEAD", dir);
+      assert.strictEqual(commitCountAfter, commitCountBefore, "no snapshot commit was created");
+    });
+
   } finally {
     resetProactiveHealing();
     for (const dir of cleanups) {

package/src/resources/extensions/gsd/tests/integration/doctor-runtime.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict';
  *   state_file_stale, gitignore_missing_patterns
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, realpathSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, realpathSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -252,6 +252,37 @@ node_modules/
     } else {
     }
 
+    // ─── Test 8b: Symlinked .gsd without .gitignore entry (#4423) ─────
+    if (process.platform !== "win32") {
+    test('symlinked_gsd_unignored', async () => {
+      const dir = createGitProject();
+      cleanups.push(dir);
+
+      // Create .gsd as a symlink to an external directory (standard external
+      // state layout), and write a .gitignore that does NOT list .gsd.
+      const externalGsd = mkdtempSync(join(tmpdir(), "gsd-external-doctor-"));
+      cleanups.push(externalGsd);
+      writeFileSync(join(externalGsd, "STATE.md"), "# State\n");
+      symlinkSync(externalGsd, join(dir, ".gsd"));
+
+      writeFileSync(join(dir, ".gitignore"), "node_modules/\n");
+
+      const detect = await runGSDDoctor(dir);
+      const symlinkIssues = detect.issues.filter(i => i.code === "symlinked_gsd_unignored");
+      assert.ok(symlinkIssues.length > 0, "detects symlinked .gsd without gitignore entry");
+
+      const fixed = await runGSDDoctor(dir, { fix: true });
+      assert.ok(
+        fixed.fixesApplied.some(f => f.includes(".gitignore")),
+        "fix updates .gitignore",
+      );
+
+      const content = readFileSync(join(dir, ".gitignore"), "utf-8");
+      assert.ok(/^\.gsd\/?$/m.test(content), "gitignore now has .gsd entry");
+    });
+    } else {
+    }
+
     // ─── Test 9: Orphaned completed-units detection & fix ─────────────
     test('orphaned_completed_units', async () => {
       const dir = createMinimalProject();
@@ -277,6 +308,42 @@ node_modules/
       assert.deepStrictEqual(content.length, 0, "all orphaned keys removed");
     });
 
+    // ─── Test: hook/ compound keys are NOT flagged as orphaned (#2826) ─
+    test('orphaned_completed_units — hook/ compound keys not flagged', async () => {
+      const dir = createMinimalProject();
+      cleanups.push(dir);
+
+      // Hook unit types are stored as "hook/<hookName>/<unitId...>".
+      // These are valid completions with no artifact to verify — they must
+      // not be reported as orphaned_completed_units.
+      const completedKeys = [
+        "hook/telegram-progress/M001/S01",
+        "hook/telegram-progress/M001/S01/T01",
+        "hook/my-custom-hook/M001",
+        // Mix in a genuinely missing plain key to confirm detection still works
+        "execute-task/M001/S01/T99",
+      ];
+      writeFileSync(join(dir, ".gsd", "completed-units.json"), JSON.stringify(completedKeys));
+
+      const detect = await runGSDDoctor(dir);
+      const orphanIssues = detect.issues.filter(i => i.code === "orphaned_completed_units");
+
+      // Only the plain "execute-task/M001/S01/T99" should be flagged, not the hooks.
+      // If the compound-type parsing is broken, all 4 keys (including the 3 hook/
+      // keys) would be flagged. With the fix, at most 1 key is flagged.
+      if (orphanIssues.length > 0) {
+        const msg = orphanIssues[0]!.message;
+        assert.ok(
+          !msg.includes("hook/telegram-progress") && !msg.includes("hook/my-custom-hook"),
+          `hook/ keys must not appear in orphaned_completed_units message — got: ${msg}`,
+        );
+        assert.ok(
+          !msg.includes("4 completed-unit key") && !msg.includes("3 completed-unit key"),
+          `hook/ keys must not inflate the orphaned count — got: ${msg}`,
+        );
+      }
+    });
+
     // ─── Test: Stranded lock directory detection & fix ────────────────
     // Skip on Windows: proper-lockfile uses advisory file locking on Windows,
     // not the directory-based mechanism. The .gsd.lock/ directory pattern is