kc-beta 0.3.2 → 0.5.4

package/src/agent/event-log.js

@@ -12,15 +12,28 @@ import { estimateTokens } from "./token-counter.js";
 export class EventLog {
   /**
    * @param {string} workspacePath - Session workspace directory
+   * @param {object} [opts]
+   * @param {string} [opts.logDir] - Override absolute path for the events directory
+   *   (used for sub-agent isolation, Bug 2)
    */
-  constructor(workspacePath) {
-    this._dir = path.join(workspacePath, "logs");
+  constructor(workspacePath, opts = {}) {
+    this._dir = opts.logDir || path.join(workspacePath, "logs");
     this._logPath = path.join(this._dir, "events.jsonl");
     this._seq = 0;
     this._estimatedTokens = 0;
     this._initFromExisting();
   }
 
+  /**
+   * Re-point this event log at a new directory. Used by
+   * `engine.renameSession()` (Bug 3).
+   */
+  _setWorkspacePath(newWorkspacePath, opts = {}) {
+    this._dir = opts.logDir || path.join(newWorkspacePath, "logs");
+    this._logPath = path.join(this._dir, "events.jsonl");
+    // Sequence counter stays — we keep counting from where we left off.
+  }
+
   /** Current sequence number */
   get currentSeq() { return this._seq; }
 

package/src/agent/history.js

@@ -1,31 +1,42 @@
 import fs from "node:fs";
 import path from "node:path";
+import { estimateTokens } from "./token-counter.js";
+
+// Belt-and-suspenders cap on any single message's content. Block 11 tool-call
+// offloading already prevents tool outputs from getting this big in normal use,
+// but old/migrated workspaces and edge cases benefit from a hard ceiling that
+// keeps a single bloated message from blowing the model's context budget alone.
+const DEFAULT_MAX_MESSAGE_TOKENS = 30000;
 
 /**
  * Manages the message list for the OpenAI-compatible API.
- * Persists to workspace/logs/conversation/ on every write.
- * Loads existing history when workspacePath is provided.
+ * Persists to <conversationDir>/ on every write.
+ *
+ * @param {string} [workspacePath] - Workspace directory (default conversation dir is workspacePath/logs/conversation/)
+ * @param {object} [opts]
+ * @param {string} [opts.conversationDir] - Override absolute path (used for sub-agent isolation, Bug 2)
+ * @param {number} [opts.maxMessageTokens] - Per-message content cap (default 30000)
  */
 export class ConversationHistory {
-  /**
-   * @param {string} [workspacePath] - Workspace directory for persistence
-   */
-  constructor(workspacePath) {
+  constructor(workspacePath, opts = {}) {
     /** @type {Array<object>} API messages */
     this._messages = [];
     /** @type {Array<object>} Flat display log for replay */
     this._displayLog = [];
     this._workspacePath = workspacePath || null;
+    this._conversationDir = opts.conversationDir || (workspacePath ? path.join(workspacePath, "logs", "conversation") : null);
+    this._maxMessageTokens = opts.maxMessageTokens ?? DEFAULT_MAX_MESSAGE_TOKENS;
 
-    if (this._workspacePath) this._load();
+    if (this._conversationDir) this._load();
   }
 
   get messages() { return this._messages; }
   get displayLog() { return this._displayLog; }
 
   addUser(text) {
-    this._messages.push({ role: "user", content: text });
-    this._displayLog.push({ role: "user", content: text });
+    const capped = this._capContent(text);
+    this._messages.push({ role: "user", content: capped });
+    this._displayLog.push({ role: "user", content: capped });
     this._save();
   }
 
@@ -34,15 +45,19 @@ export class ConversationHistory {
    * @param {object} message
    */
   addRaw(message) {
-    this._messages.push(message);
+    const msg = { ...message };
+    if (typeof msg.content === "string") {
+      msg.content = this._capContent(msg.content);
+    }
+    this._messages.push(msg);
 
-    const role = message.role || "";
+    const role = msg.role || "";
     if (role === "assistant") {
-      const content = message.content || "";
+      const content = msg.content || "";
       if (content) {
         this._displayLog.push({ role: "agent", content });
       }
-      for (const tc of message.tool_calls || []) {
+      for (const tc of msg.tool_calls || []) {
         const fn = tc.function || {};
         let toolInput = {};
         try { toolInput = JSON.parse(fn.arguments || "{}"); } catch { /* ignore */ }
@@ -53,7 +68,7 @@ export class ConversationHistory {
         });
       }
     } else if (role === "tool") {
-      const content = message.content || "";
+      const content = msg.content || "";
       // Update the last tool entry with output
       for (let i = this._displayLog.length - 1; i >= 0; i--) {
         if (this._displayLog[i].role === "tool" && !("toolOutput" in this._displayLog[i])) {
@@ -66,33 +81,86 @@ export class ConversationHistory {
     this._save();
   }
 
+  /**
+   * Cap a single message's content if it exceeds maxMessageTokens. Cuts the
+   * middle, keeps head + tail, leaves a marker pointing at logs/events.jsonl
+   * for the full content (event log keeps everything via appendFileSync).
+   *
+   * CJK-aware: derives the character budget from a sample-based chars/token
+   * ratio. Latin sample ≈ 4 chars/token, CJK ≈ 0.67 chars/token. Iterative
+   * tightening converges on the cap; clamping prevents accidental doubling
+   * if the heuristic is ever wrong.
+   */
+  _capContent(content) {
+    if (typeof content !== "string" || !content) return content;
+    const tokens = estimateTokens(content);
+    if (tokens <= this._maxMessageTokens) return content;
+
+    const target = Math.max(100, this._maxMessageTokens - 50); // reserve for marker
+    const ratio = this._charsPerToken(content);
+    let charBudget = Math.max(100, Math.floor(target * ratio));
+
+    for (let i = 0; i < 5; i++) {
+      const head = Math.min(Math.floor(charBudget * 0.6), content.length);
+      const tail = Math.min(Math.floor(charBudget * 0.3), Math.max(0, content.length - head));
+      // If proposed slices would cover the whole input, truncating creates
+      // no savings — return original (the safety-net cap rather doubles than truncates).
+      if (head + tail >= content.length) return content;
+      const result = content.slice(0, head) + this._truncMarker(tokens) + content.slice(-tail);
+      if (estimateTokens(result) <= this._maxMessageTokens) return result;
+      charBudget = Math.floor(charBudget * 0.7);
+    }
+
+    // Last resort after 5 iterations: head only, no tail.
+    const headOnly = Math.min(Math.max(charBudget, 100), content.length);
+    return content.slice(0, headOnly) + this._truncMarker(tokens);
+  }
+
+  /** Sample-based chars-per-token ratio. Inverse of estimateTokens rate. */
+  _charsPerToken(content) {
+    const sample = content.slice(0, 2000);
+    const t = estimateTokens(sample) || 1;
+    return Math.max(0.5, sample.length / t);
+  }
+
+  _truncMarker(originalTokens) {
+    return `\n\n[…truncated, ${originalTokens} tokens; full content in logs/events.jsonl…]\n\n`;
+  }
+
+  /**
+   * Re-point this history at a new conversation directory. Used by
+   * `engine.renameSession()` (Bug 3) when the workspace is renamed.
+   */
+  _setWorkspacePath(newWorkspacePath, opts = {}) {
+    this._workspacePath = newWorkspacePath;
+    this._conversationDir = opts.conversationDir || path.join(newWorkspacePath, "logs", "conversation");
+  }
+
   _save() {
-    if (!this._workspacePath) return;
-    const convDir = path.join(this._workspacePath, "logs", "conversation");
-    fs.mkdirSync(convDir, { recursive: true });
+    if (!this._conversationDir) return;
+    fs.mkdirSync(this._conversationDir, { recursive: true });
     fs.writeFileSync(
-      path.join(convDir, "messages.json"),
+      path.join(this._conversationDir, "messages.json"),
       JSON.stringify(this._messages, null, 2),
       "utf-8",
     );
     fs.writeFileSync(
-      path.join(convDir, "display.json"),
+      path.join(this._conversationDir, "display.json"),
       JSON.stringify(this._displayLog, null, 2),
       "utf-8",
     );
   }
 
   _load() {
-    if (!this._workspacePath) return;
-    const convDir = path.join(this._workspacePath, "logs", "conversation");
+    if (!this._conversationDir) return;
 
-    const msgPath = path.join(convDir, "messages.json");
+    const msgPath = path.join(this._conversationDir, "messages.json");
     if (fs.existsSync(msgPath)) {
       try { this._messages = JSON.parse(fs.readFileSync(msgPath, "utf-8")); }
       catch { this._messages = []; }
     }
 
-    const displayPath = path.join(convDir, "display.json");
+    const displayPath = path.join(this._conversationDir, "display.json");
     if (fs.existsSync(displayPath)) {
       try { this._displayLog = JSON.parse(fs.readFileSync(displayPath, "utf-8")); }
       catch { this._displayLog = []; }

package/src/agent/pipelines/initializer.js

@@ -73,15 +73,12 @@ export class ProjectInitializer extends Pipeline {
       fs.writeFileSync(envPath, envContent, "utf-8");
     }
 
-    const manifestPath = path.join(this._workspace.cwd, "versions.json");
-    if (!fs.existsSync(manifestPath)) {
-      fs.writeFileSync(manifestPath, JSON.stringify({ version: "0.1.0", entries: [] }, null, 2), "utf-8");
-    }
-
-    // AGENT.md — per-project context (agent can modify)
+    // AGENT.md — per-project context (agent can modify). Auto-commit so
+    // git captures the seed.
     const agentMdPath = path.join(this._workspace.cwd, "AGENT.md");
     if (!fs.existsSync(agentMdPath) && fs.existsSync(AGENT_MD_TEMPLATE)) {
       fs.copyFileSync(AGENT_MD_TEMPLATE, agentMdPath);
+      this._workspace.autoCommit?.("AGENT.md", "seed");
     }
 
     this.workspaceCreated = true;

package/src/agent/retry.js

@@ -12,18 +12,26 @@ const JITTER_FRACTION = 0.2;
 const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504, 520, 522, 524]);
 const NON_RETRYABLE_STATUS = new Set([400, 401, 403, 404, 422]);
 
+// Phrases that indicate the request itself is too large for the model.
+// Some providers return these as 400 (correct), others as 500/503 (incorrect),
+// but in either case retrying just delays the inevitable failure.
+const CONTEXT_LENGTH_PATTERNS = /context_length|context length|maximum context|too many tokens|prompt is too long|input length|input is too long|exceeds.{0,20}context|exceeded the max|reduce the length/i;
+
 /**
  * Determine if an error is retryable.
  * @param {Error} err
  * @returns {boolean}
  */
 function isRetryable(err) {
+  const msg = err.message || "";
+  // Context-length errors are non-retryable regardless of status code
+  if (CONTEXT_LENGTH_PATTERNS.test(msg)) return false;
+
   if (err.status) {
     if (NON_RETRYABLE_STATUS.has(err.status)) return false;
     if (RETRYABLE_STATUS.has(err.status)) return true;
   }
   // Network errors (ECONNRESET, ETIMEDOUT, fetch TypeError, AbortError)
-  const msg = err.message || "";
   if (/ECONNRESET|ETIMEDOUT|ENOTFOUND|ECONNREFUSED|UND_ERR|fetch failed|network|socket hang up/i.test(msg)) {
     return true;
   }

package/src/agent/rule-catalog-normalize.js

@@ -0,0 +1,37 @@
+/**
+ * Normalize a catalog.json payload into a flat array of rule records.
+ *
+ * KC the agent has historically produced catalog.json in at least four shapes,
+ * and earlier code paths assumed a flat array — silently dropping everything
+ * when the catalog was object-shaped. This helper unifies the handling so
+ * the engine, the rule_catalog tool, and the release tool all see the same
+ * list of rules regardless of how the file was written.
+ *
+ * Accepted shapes:
+ *   1. [rule, rule, ...]                              flat array (original)
+ *   2. { rules: [...] }                               wrapper object
+ *   3. { categories: { A: [...], B: [...] }, ... }    grouped by category
+ *   4. { categories: { A: { rules: [...] }, ... } }   nested category objects
+ *
+ * Anything else (null, wrong shape, throws) returns [].
+ */
+export function normalizeRuleCatalog(catalog) {
+  if (Array.isArray(catalog)) return catalog;
+  if (!catalog || typeof catalog !== "object") return [];
+
+  if (Array.isArray(catalog.rules)) return catalog.rules;
+
+  if (catalog.categories && typeof catalog.categories === "object") {
+    const out = [];
+    for (const group of Object.values(catalog.categories)) {
+      if (Array.isArray(group)) {
+        out.push(...group);
+      } else if (group && Array.isArray(group.rules)) {
+        out.push(...group.rules);
+      }
+    }
+    if (out.length > 0) return out;
+  }
+
+  return [];
+}

package/src/agent/scheduler.js

@@ -0,0 +1,276 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const SCHEDULES_REL = "schedules.json";
+const WRAPPERS_DIR_REL = path.join("scripts", "ingest");
+const INGEST_LOG_REL = path.join("logs", "ingest.log");
+const VALID_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+
+/**
+ * Per-session schedule registry + wrapper-script generator.
+ *
+ * KC defines fetch jobs (each is a shell command). For each enabled job,
+ * Scheduler renders a self-contained wrapper script under
+ * `workspace/scripts/ingest/<id>.sh`. The user installs the wrapper into
+ * their crontab via `crontab -e`. Cron invokes the script directly — no
+ * kc-beta runtime dependency, works while kc-beta is closed.
+ *
+ * The wrapper:
+ *   - exports WORKSPACE / INPUT_DIR / PROJECT_DIR env vars
+ *   - snapshots input/ filenames before running
+ *   - runs the user's command
+ *   - prefixes any new files in input/ with `<job-id>_<YYYYMMDD-HHMMSS>_`
+ *   - appends to logs/ingest.log
+ */
+export class Scheduler {
+  /**
+   * @param {import('./workspace.js').Workspace} workspace
+   */
+  constructor(workspace) {
+    this._workspace = workspace;
+  }
+
+  // --- registry ---
+
+  load() {
+    const p = this._abs(SCHEDULES_REL);
+    if (!fs.existsSync(p)) return { version: 1, jobs: [] };
+    try {
+      const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+      if (!data.jobs) return { version: 1, jobs: [] };
+      return data;
+    } catch {
+      return { version: 1, jobs: [] };
+    }
+  }
+
+  save(state) {
+    const p = this._abs(SCHEDULES_REL);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(state, null, 2), "utf-8");
+    this._workspace.autoCommit?.(SCHEDULES_REL, "schedules");
+  }
+
+  list() {
+    return this.load().jobs;
+  }
+
+  /**
+   * Add a job. Returns { ok: true, job } or { ok: false, reason }.
+   * @param {{id:string, command:string, description?:string, cron_hint?:string, enabled?:boolean}} input
+   */
+  add(input) {
+    const id = (input.id || "").trim();
+    const command = (input.command || "").trim();
+    if (!VALID_ID.test(id)) return { ok: false, reason: `id must match ${VALID_ID} (got '${id}')` };
+    if (!command) return { ok: false, reason: "command is required" };
+
+    const state = this.load();
+    if (state.jobs.find((j) => j.id === id)) {
+      return { ok: false, reason: `job '${id}' already exists; remove first or pick another id` };
+    }
+
+    const job = {
+      id,
+      type: "shell",
+      command,
+      description: input.description || "",
+      cron_hint: input.cron_hint || "",
+      enabled: input.enabled !== false,
+      created_at: new Date().toISOString(),
+    };
+    state.jobs.push(job);
+    this.save(state);
+    if (job.enabled) this.renderWrapper(job);
+    return { ok: true, job };
+  }
+
+  remove(id) {
+    const state = this.load();
+    const before = state.jobs.length;
+    state.jobs = state.jobs.filter((j) => j.id !== id);
+    if (state.jobs.length === before) return { ok: false, reason: `no job '${id}'` };
+    this.save(state);
+    this._removeWrapper(id);
+    return { ok: true };
+  }
+
+  setEnabled(id, enabled) {
+    const state = this.load();
+    const job = state.jobs.find((j) => j.id === id);
+    if (!job) return { ok: false, reason: `no job '${id}'` };
+    job.enabled = !!enabled;
+    this.save(state);
+    if (job.enabled) this.renderWrapper(job);
+    else this._removeWrapper(id);
+    return { ok: true, job };
+  }
+
+  // --- wrapper script ---
+
+  /**
+   * Render the per-job wrapper script. Returns absolute path.
+   * @param {object} job
+   */
+  renderWrapper(job) {
+    const wrappersDirAbs = this._abs(WRAPPERS_DIR_REL);
+    fs.mkdirSync(wrappersDirAbs, { recursive: true });
+    const scriptRel = path.join(WRAPPERS_DIR_REL, `${job.id}.sh`);
+    const scriptAbs = this._abs(scriptRel);
+
+    const wsAbs = this._workspace.cwd;
+    const projectAbs = this._workspace.projectDir || "";
+    const ingestLogAbs = this._abs(INGEST_LOG_REL);
+    const inputDirAbs = path.join(wsAbs, "input");
+
+    // Uses `find -newer` against a sentinel file to detect new arrivals.
+    // Portable across macOS BSD find and GNU find (no -printf, no comm/process-sub).
+    const body = [
+      "#!/bin/sh",
+      "# KC Agent ingestion wrapper",
+      `# Job: ${job.id}`,
+      `# Description: ${(job.description || "").replace(/[\r\n]/g, " ")}`,
+      `# Generated: ${new Date().toISOString()}`,
+      "# Do not edit by hand — regenerated by `schedule_fetch`.",
+      "",
+      "set -u",
+      `WORKSPACE=${shQuote(wsAbs)}`,
+      `INPUT_DIR=${shQuote(inputDirAbs)}`,
+      `PROJECT_DIR=${shQuote(projectAbs)}`,
+      `LOG_FILE=${shQuote(ingestLogAbs)}`,
+      `JOB_ID=${shQuote(job.id)}`,
+      'export WORKSPACE INPUT_DIR PROJECT_DIR',
+      "",
+      'mkdir -p "$INPUT_DIR" "$(dirname "$LOG_FILE")"',
+      'TS=$(date -u +%Y%m%d-%H%M%S)',
+      "",
+      '# Sentinel file for `find -newer` to detect arrivals',
+      'SENTINEL=$(mktemp -t kc_ingest_sentinel.XXXXXX) || exit 1',
+      'sleep 1  # ensure mtime granularity',
+      "",
+      `echo "[$TS] job=$JOB_ID start" >> "$LOG_FILE"`,
+      `{ ${job.command}; } >> "$LOG_FILE" 2>&1`,
+      'EXIT_CODE=$?',
+      "",
+      "# Rename any files newer than the sentinel: prepend job id + timestamp.",
+      "# Skip files already prefixed with this job id (idempotent re-runs).",
+      'find "$INPUT_DIR" -maxdepth 1 -type f -newer "$SENTINEL" 2>/dev/null | while IFS= read -r f; do',
+      '  base=$(basename "$f")',
+      '  case "$base" in',
+      `    "$\{JOB_ID\}_"*) continue ;;`,
+      '  esac',
+      '  mv "$f" "$INPUT_DIR/${JOB_ID}_${TS}_${base}"',
+      'done',
+      "",
+      'rm -f "$SENTINEL"',
+      `echo "[$TS] job=$JOB_ID exit=$EXIT_CODE" >> "$LOG_FILE"`,
+      'exit $EXIT_CODE',
+      "",
+    ].join("\n");
+
+    fs.writeFileSync(scriptAbs, body, "utf-8");
+    fs.chmodSync(scriptAbs, 0o755);
+    this._workspace.autoCommit?.(scriptRel, "wrapper");
+    return scriptAbs;
+  }
+
+  _removeWrapper(id) {
+    const scriptRel = path.join(WRAPPERS_DIR_REL, `${id}.sh`);
+    const scriptAbs = this._abs(scriptRel);
+    if (fs.existsSync(scriptAbs)) {
+      fs.unlinkSync(scriptAbs);
+      this._workspace.autoCommit?.(scriptRel, "wrapper-remove");
+    }
+  }
+
+  /**
+   * Generate paste-ready crontab lines for all enabled jobs.
+   * If a job lacks `cron_hint`, the line is commented out with a hint to fill it in.
+   * @returns {string}
+   */
+  formatCrontab() {
+    const jobs = this.list().filter((j) => j.enabled);
+    if (jobs.length === 0) return "(no enabled jobs to install)";
+
+    const lines = [
+      "# KC Agent ingestion jobs — install with `crontab -e` then paste these lines.",
+      `# Generated ${new Date().toISOString()}`,
+      "",
+    ];
+    for (const j of jobs) {
+      const scriptAbs = this._abs(path.join(WRAPPERS_DIR_REL, `${j.id}.sh`));
+      if (j.cron_hint) {
+        lines.push(`# ${j.description || j.id}`);
+        lines.push(`${j.cron_hint} ${scriptAbs}`);
+      } else {
+        lines.push(`# ${j.description || j.id} — set the schedule yourself (5 cron fields)`);
+        lines.push(`# <minute> <hour> <day-of-month> <month> <day-of-week>  ${scriptAbs}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+
+  /**
+   * Tail of logs/ingest.log (last N lines), or empty string if missing.
+   */
+  tailLog(lines = 20) {
+    const p = this._abs(INGEST_LOG_REL);
+    if (!fs.existsSync(p)) return "";
+    const body = fs.readFileSync(p, "utf-8");
+    return body.split("\n").filter(Boolean).slice(-lines).join("\n");
+  }
+
+  /**
+   * Count of files directly under input/ (excluding subdirs like archived/).
+   */
+  pendingInputCount() {
+    const dir = path.join(this._workspace.cwd, "input");
+    if (!fs.existsSync(dir)) return 0;
+    try {
+      return fs.readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isFile())
+        .length;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Regenerate wrapper scripts for all enabled jobs. Used by
+   * `engine.renameSession()` (Bug 3) — wrappers bake in absolute paths to
+   * the workspace, so a rename needs them re-rendered with the new paths.
+   *
+   * Returns `{ regenerated, disabled, failed }`:
+   *  - `regenerated`: ids of jobs whose wrappers were successfully re-rendered
+   *  - `disabled`: ids of jobs we skipped because they're disabled (no wrapper expected)
+   *  - `failed`: list of `{id, error}` for jobs whose render call threw
+   * Splitting "skipped" into disabled vs failed lets the CLI surface render
+   * failures (e.g. disk full) instead of silently swallowing them.
+   */
+  regenerateAllWrappers() {
+    const out = { regenerated: [], disabled: [], failed: [] };
+    for (const job of this.list()) {
+      if (!job.enabled) { out.disabled.push(job.id); continue; }
+      try {
+        this.renderWrapper(job);
+        out.regenerated.push(job.id);
+      } catch (e) {
+        out.failed.push({ id: job.id, error: e?.message || String(e) });
+      }
+    }
+    return out;
+  }
+
+  // --- helpers ---
+
+  _abs(rel) {
+    return path.join(this._workspace.cwd, rel);
+  }
+}
+
+/** POSIX shell-quote a string. */
+function shQuote(s) {
+  if (s === "") return "''";
+  return `'${String(s).replace(/'/g, `'\\''`)}'`;
+}

package/src/agent/session-state.js

@@ -10,9 +10,18 @@ import path from "node:path";
 export class SessionState {
   /**
    * @param {string} workspacePath - Session workspace directory
+   * @param {object} [opts]
+   * @param {string} [opts.statePath] - Override absolute path (used for sub-agent isolation, Bug 2)
    */
-  constructor(workspacePath) {
-    this._path = path.join(workspacePath, "session-state.json");
+  constructor(workspacePath, opts = {}) {
+    this._path = opts.statePath || path.join(workspacePath, "session-state.json");
+  }
+
+  /**
+   * Re-point at a new state file. Used by `engine.renameSession()` (Bug 3).
+   */
+  _setWorkspacePath(newWorkspacePath, opts = {}) {
+    this._path = opts.statePath || path.join(newWorkspacePath, "session-state.json");
   }
 
   /** Whether a session state file exists */

package/src/agent/task-manager.js

@@ -16,6 +16,11 @@ export class TaskManager {
     this._load();
   }
 
+  /** Re-point at a new tasks.json. Used by `engine.renameSession()` (Bug 3). */
+  _setWorkspacePath(newWorkspacePath) {
+    this._path = path.join(newWorkspacePath, "tasks.json");
+  }
+
   // --- Task CRUD ---
 
   /**