@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/worktree-claude-config.ts

@@ -0,0 +1,272 @@
+import fs = require('fs');
+import os = require('os');
+import path = require('path');
+import worktreeToolingEnv = require('./worktree-tooling-env');
+
+const { resolveWorktreeRoot } = worktreeToolingEnv;
+
+type MutableRecord = Record<string, unknown>;
+
+interface HookCommand {
+  type?: string;
+  command?: string;
+}
+
+interface HookEntry {
+  matcher?: string;
+  hooks?: readonly HookCommand[];
+}
+
+interface OverlayOptions {
+  includeDangerousGit?: boolean;
+}
+
+interface WorktreeOptions {
+  worktreePath?: string;
+  cwd?: string;
+}
+
+const CLAUDE_DIRNAME = '.claude';
+const MCP_BASENAME = '.mcp.json';
+const SETTINGS_BASENAME = 'settings.json';
+const OVERLAY_PREFIX = 'zeroshot-claude-settings-';
+const CLAUDE_SETTINGS_ENV = 'ZEROSHOT_CLAUDE_SETTINGS_FILE';
+const CLAUDE_MCP_CONFIG_ENV = 'ZEROSHOT_CLAUDE_MCP_CONFIG_FILE';
+const ASK_USER_HOOK = 'block-ask-user-question.py';
+const DANGEROUS_GIT_HOOK = 'block-dangerous-git.py';
+
+function isMutableRecord(value: unknown): value is MutableRecord {
+  return typeof value === 'object' && value !== null;
+}
+
+function isHookEntries(value: unknown): value is HookEntry[] {
+  return Array.isArray(value);
+}
+
+function readSettings(settingsPath: string): MutableRecord {
+  if (!fs.existsSync(settingsPath)) return {};
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not parse Claude settings overlay ${settingsPath}: ${message}`);
+  }
+  if (!isMutableRecord(parsed)) {
+    throw new TypeError(`Claude settings overlay ${settingsPath} must contain an object.`);
+  }
+  return parsed;
+}
+
+function writeSettings(settingsPath: string, settings: MutableRecord): void {
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+}
+
+function requireTargetClaudeDir(targetClaudeDir: unknown): string {
+  if (typeof targetClaudeDir !== 'string' || !targetClaudeDir) {
+    throw new Error('Claude safety hooks require an explicit per-run settings directory.');
+  }
+  if (!isClaudeSettingsOverlayDirectory(targetClaudeDir)) {
+    throw new Error(
+      `Claude safety hooks require a Zeroshot-owned Claude settings overlay: ${targetClaudeDir}`
+    );
+  }
+  return targetClaudeDir;
+}
+
+function copyHookScript(targetClaudeDir: string, hookScriptName: string): string {
+  const hooksDir = path.join(targetClaudeDir, 'hooks');
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  const sourcePath = path.join(__dirname, '..', 'cluster-hooks', hookScriptName);
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(
+      `Claude safety hook ${hookScriptName} is missing from the Zeroshot installation.`
+    );
+  }
+
+  const destinationPath = path.join(hooksDir, hookScriptName);
+  fs.copyFileSync(sourcePath, destinationPath);
+  fs.chmodSync(destinationPath, 0o755);
+  return destinationPath;
+}
+
+function ensurePreToolUseHooks(settings: MutableRecord): HookEntry[] {
+  let hooks = settings.hooks;
+  if (!hooks) {
+    hooks = {};
+    settings.hooks = hooks;
+  }
+  if (!isMutableRecord(hooks)) {
+    throw new TypeError('Claude settings hooks must be an object.');
+  }
+
+  let preToolUse = hooks.PreToolUse;
+  if (!preToolUse) {
+    preToolUse = [];
+    hooks.PreToolUse = preToolUse;
+  }
+  if (!isHookEntries(preToolUse)) {
+    throw new TypeError('Claude settings hooks.PreToolUse must be an array.');
+  }
+  return preToolUse;
+}
+
+function ensureAskUserQuestionHook(targetClaudeDir: unknown): void {
+  const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+  const hookScriptPath = copyHookScript(overlayDir, ASK_USER_HOOK);
+  const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+  const settings = readSettings(settingsPath);
+  const hooks = ensurePreToolUseHooks(settings);
+  const hasHook = hooks.some(
+    (entry) =>
+      entry.matcher === 'AskUserQuestion' ||
+      entry.hooks?.some((hook) => hook.command?.includes(ASK_USER_HOOK))
+  );
+
+  if (!hasHook) {
+    hooks.push({
+      matcher: 'AskUserQuestion',
+      hooks: [{ type: 'command', command: hookScriptPath }],
+    });
+    writeSettings(settingsPath, settings);
+  }
+}
+
+function ensureDangerousGitHook(targetClaudeDir: unknown): void {
+  const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+  const hookScriptPath = copyHookScript(overlayDir, DANGEROUS_GIT_HOOK);
+  const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+  const settings = readSettings(settingsPath);
+  const hooks = ensurePreToolUseHooks(settings);
+  const hasHook = hooks.some(
+    (entry) =>
+      entry.matcher === 'Bash' &&
+      entry.hooks?.some((hook) => hook.command?.includes(DANGEROUS_GIT_HOOK))
+  );
+
+  if (!hasHook) {
+    hooks.push({
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: hookScriptPath }],
+    });
+    writeSettings(settingsPath, settings);
+  }
+}
+
+function prepareClaudeSettingsOverlay(options: OverlayOptions = {}): string {
+  const overlayDir = fs.mkdtempSync(path.join(os.tmpdir(), OVERLAY_PREFIX));
+  fs.chmodSync(overlayDir, 0o700);
+  try {
+    ensureAskUserQuestionHook(overlayDir);
+    if (options.includeDangerousGit) ensureDangerousGitHook(overlayDir);
+    return path.join(overlayDir, SETTINGS_BASENAME);
+  } catch (error) {
+    fs.rmSync(overlayDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+function cleanupClaudeSettingsOverlay(settingsPath: unknown): boolean {
+  if (!isCanonicalClaudeSettingsOverlayPath(settingsPath)) return false;
+
+  const overlayDir = path.dirname(settingsPath);
+  if (!fs.existsSync(overlayDir)) return true;
+  if (!isClaudeSettingsOverlayPath(settingsPath)) return false;
+
+  fs.rmSync(overlayDir, { recursive: true, force: true });
+  return true;
+}
+
+function isCanonicalClaudeSettingsOverlayPath(settingsPath: unknown): settingsPath is string {
+  if (typeof settingsPath !== 'string' || !settingsPath) return false;
+  const resolvedSettingsPath = path.resolve(settingsPath);
+  const overlayDir = path.dirname(resolvedSettingsPath);
+  return (
+    resolvedSettingsPath === settingsPath &&
+    path.basename(resolvedSettingsPath) === SETTINGS_BASENAME &&
+    path.dirname(overlayDir) === path.resolve(os.tmpdir()) &&
+    path.basename(overlayDir).startsWith(OVERLAY_PREFIX)
+  );
+}
+
+function isClaudeSettingsOverlayPath(
+  settingsPath: unknown,
+  platform: NodeJS.Platform = process.platform
+): settingsPath is string {
+  if (!isCanonicalClaudeSettingsOverlayPath(settingsPath)) return false;
+
+  const overlayDir = path.dirname(settingsPath);
+  try {
+    const stat = fs.lstatSync(overlayDir);
+    const ownedByProcess = typeof process.getuid !== 'function' || stat.uid === process.getuid();
+    const privateMode = platform === 'win32' || (stat.mode & 0o777) === 0o700;
+    return stat.isDirectory() && !stat.isSymbolicLink() && ownedByProcess && privateMode;
+  } catch {
+    return false;
+  }
+}
+
+function isCanonicalClaudeSettingsOverlayDirectory(overlayDir: unknown): overlayDir is string {
+  if (
+    typeof overlayDir !== 'string' ||
+    !overlayDir ||
+    path.resolve(overlayDir) !== overlayDir
+  ) {
+    return false;
+  }
+  return isCanonicalClaudeSettingsOverlayPath(path.join(overlayDir, SETTINGS_BASENAME));
+}
+
+function isClaudeSettingsOverlayDirectory(overlayDir: unknown): overlayDir is string {
+  return (
+    typeof overlayDir === 'string' &&
+    Boolean(overlayDir) &&
+    isClaudeSettingsOverlayPath(path.join(overlayDir, SETTINGS_BASENAME))
+  );
+}
+
+function resolveRepoMcpConfigPath(options: WorktreeOptions = {}): string | null {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  if (!worktreeRoot) return null;
+
+  const candidates = [
+    path.join(worktreeRoot, MCP_BASENAME),
+    path.join(worktreeRoot, CLAUDE_DIRNAME, MCP_BASENAME),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function resolveContainerMcpConfigPath(options: WorktreeOptions = {}): string | null {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  const hostConfigPath = resolveRepoMcpConfigPath(options);
+  if (!worktreeRoot || !hostConfigPath) return null;
+
+  const relativePath = path.relative(worktreeRoot, hostConfigPath);
+  if (
+    !relativePath ||
+    path.isAbsolute(relativePath) ||
+    relativePath === '..' ||
+    relativePath.startsWith(`..${path.sep}`)
+  ) {
+    throw new Error(`Repository MCP config is outside the mounted workspace: ${hostConfigPath}`);
+  }
+
+  return path.posix.join('/workspace', relativePath.split(path.sep).join('/'));
+}
+
+export = {
+  CLAUDE_MCP_CONFIG_ENV,
+  CLAUDE_SETTINGS_ENV,
+  cleanupClaudeSettingsOverlay,
+  ensureAskUserQuestionHook,
+  ensureDangerousGitHook,
+  isCanonicalClaudeSettingsOverlayDirectory,
+  isCanonicalClaudeSettingsOverlayPath,
+  isClaudeSettingsOverlayDirectory,
+  isClaudeSettingsOverlayPath,
+  prepareClaudeSettingsOverlay,
+  resolveContainerMcpConfigPath,
+  resolveRepoMcpConfigPath,
+};

package/src/worktree-tooling-env.js

@@ -1,153 +1,131 @@
-const fs = require('fs');
-const path = require('path');
-
+"use strict";
+const fs = require("fs");
+const path = require("path");
 const TOOLING_METADATA_RELATIVE_PATH = path.join('.zeroshot', 'tooling-env.json');
 const DEFAULT_TOOL_BIN_RELATIVE_PATHS = ['.zeroshot/bin', '.worktree-tool-bin'];
 const FALLBACK_BIN_PREFIX = '.worktree-tool-bin.';
-
+function isToolingMetadata(value) {
+    return typeof value === 'object' && value !== null;
+}
 function pathKeyForEnv(env) {
-  if (Object.prototype.hasOwnProperty.call(env, 'PATH')) {
-    return 'PATH';
-  }
-  return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') || 'PATH';
+    if (Object.prototype.hasOwnProperty.call(env, 'PATH')) {
+        return 'PATH';
+    }
+    return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') ?? 'PATH';
 }
-
 function resolveExistingRealPath(candidatePath) {
-  try {
-    return fs.realpathSync(candidatePath);
-  } catch {
-    return null;
-  }
+    try {
+        return fs.realpathSync(candidatePath);
+    }
+    catch {
+        return null;
+    }
 }
-
 function isWithinRoot(candidatePath, rootPath) {
-  const candidateRealPath = resolveExistingRealPath(candidatePath);
-  const rootRealPath = resolveExistingRealPath(rootPath);
-  if (!candidateRealPath || !rootRealPath) {
-    return false;
-  }
-
-  return (
-    candidateRealPath === rootRealPath || candidateRealPath.startsWith(`${rootRealPath}${path.sep}`)
-  );
+    const candidateRealPath = resolveExistingRealPath(candidatePath);
+    const rootRealPath = resolveExistingRealPath(rootPath);
+    if (!candidateRealPath || !rootRealPath) {
+        return false;
+    }
+    return (candidateRealPath === rootRealPath || candidateRealPath.startsWith(`${rootRealPath}${path.sep}`));
 }
-
 function dedupePaths(entries) {
-  const seen = new Set();
-  const orderedEntries = [];
-
-  for (const entry of entries) {
-    if (!entry || seen.has(entry)) {
-      continue;
-    }
-    seen.add(entry);
-    orderedEntries.push(entry);
-  }
-
-  return orderedEntries;
+    const seen = new Set();
+    const orderedEntries = [];
+    for (const entry of entries) {
+        if (!entry || seen.has(entry)) {
+            continue;
+        }
+        seen.add(entry);
+        orderedEntries.push(entry);
+    }
+    return orderedEntries;
 }
-
 function hasToolingMetadata(dirPath) {
-  return fs.existsSync(path.join(dirPath, TOOLING_METADATA_RELATIVE_PATH));
+    return fs.existsSync(path.join(dirPath, TOOLING_METADATA_RELATIVE_PATH));
 }
-
 function hasGitEntry(dirPath) {
-  return fs.existsSync(path.join(dirPath, '.git'));
+    return fs.existsSync(path.join(dirPath, '.git'));
 }
-
 function resolveWorktreeRoot(startDir) {
-  if (!startDir) {
-    return null;
-  }
-
-  let currentDir = path.resolve(startDir);
-  let nearestGitRoot = null;
-  while (true) {
-    if (hasToolingMetadata(currentDir)) {
-      return currentDir;
-    }
-    if (!nearestGitRoot && hasGitEntry(currentDir)) {
-      nearestGitRoot = currentDir;
-    }
-
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) {
-      return nearestGitRoot;
-    }
-    currentDir = parentDir;
-  }
+    if (!startDir) {
+        return null;
+    }
+    let currentDir = path.resolve(startDir);
+    let nearestGitRoot = null;
+    while (true) {
+        if (hasToolingMetadata(currentDir)) {
+            return currentDir;
+        }
+        if (!nearestGitRoot && hasGitEntry(currentDir)) {
+            nearestGitRoot = currentDir;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return nearestGitRoot;
+        }
+        currentDir = parentDir;
+    }
 }
-
 function readToolingMetadata(worktreeRoot) {
-  const metadataPath = path.join(worktreeRoot, TOOLING_METADATA_RELATIVE_PATH);
-  if (!fs.existsSync(metadataPath)) {
-    return null;
-  }
-
-  try {
-    const parsed = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-    if (!parsed || typeof parsed !== 'object') {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
+    const metadataPath = path.join(worktreeRoot, TOOLING_METADATA_RELATIVE_PATH);
+    if (!fs.existsSync(metadataPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+        if (!isToolingMetadata(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
 }
-
 function listFallbackBinDirectories(worktreeRoot) {
-  try {
-    return fs
-      .readdirSync(worktreeRoot, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory() && entry.name.startsWith(FALLBACK_BIN_PREFIX))
-      .map((entry) => path.join(worktreeRoot, entry.name));
-  } catch {
-    return [];
-  }
+    try {
+        return fs
+            .readdirSync(worktreeRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith(FALLBACK_BIN_PREFIX))
+            .map((entry) => path.join(worktreeRoot, entry.name));
+    }
+    catch {
+        return [];
+    }
 }
-
 function resolveWorktreeToolBinEntries(options = {}) {
-  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
-  if (!worktreeRoot) {
-    return [];
-  }
-
-  const metadata = readToolingMetadata(worktreeRoot);
-  const hasExplicitWorktreePath =
-    typeof options.worktreePath === 'string' && options.worktreePath.trim().length > 0;
-  if (!metadata && !hasExplicitWorktreePath) {
-    return [];
-  }
-
-  const candidates = [];
-  if (typeof metadata?.toolBinDir === 'string' && metadata.toolBinDir.trim()) {
-    candidates.push(metadata.toolBinDir.trim());
-  }
-
-  for (const relativePath of DEFAULT_TOOL_BIN_RELATIVE_PATHS) {
-    candidates.push(path.join(worktreeRoot, relativePath));
-  }
-  candidates.push(...listFallbackBinDirectories(worktreeRoot));
-
-  return dedupePaths(candidates).filter((candidatePath) =>
-    isWithinRoot(candidatePath, worktreeRoot)
-  );
+    const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+    if (!worktreeRoot) {
+        return [];
+    }
+    const metadata = readToolingMetadata(worktreeRoot);
+    const hasExplicitWorktreePath = typeof options.worktreePath === 'string' && options.worktreePath.trim().length > 0;
+    if (!metadata && !hasExplicitWorktreePath) {
+        return [];
+    }
+    const candidates = [];
+    if (typeof metadata?.toolBinDir === 'string' && metadata.toolBinDir.trim()) {
+        candidates.push(metadata.toolBinDir.trim());
+    }
+    for (const relativePath of DEFAULT_TOOL_BIN_RELATIVE_PATHS) {
+        candidates.push(path.join(worktreeRoot, relativePath));
+    }
+    candidates.push(...listFallbackBinDirectories(worktreeRoot));
+    return dedupePaths(candidates).filter((candidatePath) => isWithinRoot(candidatePath, worktreeRoot));
 }
-
 function prependWorktreeToolBinToEnv(env, options = {}) {
-  const toolBinEntries = resolveWorktreeToolBinEntries(options);
-  if (toolBinEntries.length === 0) {
+    const toolBinEntries = resolveWorktreeToolBinEntries(options);
+    if (toolBinEntries.length === 0) {
+        return env;
+    }
+    const pathKey = pathKeyForEnv(env);
+    const existingEntries = (env[pathKey] || '').split(path.delimiter).filter(Boolean);
+    env[pathKey] = dedupePaths([...toolBinEntries, ...existingEntries]).join(path.delimiter);
     return env;
-  }
-
-  const pathKey = pathKeyForEnv(env);
-  const existingEntries = (env[pathKey] || '').split(path.delimiter).filter(Boolean);
-  env[pathKey] = dedupePaths([...toolBinEntries, ...existingEntries]).join(path.delimiter);
-  return env;
 }
-
 module.exports = {
-  prependWorktreeToolBinToEnv,
-  resolveWorktreeRoot,
-  resolveWorktreeToolBinEntries,
+    prependWorktreeToolBinToEnv,
+    resolveWorktreeRoot,
+    resolveWorktreeToolBinEntries,
 };

package/src/worktree-tooling-env.ts

@@ -0,0 +1,142 @@
+import fs = require('fs');
+import path = require('path');
+interface WorktreeToolingOptions {
+  worktreePath?: string;
+  cwd?: string;
+}
+interface ToolingMetadata {
+  toolBinDir?: unknown;
+}
+const TOOLING_METADATA_RELATIVE_PATH = path.join('.zeroshot', 'tooling-env.json');
+const DEFAULT_TOOL_BIN_RELATIVE_PATHS = ['.zeroshot/bin', '.worktree-tool-bin'];
+const FALLBACK_BIN_PREFIX = '.worktree-tool-bin.';
+function isToolingMetadata(value: unknown): value is ToolingMetadata {
+  return typeof value === 'object' && value !== null;
+}
+function pathKeyForEnv(env: NodeJS.ProcessEnv): string {
+  if (Object.prototype.hasOwnProperty.call(env, 'PATH')) {
+    return 'PATH';
+  }
+  return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') ?? 'PATH';
+}
+function resolveExistingRealPath(candidatePath: string): string | null {
+  try {
+    return fs.realpathSync(candidatePath);
+  } catch {
+    return null;
+  }
+}
+function isWithinRoot(candidatePath: string, rootPath: string): boolean {
+  const candidateRealPath = resolveExistingRealPath(candidatePath);
+  const rootRealPath = resolveExistingRealPath(rootPath);
+  if (!candidateRealPath || !rootRealPath) {
+    return false;
+  }
+  return (
+    candidateRealPath === rootRealPath || candidateRealPath.startsWith(`${rootRealPath}${path.sep}`)
+  );
+}
+function dedupePaths(entries: Iterable<string | null | undefined>): string[] {
+  const seen = new Set<string>();
+  const orderedEntries: string[] = [];
+  for (const entry of entries) {
+    if (!entry || seen.has(entry)) {
+      continue;
+    }
+    seen.add(entry);
+    orderedEntries.push(entry);
+  }
+  return orderedEntries;
+}
+function hasToolingMetadata(dirPath: string): boolean {
+  return fs.existsSync(path.join(dirPath, TOOLING_METADATA_RELATIVE_PATH));
+}
+function hasGitEntry(dirPath: string): boolean {
+  return fs.existsSync(path.join(dirPath, '.git'));
+}
+function resolveWorktreeRoot(startDir: string | null | undefined): string | null {
+  if (!startDir) {
+    return null;
+  }
+  let currentDir = path.resolve(startDir);
+  let nearestGitRoot: string | null = null;
+  while (true) {
+    if (hasToolingMetadata(currentDir)) {
+      return currentDir;
+    }
+    if (!nearestGitRoot && hasGitEntry(currentDir)) {
+      nearestGitRoot = currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return nearestGitRoot;
+    }
+    currentDir = parentDir;
+  }
+}
+function readToolingMetadata(worktreeRoot: string): ToolingMetadata | null {
+  const metadataPath = path.join(worktreeRoot, TOOLING_METADATA_RELATIVE_PATH);
+  if (!fs.existsSync(metadataPath)) {
+    return null;
+  }
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    if (!isToolingMetadata(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function listFallbackBinDirectories(worktreeRoot: string): string[] {
+  try {
+    return fs
+      .readdirSync(worktreeRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith(FALLBACK_BIN_PREFIX))
+      .map((entry) => path.join(worktreeRoot, entry.name));
+  } catch {
+    return [];
+  }
+}
+function resolveWorktreeToolBinEntries(options: WorktreeToolingOptions = {}): string[] {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  if (!worktreeRoot) {
+    return [];
+  }
+  const metadata = readToolingMetadata(worktreeRoot);
+  const hasExplicitWorktreePath =
+    typeof options.worktreePath === 'string' && options.worktreePath.trim().length > 0;
+  if (!metadata && !hasExplicitWorktreePath) {
+    return [];
+  }
+  const candidates: string[] = [];
+  if (typeof metadata?.toolBinDir === 'string' && metadata.toolBinDir.trim()) {
+    candidates.push(metadata.toolBinDir.trim());
+  }
+  for (const relativePath of DEFAULT_TOOL_BIN_RELATIVE_PATHS) {
+    candidates.push(path.join(worktreeRoot, relativePath));
+  }
+  candidates.push(...listFallbackBinDirectories(worktreeRoot));
+  return dedupePaths(candidates).filter((candidatePath) =>
+    isWithinRoot(candidatePath, worktreeRoot)
+  );
+}
+function prependWorktreeToolBinToEnv(
+  env: NodeJS.ProcessEnv,
+  options: WorktreeToolingOptions = {}
+): NodeJS.ProcessEnv {
+  const toolBinEntries = resolveWorktreeToolBinEntries(options);
+  if (toolBinEntries.length === 0) {
+    return env;
+  }
+  const pathKey = pathKeyForEnv(env);
+  const existingEntries = (env[pathKey] || '').split(path.delimiter).filter(Boolean);
+  env[pathKey] = dedupePaths([...toolBinEntries, ...existingEntries]).join(path.delimiter);
+  return env;
+}
+export = {
+  prependWorktreeToolBinToEnv,
+  resolveWorktreeRoot,
+  resolveWorktreeToolBinEntries,
+};

package/task-lib/completion.js

@@ -2,8 +2,7 @@
  * Shell completion setup for ct
  * Placeholder - completion not yet implemented
  */
-
 export function setupCompletion() {
-  // TODO: Implement shell completion
-  // For now, this is a no-op
+    // TODO: Implement shell completion
+    // For now, this is a no-op
 }

package/task-lib/completion.ts

@@ -0,0 +1,9 @@
+/**
+ * Shell completion setup for ct
+ * Placeholder - completion not yet implemented
+ */
+
+export function setupCompletion(): void {
+  // TODO: Implement shell completion
+  // For now, this is a no-op
+}