@zosmaai/pi-llm-wiki 0.9.1 → 0.9.3

package/extensions/llm-wiki/index.ts

@@ -2,11 +2,8 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { installGuardrails } from "./lib/guardrails.js";
-import {
-  MODEL_STATUS_KEY,
-  formatActiveModelLabel,
-  registerWikiModelCommand,
-} from "./lib/model-command.js";
+import { appendWikiStatus } from "./lib/inject.js";
+import { registerWikiModelCommand } from "./lib/model-command.js";
 import {
   buildSessionNotice,
   createReminderState,
@@ -22,7 +19,7 @@ import {
 } from "./lib/recall.js";
 import { registerWikiRetro } from "./lib/retro.js";
 import { registerBackgroundRuntime } from "./lib/runtime.js";
-import { noticesEnabled } from "./lib/task-config.js";
+import { loadTaskConfig, noticesEnabled, trajectoriesEnabled } from "./lib/task-config.js";
 import {
   registerWikiBootstrap,
   registerWikiCaptureSource,
@@ -36,6 +33,12 @@ import {
   registerWikiStatus,
   registerWikiWatch,
 } from "./lib/tools.js";
+import { registerWikiTrajectoriesCommand } from "./lib/trajectories-command.js";
+import {
+  registerWikiCaptureTrajectory,
+  registerWikiDistillSkills,
+  registerWikiRecallSkill,
+} from "./lib/trajectory.js";
 import {
   ensureVaultStructure,
   fmtDate,
@@ -44,11 +47,13 @@ import {
   resolveVaultPaths,
   writeJson,
 } from "./lib/utils.js";
+import { applySessionStartStatus } from "./lib/visible-status.js";
 
 /**
  * @zosmaai/pi-llm-wiki — LLM Wiki extension for Pi
  *
- * Registers 12 custom tools and installs guardrails:
+ * Registers 13 custom tools and installs guardrails (+3 agent-trajectory tools
+ * when `llm-wiki.trajectories` is enabled — opt-in, off by default, issue #80):
  * - wiki_recall (layered: personal + project vaults)
  * - wiki_retro (lightweight: single markdown file)
  * - wiki_capture_source (full 4-layer pipeline)
@@ -81,6 +86,23 @@ export default function (pi: ExtensionAPI) {
   registerWikiWatch(pi);
   registerWikiRecall(pi, runtime);
   registerWikiRetro(pi, runtime);
+  // Agent working-memory (issue #80): capture what the agent *did* (its
+  // tool-call trajectory), distill it into reusable skills, and recall past
+  // skills/cases. OPT-IN, default OFF — registered ONLY when enabled so the 3
+  // tools cost nothing in the system prompt for users who don't opt in.
+  //
+  // Gate on loadTaskConfig(process.cwd()) at factory time, NOT runtime.config:
+  // runtime.config is empty ({}) until ensureConfig runs in a later hook, so a
+  // runtime.config gate here would read as permanently off. Toggling the flag
+  // via /wiki-trajectories reloads the extension, re-running this gate.
+  const trajectoriesOn = trajectoriesEnabled(loadTaskConfig(process.cwd()));
+  if (trajectoriesOn) {
+    registerWikiCaptureTrajectory(pi);
+    registerWikiDistillSkills(pi);
+    registerWikiRecallSkill(pi);
+  }
+  // Activation surface for the above (always available so users can turn it on).
+  registerWikiTrajectoriesCommand(pi);
   // Model selection surface (issue #69): /wiki-model command to view/set the
   // background task model. The taskModel config field + resolveModel already
   // exist; this exposes them to the user (default stays the session model).
@@ -106,6 +128,10 @@ export default function (pi: ExtensionAPI) {
     try {
       const migration = migrateDoubledPersonalVault();
       if (migration && migration.moved.length > 0) {
+        // INTENTIONALLY NOT gated by `noticesEnabled` (issues #77, #84): this is
+        // a one-shot data-integrity recovery signal, not chat-noise. If the
+        // user has a broken doubled-dotdir layout we want them to see that it
+        // was fixed, even in quiet mode.
         ctx.ui.setStatus(
           "llm-wiki",
           `🧠 Personal wiki layout fixed: flattened ${migration.moved.length} entries out of ${migration.from} (see CHANGELOG)`,
@@ -147,17 +173,24 @@ export default function (pi: ExtensionAPI) {
       writeFileSync(join(vaultPaths.dotWiki, "WIKI_SCHEMA.md"), schema, "utf-8");
 
       needsTopicInference = true;
+      // INTENTIONALLY NOT gated by `noticesEnabled` (issues #77, #84): one-shot
+      // first-run setup signal. The user needs to know the wiki was just
+      // auto-created, regardless of quiet mode.
       ctx.ui.setStatus("llm-wiki", "🧠 Wiki created (inferring topic from first prompt…)");
       return;
     }
 
-    ctx.ui.setStatus("llm-wiki", "🧠 LLM Wiki (13 tools, observe + recall active)");
-
-    // Surface the active background task model (issue #69). Defaults to the
-    // session model when no taskModel is configured.
+    // Surface the "wiki active" badge and the active background task model
+    // (issue #69), both gated by `llm-wiki.notices` (issue #77, regression
+    // fixed in #83, helper extracted in #84). `ensureConfig` MUST run first so
+    // the gate sees the loaded project settings.
     runtime.ensureConfig(process.cwd());
-    const modelLabel = formatActiveModelLabel(runtime.config, (ctx.model as { id?: string })?.id);
-    ctx.ui.setStatus(MODEL_STATUS_KEY, `🧠 wiki model: ${modelLabel}`);
+    applySessionStartStatus({
+      ui: ctx.ui,
+      runtime,
+      trajectoriesOn,
+      sessionModelId: (ctx.model as { id?: string })?.id,
+    });
 
     // One-time, user-visible session notice announcing the full wiki loop
     // (issue #77). Without this, recall/observe/retro are invisible — they
@@ -241,7 +274,10 @@ Then call wiki_bootstrap with the inferred topic and mode to finalize the setup.
         // large vault never floods the system prompt with inline previews.
         // includePersonal=false here mirrors the auto-injection search scope.
         const linksOnly = shouldUseLinksFirst(vaultPageCount(paths, false), runtime.config);
-        const recallContext = formatRecallContext(results, { linksOnly });
+        const recallContext = formatRecallContext(results, {
+          linksOnly,
+          skillInlineMax: runtime.config?.recallSkillInlineMax,
+        });
         if (recallContext) {
           injectedContext += `\n\n${recallContext}`;
         }
@@ -260,8 +296,7 @@ Then call wiki_bootstrap with the inferred topic and mode to finalize the setup.
 
     // Always inject a visible wiki status footer, even when empty
     // This ensures the model knows the wiki is active and can use it
-    injectedContext +=
-      "\n\n<wiki_status>LLM Wiki active — use wiki_recall for deeper search, wiki_observe to record observations, wiki_retro to save insights.</wiki_status>";
+    injectedContext = appendWikiStatus(injectedContext);
 
     if (injectedContext === event.systemPrompt) return;
     return { systemPrompt: injectedContext };

package/extensions/llm-wiki/lib/inject.ts

@@ -0,0 +1,27 @@
+/**
+ * System-prompt context injection primitives (issue #87).
+ *
+ * The `before_agent_start` hook augments the chained system prompt with a
+ * visible wiki-status footer. This module isolates that append so it can be
+ * unit-tested for idempotency — a turn that aborts (network error / ESC) and is
+ * retried can carry the prior injection forward, and a naive append stacks the
+ * footer 2x, 3x, ...
+ */
+
+/** The always-injected wiki-status footer (sans surrounding whitespace). */
+export const WIKI_STATUS_BLOCK =
+  "<wiki_status>LLM Wiki active — use wiki_recall for deeper search, wiki_observe to record observations, wiki_retro to save insights.</wiki_status>";
+
+/**
+ * Append the wiki-status footer to a system prompt — idempotently (issue #87).
+ *
+ * Strips any already-present footer (with its leading blank line) before
+ * appending exactly one. This makes the injection safe across aborted/retried
+ * agent starts that carry the prior injection forward in the chained system
+ * prompt, so the footer never stacks (2x, 3x, ...).
+ * See test/inject-idempotent.test.ts.
+ */
+export function appendWikiStatus(systemPrompt: string): string {
+  const base = systemPrompt.split(`\n\n${WIKI_STATUS_BLOCK}`).join("");
+  return `${base}\n\n${WIKI_STATUS_BLOCK}`;
+}

package/extensions/llm-wiki/lib/metadata.ts

@@ -19,7 +19,16 @@ import {
  */
 
 export interface RegistryEntry {
-  type: "source" | "entity" | "concept" | "synthesis" | "analysis";
+  type:
+    | "source"
+    | "entity"
+    | "concept"
+    | "synthesis"
+    | "analysis"
+    | "requirement"
+    | "trajectory"
+    | "skill"
+    | "case";
   title: string;
   created: string;
   updated: string;
@@ -98,6 +107,30 @@ export function buildRegistry(paths: VaultPaths): Registry {
     }
   }
 
+  // Scan raw trajectory packets (agent working-memory). These are catalogued
+  // under the `trajectories/` namespace so distillation and recall can find
+  // them even before a canonical case/skill page has been written.
+  if (existsSync(paths.rawTrajectories)) {
+    for (const entry of readdirSync(paths.rawTrajectories)) {
+      const manifestPath = join(paths.rawTrajectories, entry, "manifest.json");
+      if (!existsSync(manifestPath)) continue;
+
+      const manifest = readJson<Record<string, unknown>>(manifestPath, {});
+      const id = String(manifest.id || entry);
+      const trajectoryPage = `trajectories/${id}`;
+
+      if (!pages[trajectoryPage]) {
+        pages[trajectoryPage] = {
+          type: "trajectory",
+          title: String(manifest.title || id),
+          created: String(manifest.captured || fmtDate()),
+          updated: String(manifest.captured || fmtDate()),
+          ...manifest,
+        };
+      }
+    }
+  }
+
   return {
     version: "1.0",
     last_updated: new Date().toISOString(),

package/extensions/llm-wiki/lib/recall.ts

@@ -33,7 +33,7 @@ export interface RecallResult {
   type: string;
   /** First N chars of page content for context */
   preview: string;
-  /** Relative path from wiki root */
+  /** Absolute filesystem path to the page (resolvable by the `read` tool). */
   path: string;
   /** Vault source label for dual-vault results */
   vaultLabel?: string;
@@ -743,24 +743,105 @@ function linkSnippet(preview: string): string {
   return oneLine.length > LINKS_SNIPPET_MAX ? `${oneLine.slice(0, LINKS_SNIPPET_MAX)}…` : oneLine;
 }
 
+/**
+ * Default cap on chars of a skill/case body inlined directly into a recall
+ * block. Overridable per-vault via `recallSkillInlineMax` (0 disables inlining).
+ * Mirrors `DEFAULT_RECALL_LINKS_THRESHOLD` — the sibling context-window lever.
+ */
+export const DEFAULT_RECALL_SKILL_INLINE_MAX = 1600;
+
+/**
+ * Skills/working-memory carve-out from links-first: short, high-value
+ * procedural pages (`skill`/`case`) are meant to be APPLIED immediately, so we
+ * inline their body directly rather than make the agent expand a link it often
+ * skips (adherence > context-economy for these page types). Returns null for
+ * non-skill pages or when the body can't be read.
+ */
+function isSkillOrCase(r: RecallResult): boolean {
+  return (
+    r.type === "skill" ||
+    r.type === "case" ||
+    r.id.startsWith("skills/") ||
+    r.id.startsWith("cases/")
+  );
+}
+
+/**
+ * Inlined body for a skill/case page, or null. `max <= 0` disables inlining and
+ * short-circuits BEFORE any filesystem access, so a vault that opts out keeps
+ * recall page-body-I/O-free (issue #68's cheap-recall invariant). Otherwise the
+ * read is bounded: it fires only for skill/case results (which exist only when
+ * the trajectories feature is on) and only the top-N ranked hits.
+ */
+function inlineSkillBody(r: RecallResult, max = DEFAULT_RECALL_SKILL_INLINE_MAX): string | null {
+  if (max <= 0) return null;
+  if (!isSkillOrCase(r)) return null;
+  if (!r.path || !existsSync(r.path)) return null;
+  // Normalize CRLF first so the LF-anchored frontmatter strip below works on
+  // Windows-authored / git-autocrlf'd vaults (otherwise the raw YAML leaks in).
+  let body = readFileSync(r.path, "utf-8").replace(/\r\n/g, "\n");
+  body = body.replace(/^---\n[\s\S]*?\n---\n/, "").trim(); // strip YAML frontmatter
+  if (!body) return null;
+  if (body.length > max) {
+    body = `${body.slice(0, max)}\n…(truncated — \`read\` the path above for the full page)`;
+  }
+  return body;
+}
+
+/**
+ * A backtick fence guaranteed longer than any backtick run inside `body`.
+ * Skill/case pages routinely embed their own fenced code blocks; CommonMark
+ * closes a fenced block only on a fence of length >= the opener, so opening
+ * with (longest inner run + 1, min 3) keeps an inlined body from terminating
+ * the wrapper early — and stays safe even when truncation cuts mid-fence.
+ */
+function codeFenceFor(body: string): string {
+  let longest = 0;
+  for (const run of body.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+  return "`".repeat(Math.max(3, longest + 1));
+}
+
+/** Indented, fence-safe lines wrapping an inlined skill/case body. */
+function inlineBlockLines(body: string, indent: string): string[] {
+  const fence = codeFenceFor(body);
+  return [
+    "",
+    `${indent}${fence}`,
+    ...body.split("\n").map((line) => `${indent}${line}`),
+    `${indent}${fence}`,
+  ];
+}
+
 /**
  * Format recall results as a compact system-prompt section.
  *
  * Two render modes (issue #68):
- * - Default / `linksOnly: false` — preview-inline (unchanged for small vaults).
+ * - Default / `linksOnly: false` — preview-inline. For ordinary pages this is
+ *   byte-for-byte the pre-fix small-vault rendering (no regression); the
+ *   resolvable read-path + new footer copy are confined to links-first, where
+ *   there is no inline content and the agent MUST resolve a link.
  * - `linksOnly: true` — stage-1 "links-first": a ranked list of links carrying
- *   id, title, type, score, and a single short snippet. The agent expands the
- *   links it wants on demand via `read` (stage 2). Used above the vault-size
- *   threshold to keep large vaults from flooding context.
+ *   id, title, type, score, and a single short snippet, each with a resolvable
+ *   `read <path>`. The agent expands the links it wants on demand (stage 2).
+ *   Used above the vault-size threshold to keep large vaults from flooding context.
+ *
+ * `skillInlineMax` (default `DEFAULT_RECALL_SKILL_INLINE_MAX`) caps how much of a
+ * skill/case body is inlined; 0 disables inlining (pure links-first for those too).
  */
 export function formatRecallContext(
   results: RecallResult[],
-  opts: { linksOnly?: boolean } = {},
+  opts: { linksOnly?: boolean; skillInlineMax?: number } = {},
 ): string {
   if (results.length === 0) return "";
 
+  const skillInlineMax = opts.skillInlineMax ?? DEFAULT_RECALL_SKILL_INLINE_MAX;
   const hasLayered = results.some((r) => r.vaultLabel);
   const label = hasLayered ? " (personal + project)" : "";
+  // Salience nudge: when a distilled skill/case matches, tell the agent to
+  // apply it BEFORE experimenting (the dominant cost is recall non-adherence).
+  const hasSkill = results.some(isSkillOrCase);
+  const skillNudge =
+    "⚠\ufe0f A distilled skill/case below matches this task — read and APPLY it BEFORE experimenting on your own.";
 
   if (opts.linksOnly) {
     const lines: string[] = [
@@ -770,6 +851,7 @@ export function formatRecallContext(
       "",
     ];
 
+    if (hasSkill) lines.splice(1, 0, "", skillNudge);
     results.forEach((r, i) => {
       const vaultTag = r.vaultLabel ? ` ${r.vaultLabel}` : "";
       const snippet = linkSnippet(r.preview);
@@ -777,11 +859,18 @@ export function formatRecallContext(
       lines.push(
         `${i + 1}. **[[${r.id}]]** — *${r.type}* — score ${r.score.toFixed(1)}${vaultTag} — ${r.title}${tail}`,
       );
+      // Surface a read-resolvable path so expansion is a single, first-try
+      // `read` (issue: wikilink ids aren't resolvable by the file read tool).
+      if (r.path) lines.push(`   ↳ \`read ${r.path}\``);
+      // Skills/case carve-out: inline the body so the agent doesn't have to
+      // (and often won't) expand the link before acting.
+      const inl = inlineSkillBody(r, skillInlineMax);
+      if (inl) lines.push(...inlineBlockLines(inl, "   "));
     });
 
     lines.push(
       "",
-      "Call `read` on the links you need to pull their full content." +
+      "Call `read` on the exact path shown under each link to pull its full content." +
         " Add new findings via wiki_ensure_page or wiki_retro.",
       "",
     );
@@ -796,10 +885,20 @@ export function formatRecallContext(
     "",
   ];
 
+  if (hasSkill) lines.splice(1, 0, "", skillNudge);
   for (const r of results) {
     const vaultTag = r.vaultLabel ? ` ${r.vaultLabel}` : "";
     lines.push(`- **[[${r.id}]]** — *${r.type}* — ${r.title}${vaultTag}`);
-    if (r.preview) {
+    // Skills/case carve-out: inline the body (adherence > context-economy). Only
+    // here does the default path deviate from the pre-fix small-vault render —
+    // and only when a skill/case matched (i.e. the trajectories feature is on),
+    // so ordinary pages stay byte-for-byte unchanged (#68 no-regression promise).
+    const inl = inlineSkillBody(r, skillInlineMax);
+    if (inl) {
+      // Resolvable path so a truncated inline body is one `read` away.
+      if (r.path) lines.push(`  ↳ \`read ${r.path}\``);
+      lines.push(...inlineBlockLines(inl, "  "));
+    } else if (r.preview) {
       // Truncate preview to one line
       const preview = r.preview.length > 120 ? `${r.preview.slice(0, 120)}…` : r.preview;
       lines.push(`  ${preview}`);

package/extensions/llm-wiki/lib/task-config.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 
@@ -70,6 +70,19 @@ export interface TaskConfig {
    */
   recallLinksThreshold?: number;
 
+  /**
+   * Max characters of a distilled `skill`/`case` body inlined directly into a
+   * recall block before truncation (recall-adherence fix). Skills/cases are
+   * meant to be APPLIED immediately, so links-first recall inlines their short
+   * body instead of a bare link the agent often skips. Set to 0 to DISABLE
+   * inlining entirely — skills/cases then fall back to the normal link/preview
+   * path (pure links-first), and no page body is read at format time. Only
+   * relevant when the trajectories feature is on (skill/case pages exist only
+   * then). Default 1600. Clamped to a non-negative integer. Mirrors the
+   * `recallLinksThreshold` knob — the other context-window lever for recall.
+   */
+  recallSkillInlineMax?: number;
+
   /**
    * Surface wiki activity in the UI (issue #77). When enabled (the default),
    * the status line reflects recall hits and the periodic observe/retro
@@ -79,6 +92,14 @@ export interface TaskConfig {
    * not want any chat-level wiki notices.
    */
   notices?: boolean;
+
+  /**
+   * Agent-trajectory working-memory (capture → distill → recall), issue #80.
+   * OPT-IN, default OFF: only an explicit `trajectories: true` enables it.
+   * When off, the trajectory tools are never registered (see index.ts), so
+   * they cost nothing in the system prompt for the ~95% who don't use them.
+   */
+  trajectories?: boolean;
 }
 
 export const TASK_DEFAULTS: TaskConfig = {};
@@ -91,6 +112,15 @@ export function noticesEnabled(config: TaskConfig | undefined): boolean {
   return config?.notices !== false;
 }
 
+/**
+ * Resolve whether agent-trajectory working-memory is enabled (issue #80).
+ * INVERSE polarity of `noticesEnabled`: defaults to `false`; only an explicit
+ * `trajectories: true` turns it on.
+ */
+export function trajectoriesEnabled(config: TaskConfig | undefined): boolean {
+  return config?.trajectories === true;
+}
+
 const SETTINGS_KEY = "llm-wiki";
 
 function readModelSpec(value: unknown): { provider: string; id: string } | undefined {
@@ -103,9 +133,8 @@ function readModelSpec(value: unknown): { provider: string; id: string } | undef
 }
 
 function readNamespacedConfig(path: string): Partial<TaskConfig> {
-  if (!existsSync(path)) return {};
   try {
-    const raw = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown>;
+    const raw = readSettingsObject(path);
     const nested = raw[SETTINGS_KEY];
     if (!nested || typeof nested !== "object") return {};
     const section = nested as Record<string, unknown>;
@@ -134,9 +163,18 @@ function readNamespacedConfig(path: string): Partial<TaskConfig> {
       out.recallLinksThreshold = Math.max(0, Math.floor(threshold));
     }
 
+    const inlineMax = section.recallSkillInlineMax;
+    if (typeof inlineMax === "number" && Number.isFinite(inlineMax)) {
+      out.recallSkillInlineMax = Math.max(0, Math.floor(inlineMax));
+    }
+
     if (typeof section.notices === "boolean") {
       out.notices = section.notices;
     }
+
+    if (typeof section.trajectories === "boolean") {
+      out.trajectories = section.trajectories;
+    }
     return out;
   } catch {
     return {};
@@ -160,6 +198,22 @@ export function parseModelRef(ref: string): { provider: string; id: string } | u
   return { provider, id };
 }
 
+/**
+ * Read a settings JSON file as a plain object, or `{}` when it is absent or
+ * corrupt. Reads directly (no `existsSync` pre-check) so there is no
+ * check-then-use race: a missing file throws ENOENT, which the catch treats
+ * the same as an empty file.
+ */
+function readSettingsObject(path: string): Record<string, unknown> {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed && typeof parsed === "object") return parsed as Record<string, unknown>;
+  } catch {
+    // Missing or corrupt settings file: start from an empty object.
+  }
+  return {};
+}
+
 /**
  * Persist (or clear) the wiki background `taskModel` in the PROJECT settings
  * file `<cwd>/.pi/settings.json` under the namespaced `llm-wiki` key (issue
@@ -173,16 +227,7 @@ export function persistTaskModel(
   model: { provider: string; id: string } | undefined,
 ): void {
   const settingsPath = join(cwd, ".pi", "settings.json");
-  let raw: Record<string, unknown> = {};
-  if (existsSync(settingsPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
-      if (parsed && typeof parsed === "object") raw = parsed as Record<string, unknown>;
-    } catch {
-      // Corrupt settings file: start from an empty object rather than throw.
-      raw = {};
-    }
-  }
+  const raw = readSettingsObject(settingsPath);
 
   const existing = raw[SETTINGS_KEY];
   const section: Record<string, unknown> =
@@ -200,6 +245,33 @@ export function persistTaskModel(
   writeFileSync(settingsPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
 
+/**
+ * Persist the agent-trajectory flag in the PROJECT settings file
+ * `<cwd>/.pi/settings.json` under the namespaced `llm-wiki` key (issue #80).
+ * Mirrors `persistTaskModel`: project settings win in `loadTaskConfig`, other
+ * keys are preserved. `true` writes `trajectories: true`; `false` removes the
+ * key (reverting to the default-off behavior).
+ */
+export function persistTrajectoriesEnabled(cwd: string, enabled: boolean): void {
+  const settingsPath = join(cwd, ".pi", "settings.json");
+  const raw = readSettingsObject(settingsPath);
+
+  const existing = raw[SETTINGS_KEY];
+  const section: Record<string, unknown> =
+    existing && typeof existing === "object" ? { ...(existing as Record<string, unknown>) } : {};
+
+  if (enabled) {
+    section.trajectories = true;
+  } else {
+    // biome-ignore lint/performance/noDelete: one-off settings rewrite, not a hot path; removing the key keeps the JSON clean (default is off)
+    delete section.trajectories;
+  }
+  raw[SETTINGS_KEY] = section;
+
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
+}
+
 export function loadTaskConfig(cwd: string): TaskConfig {
   let globalPath: string;
   try {