pi-deck 0.1.4 → 0.1.6

package/README.md

@@ -95,6 +95,41 @@ The script will: check for a clean working tree on `main`, bump the version in a
 
 The published package includes a bundled server (`dist/server.js`) and the pre-built client SPA (`packages/client/dist/`). Workspace dependencies are inlined by esbuild; only runtime dependencies (`express`, `better-sqlite3`, etc.) are installed by npm.
 
+## Job Management
+
+Pi-deck integrates with Pi's job management system. Jobs are markdown files with YAML frontmatter that track work through phases (backlog → planning → ready → executing → review → complete).
+
+### Configurable Job Locations
+
+By default, jobs are stored in two locations:
+- `~/.pi/agent/jobs/<workspace-name>/` (primary)
+- `<workspace>/.pi/jobs/` (local)
+
+You can configure custom job directories by creating a `.pi/jobs.json` file in your workspace root:
+
+```json
+{
+  "locations": [
+    "~/.pi/agent/jobs/pi-deck",
+    ".pi/jobs",
+    "./custom-jobs-folder",
+    "/absolute/path/to/jobs"
+  ],
+  "defaultLocation": "~/.pi/agent/jobs/pi-deck"
+}
+```
+
+**Configuration options:**
+- `locations` (required): Array of directory paths to scan for jobs. Supports:
+  - Relative paths (resolved from workspace root): `"./jobs"`, `".pi/jobs"`
+  - Absolute paths: `"/Users/you/projects/jobs"`
+  - Home directory expansion: `"~/.pi/agent/jobs"`
+- `defaultLocation` (optional): Where new jobs are created. If not specified, uses the first location in `locations`.
+
+The configuration file is optional — without it, the default two-location behavior is preserved for backward compatibility.
+
+See `.pi/jobs.json.example` for a template.
+
 ## Configuration
 
 Create a config file at `~/.config/pi-deck/config.json`:

package/dist/server.js

@@ -24,8 +24,8 @@ __export(plan_service_exports, {
   writePlan: () => writePlan
 });
 import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, readdirSync as readdirSync2 } from "fs";
-import { join as join3, basename as basename2, resolve as resolve2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join3, basename, resolve as resolve2 } from "path";
+import { homedir as homedir3 } from "os";
 function parseFrontmatter(content) {
   const frontmatter = {};
   if (!content.startsWith("---")) {
@@ -88,7 +88,7 @@ function parseTasks(content) {
 function parsePlan(filePath, content) {
   const { frontmatter } = parseFrontmatter(content);
   const tasks = parseTasks(content);
-  const fileName = basename2(filePath, ".md");
+  const fileName = basename(filePath, ".md");
   let title = frontmatter.title;
   if (!title) {
     const h1Match = content.match(/^#\s+(.+)$/m);
@@ -161,9 +161,9 @@ ${fmBlock}
 ---${content.slice(endIndex + 4)}`;
 }
 function getPlanDirectories(workspacePath) {
-  const workspaceName = basename2(workspacePath);
+  const workspaceName = basename(workspacePath);
   const dirs = [];
-  const globalDir = join3(homedir2(), "plans", workspaceName);
+  const globalDir = join3(homedir3(), "plans", workspaceName);
   dirs.push(globalDir);
   const localDir = join3(workspacePath, ".pi", "plans");
   dirs.push(localDir);
@@ -254,13 +254,16 @@ __export(job_service_exports, {
   extractReviewSection: () => extractReviewSection,
   getActiveJobStates: () => getActiveJobStates,
   getJobDirectories: () => getJobDirectories,
+  getJobLocations: () => getJobLocations,
   getNextPhase: () => getNextPhase,
   getPreviousPhase: () => getPreviousPhase,
+  loadJobConfig: () => loadJobConfig,
   parseJob: () => parseJob,
   parseJobFrontmatter: () => parseJobFrontmatter,
   parseTasks: () => parseTasks,
   promoteJob: () => promoteJob,
   readJob: () => readJob,
+  resolveLocationPath: () => resolveLocationPath,
   setJobSessionId: () => setJobSessionId,
   unarchiveJob: () => unarchiveJob,
   updateJobFrontmatter: () => updateJobFrontmatter,
@@ -268,9 +271,55 @@ __export(job_service_exports, {
   writeJob: () => writeJob
 });
 import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync3, mkdirSync, renameSync } from "fs";
-import { join as join4, basename as basename3, resolve as resolve3, dirname as dirname2 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join4, basename as basename2, resolve as resolve3, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
 import YAML from "yaml";
+function loadJobConfig(workspacePath) {
+  const configPath = join4(workspacePath, ".pi", "jobs.json");
+  if (!existsSync4(configPath)) {
+    return null;
+  }
+  try {
+    const rawContent = readFileSync3(configPath, "utf-8");
+    const parsed = JSON.parse(rawContent);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("Configuration must be a JSON object");
+    }
+    if (!Array.isArray(parsed.locations) || parsed.locations.length === 0) {
+      throw new Error('Configuration must have a non-empty "locations" array');
+    }
+    for (const loc of parsed.locations) {
+      if (typeof loc !== "string") {
+        throw new Error(`Location must be a string, got ${typeof loc}`);
+      }
+    }
+    if (parsed.defaultLocation !== void 0 && typeof parsed.defaultLocation !== "string") {
+      throw new Error(`defaultLocation must be a string, got ${typeof parsed.defaultLocation}`);
+    }
+    return {
+      locations: parsed.locations,
+      defaultLocation: parsed.defaultLocation
+    };
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error(`Failed to parse ${configPath}: Invalid JSON`);
+    }
+    throw err;
+  }
+}
+function resolveLocationPath(location, workspacePath) {
+  if (typeof location !== "string") {
+    throw new Error(`Location must be a string, got ${typeof location}`);
+  }
+  let path = location;
+  if (path.startsWith("~/") || path === "~") {
+    path = join4(homedir4(), path.slice(1));
+  }
+  if (!path.startsWith("/")) {
+    path = resolve3(workspacePath, path);
+  }
+  return path;
+}
 function statusToPhase(status) {
   switch (status) {
     case "draft":
@@ -366,7 +415,7 @@ function parseJobFrontmatter(content) {
 function parseJob(filePath, content) {
   const { frontmatter } = parseJobFrontmatter(content);
   const tasks = parseTasks(content);
-  const fileName = basename3(filePath, ".md");
+  const fileName = basename2(filePath, ".md");
   let title = frontmatter.title;
   if (!title) {
     const h1Match = content.match(/^#\s+(.+)$/m);
@@ -434,9 +483,23 @@ function updateTaskInContent2(content, lineNumber, done) {
   return lines.join("\n");
 }
 function getJobDirectories(workspacePath) {
-  const workspaceName = basename3(workspacePath);
+  try {
+    const config2 = loadJobConfig(workspacePath);
+    if (config2) {
+      return config2.locations.map((loc) => {
+        const resolvedPath = resolveLocationPath(loc, workspacePath);
+        if (!existsSync4(resolvedPath)) {
+          console.warn(`[JobService] Configured job directory does not exist: ${resolvedPath}`);
+        }
+        return resolvedPath;
+      });
+    }
+  } catch (err) {
+    console.warn(`[JobService] Failed to load job configuration: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const workspaceName = basename2(workspacePath);
   const dirs = [];
-  dirs.push(join4(homedir3(), ".pi", "agent", "jobs", workspaceName));
+  dirs.push(join4(homedir4(), ".pi", "agent", "jobs", workspaceName));
   dirs.push(join4(workspacePath, ".pi", "jobs"));
   return dirs;
 }
@@ -490,11 +553,53 @@ function writeJob(jobPath, content) {
   writeFileSync2(jobPath, content, "utf-8");
   return parseJob(jobPath, content);
 }
-function createJob(workspacePath, title, description, tags) {
-  const workspaceName = basename3(workspacePath);
-  const jobsDir = join4(homedir3(), ".pi", "agent", "jobs", workspaceName);
-  if (!existsSync4(jobsDir)) {
-    mkdirSync(jobsDir, { recursive: true });
+function createJob(workspacePath, title, description, tags, location) {
+  let config2 = null;
+  let jobsDir;
+  try {
+    config2 = loadJobConfig(workspacePath);
+    if (location) {
+      if (config2) {
+        const resolvedLocation = resolveLocationPath(location, workspacePath);
+        const availableLocations = config2.locations.map((loc) => resolveLocationPath(loc, workspacePath));
+        if (availableLocations.includes(resolvedLocation)) {
+          jobsDir = resolvedLocation;
+        } else {
+          throw new Error(`Location "${location}" is not in the configured job locations`);
+        }
+      } else {
+        const defaultLocs = [
+          join4(homedir4(), ".pi", "agent", "jobs", basename2(workspacePath)),
+          join4(workspacePath, ".pi", "jobs")
+        ];
+        if (defaultLocs.includes(location)) {
+          jobsDir = location;
+        } else {
+          throw new Error(`Location "${location}" is not available (no custom config)`);
+        }
+      }
+    } else if (config2 && config2.defaultLocation) {
+      jobsDir = resolveLocationPath(config2.defaultLocation, workspacePath);
+    } else if (config2 && config2.locations.length > 0) {
+      jobsDir = resolveLocationPath(config2.locations[0], workspacePath);
+    } else {
+      const workspaceName = basename2(workspacePath);
+      jobsDir = join4(homedir4(), ".pi", "agent", "jobs", workspaceName);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not available")) {
+      throw err;
+    }
+    console.warn(`[JobService] Failed to load job config for createJob: ${err instanceof Error ? err.message : String(err)}`);
+    const workspaceName = basename2(workspacePath);
+    jobsDir = join4(homedir4(), ".pi", "agent", "jobs", workspaceName);
+  }
+  try {
+    if (!existsSync4(jobsDir)) {
+      mkdirSync(jobsDir, { recursive: true });
+    }
+  } catch (err) {
+    throw new Error(`Failed to create job directory at ${jobsDir}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
@@ -579,7 +684,7 @@ function getArchivedDir(jobDir) {
 }
 function archiveJob(jobPath) {
   const dir = dirname2(jobPath);
-  const file = basename3(jobPath);
+  const file = basename2(jobPath);
   const archivedDir = getArchivedDir(dir);
   if (!existsSync4(archivedDir)) {
     mkdirSync(archivedDir, { recursive: true });
@@ -591,7 +696,7 @@ function archiveJob(jobPath) {
 function unarchiveJob(jobPath) {
   const archivedDir = dirname2(jobPath);
   const parentDir = dirname2(archivedDir);
-  const file = basename3(jobPath);
+  const file = basename2(jobPath);
   const newPath = join4(parentDir, file);
   renameSync(jobPath, newPath);
   return newPath;
@@ -623,14 +728,22 @@ function discoverArchivedJobs(workspacePath) {
 }
 function buildJobSystemContext(workspacePath) {
   const dirs = getJobDirectories(workspacePath);
+  const config2 = loadJobConfig(workspacePath);
   const primaryDir = dirs[0];
   const jobs = discoverJobs(workspacePath);
   const jobLines = jobs.map((j) => `  - [${j.phase}] "${j.title}" \u2192 ${j.path}`).join("\n");
   const jobListing = jobs.length > 0 ? `
 Current jobs:
 ${jobLines}` : "\nNo jobs exist yet.";
+  const dirListing = dirs.map((d) => `  - ${d}`).join("\n");
   return `<job_system>
-You have access to a job management system. Jobs are markdown files with YAML frontmatter stored in: ${primaryDir}
+You have access to a job management system. Jobs are markdown files with YAML frontmatter.
+
+## Job Locations
+Jobs are stored in the following directories:
+${dirListing}
+
+${config2 ? `Configuration loaded from: .pi/jobs.json` : "Using default job locations (no .pi/jobs.json config)"}
 
 ## Job File Format
 \`\`\`markdown
@@ -660,7 +773,7 @@ What needs to be done.
 
 ## Managing Jobs
 - **Create a job**: Write a new .md file to ${primaryDir} with the frontmatter format above. Use filename format: YYYYMMDD-slug.md
-- **List jobs**: Read files from ${primaryDir}
+- **List jobs**: Read files from any of the job directories
 - **Update phase**: Edit the \`phase\` field in frontmatter. Update \`updated\` timestamp.
 - **Check off tasks**: Change \`- [ ]\` to \`- [x]\` in the job file.
 - **Complete a job**: Set phase to "complete" and add \`completedAt\` to frontmatter.
@@ -675,7 +788,19 @@ function buildPlanningPrompt(jobPath) {
   return `<active_job phase="planning">
 You have a job to plan at: ${jobPath}
 Read the job file. It contains a title and description.
+
+Before creating the plan, you MUST:
+1. Explore the codebase to understand the current implementation
+2. Search for relevant files, functions, and existing patterns
+3. Read documentation and configuration files as needed
+4. Gather context about the architecture and conventions used
+
+Do this research yourself \u2014 DO NOT include research or exploration tasks in the plan. The plan should only contain concrete implementation steps that will be performed after planning is complete.
+
 Your goal is to create a detailed implementation plan. Ask the user clarifying questions if needed, then write a concrete plan with \`- [ ]\` checkbox tasks back into the job file under a "## Plan" section.
+
+Plan tasks should be actionable implementation steps only (e.g., "Add function X", "Update file Y"). Do not include research tasks like "review current implementation" \u2014 you should do that during planning, not put it in the plan.
+
 Group tasks under \`### Phase\` headings. Keep tasks concise and actionable (start with a verb).
 When you're done writing the plan, let the user know so they can review and iterate or mark it as ready.
 </active_job>`;
@@ -699,6 +824,24 @@ function extractReviewSection(content) {
   const trimmed = sectionText.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
+function getJobLocations(workspacePath) {
+  const config2 = loadJobConfig(workspacePath);
+  const dirs = getJobDirectories(workspacePath);
+  let defaultDir;
+  if (config2 && config2.defaultLocation) {
+    defaultDir = resolveLocationPath(config2.defaultLocation, workspacePath);
+  } else if (config2 && config2.locations.length > 0) {
+    defaultDir = resolveLocationPath(config2.locations[0], workspacePath);
+  } else {
+    defaultDir = dirs[0];
+  }
+  return dirs.map((dir) => ({
+    path: dir,
+    isDefault: dir === defaultDir,
+    displayName: dir.startsWith(workspacePath) ? `.${dir.slice(workspacePath.length)}` : dir.replace(homedir4(), "~")
+    // Replace home directory with ~
+  }));
+}
 function buildReviewPrompt(jobPath) {
   const content = readFileSync3(jobPath, "utf-8");
   const reviewSection = extractReviewSection(content);
@@ -764,10 +907,10 @@ import { createServer } from "http";
 import { WebSocketServer, WebSocket } from "ws";
 import { fileURLToPath } from "url";
 import { dirname as dirname5, join as join7, resolve as resolve4, sep } from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync4, writeFileSync as writeFileSync3, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
 import { unlink } from "fs/promises";
 import { spawn } from "child_process";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { SessionManager as SessionManager2 } from "@mariozechner/pi-coding-agent";
 
 // packages/server/dist/config.js
@@ -801,9 +944,7 @@ function findProjectRoot(startDir) {
 var projectRoot = findProjectRoot(process.cwd());
 var DEFAULT_CONFIG = {
   port: 9741,
-  host: "0.0.0.0",
-  // Default to detected project root, then home as fallback
-  allowedDirectories: [projectRoot, homedir()]
+  host: "0.0.0.0"
 };
 var CONFIG_PATHS = [
   resolve(process.cwd(), "pi-deck.config.json"),
@@ -833,9 +974,6 @@ function loadConfigFromEnv() {
   if (process.env.HOST) {
     config2.host = process.env.HOST;
   }
-  if (process.env.PI_ALLOWED_DIRS) {
-    config2.allowedDirectories = process.env.PI_ALLOWED_DIRS.split(":").map((d) => resolve(d.replace(/^~/, homedir())));
-  }
   return config2;
 }
 var TILDE_PREFIX = /^~(?=\/|$)/;
@@ -847,57 +985,36 @@ function canonicalizePath(input) {
     return normalized;
   }
 }
-function normalizeDirectories(dirs) {
-  return dirs.map((d) => canonicalizePath(d));
-}
 function loadConfig() {
   const fileConfig = loadConfigFromFile();
   const envConfig = loadConfigFromEnv();
   const config2 = {
     port: envConfig.port ?? fileConfig.port ?? DEFAULT_CONFIG.port,
-    host: envConfig.host ?? fileConfig.host ?? DEFAULT_CONFIG.host,
-    allowedDirectories: normalizeDirectories(envConfig.allowedDirectories ?? fileConfig.allowedDirectories ?? DEFAULT_CONFIG.allowedDirectories)
+    host: envConfig.host ?? fileConfig.host ?? DEFAULT_CONFIG.host
   };
-  console.log("[Config] Allowed directories:", config2.allowedDirectories);
   return config2;
 }
-function isPathAllowed(path, allowedDirectories) {
-  const normalizedPath = canonicalizePath(path);
-  return allowedDirectories.some((allowed) => {
-    const normalizedAllowed = canonicalizePath(allowed);
-    if (normalizedAllowed === "/") {
-      return true;
-    }
-    return normalizedPath === normalizedAllowed || normalizedPath.startsWith(normalizedAllowed + "/");
-  });
-}
 
 // packages/server/dist/directory-browser.js
 import { readdirSync, statSync, existsSync as existsSync2 } from "fs";
-import { basename, join as join2 } from "path";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 var DirectoryBrowser = class {
-  allowedDirectories;
-  constructor(allowedDirectories) {
-    this.allowedDirectories = allowedDirectories;
-  }
   /**
    * List the allowed root directories
    */
   listRoots() {
-    return this.allowedDirectories.map((dir) => ({
-      name: basename(dir) || dir,
-      path: dir,
-      hasPiSessions: this.checkForPiSessions(dir)
-    }));
+    return [{
+      name: "Home",
+      path: homedir2(),
+      hasPiSessions: this.checkForPiSessions(homedir2())
+    }];
   }
   /**
    * Browse a directory and return its subdirectories
    */
   browse(path) {
     const normalizedPath = canonicalizePath(path);
-    if (!isPathAllowed(normalizedPath, this.allowedDirectories)) {
-      throw new Error(`Access denied: ${path} is not within allowed directories`);
-    }
     if (!existsSync2(normalizedPath)) {
       throw new Error(`Directory not found: ${path}`);
     }
@@ -942,13 +1059,13 @@ var DirectoryBrowser = class {
    * Get the allowed directories
    */
   getAllowedDirectories() {
-    return [...this.allowedDirectories];
+    return [homedir2()];
   }
 };
 
 // packages/server/dist/workspace-manager.js
 import { EventEmitter as EventEmitter3 } from "events";
-import { basename as basename4 } from "path";
+import { basename as basename3 } from "path";
 
 // packages/server/dist/session-orchestrator.js
 import { EventEmitter as EventEmitter2 } from "events";
@@ -1927,7 +2044,9 @@ var PiSession = class extends EventEmitter {
         cacheRead: msg.usage.cacheRead || 0,
         cacheWrite: msg.usage.cacheWrite || 0,
         total: (msg.usage.input || 0) + (msg.usage.output || 0)
-      } : void 0
+      } : void 0,
+      stopReason: msg.stopReason,
+      errorMessage: msg.errorMessage
     };
   }
   convertContent(content) {
@@ -2975,14 +3094,12 @@ var SessionOrchestrator = class extends EventEmitter2 {
 
 // packages/server/dist/workspace-manager.js
 var WorkspaceManager = class extends EventEmitter3 {
-  allowedDirectories;
   workspaces = /* @__PURE__ */ new Map();
   nextWorkspaceId = 1;
   syncIntegration = null;
   openingPaths = /* @__PURE__ */ new Set();
-  constructor(allowedDirectories) {
+  constructor() {
     super();
-    this.allowedDirectories = allowedDirectories;
   }
   /**
    * Set the sync integration for state tracking
@@ -2997,9 +3114,6 @@ var WorkspaceManager = class extends EventEmitter3 {
    */
   async openWorkspace(path) {
     const normalizedPath = canonicalizePath(path);
-    if (!isPathAllowed(normalizedPath, this.allowedDirectories)) {
-      throw new Error(`Access denied: ${normalizedPath} is not within allowed directories`);
-    }
     while (this.openingPaths.has(normalizedPath)) {
       await new Promise((resolve5) => setTimeout(resolve5, 10));
     }
@@ -3044,7 +3158,7 @@ var WorkspaceManager = class extends EventEmitter3 {
       const workspace = {
         id,
         path: normalizedPath,
-        name: basename4(normalizedPath) || normalizedPath,
+        name: basename3(normalizedPath) || normalizedPath,
         orchestrator,
         unsubscribe,
         clientCount: 1,
@@ -3258,9 +3372,9 @@ var WorkspaceManager = class extends EventEmitter3 {
   }
 };
 var workspaceManager = null;
-function getWorkspaceManager(allowedDirectories) {
+function getWorkspaceManager() {
   if (!workspaceManager) {
-    workspaceManager = new WorkspaceManager(allowedDirectories);
+    workspaceManager = new WorkspaceManager();
   }
   return workspaceManager;
 }
@@ -3268,7 +3382,7 @@ function getWorkspaceManager(allowedDirectories) {
 // packages/server/dist/ui-state.js
 import Database from "better-sqlite3";
 import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { dirname as dirname3, join as join5 } from "path";
 var DEFAULT_STATE = {
   openWorkspaces: [],
@@ -3287,7 +3401,7 @@ var DEFAULT_STATE = {
 var UIStateStore = class {
   db;
   constructor(dbPath) {
-    const path = dbPath || join5(homedir4(), ".config", "pi-deck", "ui-state.db");
+    const path = dbPath || join5(homedir5(), ".config", "pi-deck", "ui-state.db");
     const dir = dirname3(path);
     if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
@@ -5179,7 +5293,7 @@ var SyncIntegration = class extends EventEmitter8 {
 
 // packages/server/dist/index.js
 var config = loadConfig();
-var syncDbPath = join7(homedir5(), ".pi", "pi-deck-sync.db");
+var syncDbPath = join7(homedir6(), ".pi", "pi-deck-sync.db");
 var syncIntegration = new SyncIntegration(syncDbPath);
 console.log(`[Sync] Initialized sync database at ${syncDbPath}`);
 var PORT = config.port;
@@ -5219,9 +5333,9 @@ if (existsSync9(clientDistPath)) {
 }
 var server = createServer(app);
 var wss = new WebSocketServer({ server, path: "/ws" });
-var directoryBrowser = new DirectoryBrowser(config.allowedDirectories);
+var directoryBrowser = new DirectoryBrowser();
 var uiStateStore = getUIStateStore();
-var workspaceManager2 = getWorkspaceManager(config.allowedDirectories);
+var workspaceManager2 = getWorkspaceManager();
 workspaceManager2.setSyncIntegration(syncIntegration);
 var clientWorkspaces = /* @__PURE__ */ new Map();
 var pendingQuestionnaireRoutes = /* @__PURE__ */ new Map();
@@ -5360,7 +5474,6 @@ Please read the job file and execute the review steps.`;
 app.get("/health", (_req, res) => {
   res.json({
     status: "ok",
-    allowedDirectories: config.allowedDirectories,
     activeWorkspaces: workspaceManager2.listWorkspaces().length
   });
 });
@@ -5372,8 +5485,7 @@ wss.on("connection", async (ws) => {
   send(ws, {
     type: "connected",
     workspaces: existingWorkspaces,
-    allowedRoots: config.allowedDirectories,
-    homeDirectory: homedir5(),
+    homeDirectory: homedir6(),
     uiState,
     ...updateAvailable ? { updateAvailable } : {}
   });
@@ -5520,8 +5632,7 @@ async function handleMessage(ws, message) {
         send(ws, {
           type: "directoryList",
           path: "/",
-          entries: directoryBrowser.listRoots(),
-          allowedRoots: directoryBrowser.getAllowedDirectories()
+          entries: directoryBrowser.listRoots()
         });
       }
       break;
@@ -6183,26 +6294,6 @@ ${planNote}` : planNote;
       });
       break;
     }
-    case "updateAllowedRoots": {
-      const { roots } = message;
-      console.log("[Config] Updating allowed roots:", roots);
-      const configPath = join7(homedir5(), ".pi-deck.json");
-      let fileConfig = {};
-      try {
-        if (existsSync9(configPath)) {
-          fileConfig = JSON.parse(readFileSync4(configPath, "utf-8"));
-        }
-      } catch {
-      }
-      fileConfig.allowedDirectories = roots;
-      writeFileSync3(configPath, JSON.stringify(fileConfig, null, 2));
-      console.log("[Config] Saved config to", configPath);
-      send(ws, {
-        type: "allowedRootsUpdated",
-        roots
-      });
-      break;
-    }
     // ========================================================================
     // Session Tree Navigation
     // ========================================================================
@@ -6433,26 +6524,13 @@ ${planNote}` : planNote;
       }
       const rootPath = resolve4(workspace.path);
       const rawPath = message.path || "";
-      const expandedPath = rawPath.startsWith("~/") ? join7(homedir5(), rawPath.slice(2)) : rawPath;
+      const expandedPath = rawPath.startsWith("~/") ? join7(homedir6(), rawPath.slice(2)) : rawPath;
       const isAbsolute = expandedPath.startsWith("/");
       let targetPath;
       let displayPath;
       if (isAbsolute) {
         targetPath = resolve4(expandedPath);
         displayPath = rawPath;
-        const inWorkspace = targetPath.startsWith(rootPath + sep) || targetPath === rootPath;
-        const inAllowed = config.allowedDirectories.some((dir) => targetPath.startsWith(resolve4(dir) + sep) || targetPath === resolve4(dir));
-        if (!inWorkspace && !inAllowed) {
-          send(ws, {
-            type: "workspaceFile",
-            workspaceId: message.workspaceId,
-            path: displayPath,
-            content: "",
-            truncated: false,
-            requestId: message.requestId
-          });
-          break;
-        }
       } else {
         const relativePath = rawPath.replace(/^\/+/, "");
         targetPath = resolve4(rootPath, relativePath);
@@ -6930,6 +7008,28 @@ Please read the plan file and begin working through the tasks.`;
       syncIntegration.setJobs(message.workspaceId, jobs);
       break;
     }
+    case "getJobLocations": {
+      const workspace = workspaceManager2.getWorkspace(message.workspaceId);
+      if (!workspace)
+        break;
+      try {
+        const locations = getJobLocations(workspace.path);
+        const defaultLocation = locations.find((l) => l.isDefault)?.path || locations[0]?.path;
+        send(ws, {
+          type: "jobLocations",
+          workspaceId: message.workspaceId,
+          locations,
+          defaultLocation
+        });
+      } catch (err) {
+        send(ws, {
+          type: "error",
+          message: `Failed to get job locations: ${err instanceof Error ? err.message : "Unknown error"}`,
+          workspaceId: message.workspaceId
+        });
+      }
+      break;
+    }
     case "getJobContent": {
       const workspace = workspaceManager2.getWorkspace(message.workspaceId);
       if (!workspace)
@@ -6957,7 +7057,7 @@ Please read the plan file and begin working through the tasks.`;
       if (!workspace)
         break;
       try {
-        const { path: jobPath, job } = createJob(workspace.path, message.title, message.description, message.tags);
+        const { path: jobPath, job } = createJob(workspace.path, message.title, message.description, message.tags, message.location);
         broadcastToWorkspace(message.workspaceId, {
           type: "jobSaved",
           workspaceId: message.workspaceId,
@@ -7319,7 +7419,6 @@ if (existsSync9(clientDistPath)) {
 }
 server.listen(PORT, config.host, () => {
   console.log(`[Server] Pi-Deck server running on http://${config.host}:${PORT}`);
-  console.log(`[Server] Allowed directories: ${config.allowedDirectories.join(", ")}`);
   console.log(`[Server] WebSocket endpoint: ws://${config.host}:${PORT}/ws`);
 });
 //# sourceMappingURL=server.js.map