flavor-code 1.2.4 → 1.2.6

package/dist/{chunk-MRISY6KK.js → chunk-RYDCJHXW.js}

@@ -104,10 +104,12 @@ function isDestructiveTool(name) {
   return DESTRUCTIVE_TOOLS.has(name);
 }
 var PermissionEngine = class {
+  #lexicalWorkspace;
   #workspace;
   #mode;
   constructor(options) {
     const root = resolve(options.workspace);
+    this.#lexicalWorkspace = root;
     this.#workspace = existsSync(root) ? realpathSync.native(root) : root;
     this.#mode = canonicalMode(options.mode ?? "default");
   }
@@ -128,13 +130,13 @@ var PermissionEngine = class {
       return { decision: "deny", reason: `${request.tool} requires source and destination paths` };
     }
     for (const path of paths) {
-      const classification = classifyPath(this.#workspace, path);
+      const classification = classifyPath(this.#lexicalWorkspace, this.#workspace, path);
       if (classification.escape) return { decision: "deny", reason: classification.reason ?? "Path escapes the workspace" };
       if (request.agent === "subagent" && !classification.inside) {
         return { decision: "deny", reason: "Subagents are restricted to the workspace" };
       }
     }
-    const inside = paths.every((path) => classifyPath(this.#workspace, path).inside);
+    const inside = paths.every((path) => classifyPath(this.#lexicalWorkspace, this.#workspace, path).inside);
     if (this.#mode === "plan") {
       return READ_TOOLS.has(request.tool) ? { decision: "allow" } : { decision: "deny", reason: "Plan mode is read-only" };
     }
@@ -161,11 +163,11 @@ var PermissionEngine = class {
     const analysis = request.args === void 0 ? analyzeCommand(request.command ?? "") : analyzeArgumentCommand(request.command ?? "", request.args);
     if (request.agent === "subagent") {
       if (request.cwd === void 0) return { decision: "ask", reason: "Subagent shell commands require an explicit workspace cwd" };
-      const cwd = classifyPath(this.#workspace, request.cwd);
+      const cwd = classifyPath(this.#lexicalWorkspace, this.#workspace, request.cwd);
       if (cwd.escape || !cwd.inside) return { decision: "deny", reason: "Subagent shell cwd must remain in the workspace" };
       if (analysis.destructive) return { decision: "deny", reason: "Destructive commands are forbidden for subagents" };
       if (analysis.wrapped || analysis.opaque || !isRoutineCommand(analysis.command)) return { decision: "ask", reason: "Subagent shell command requires main-Agent approval" };
-      const argumentDecision = assessRoutineArguments(analysis.command, request.cwd, this.#workspace);
+      const argumentDecision = assessRoutineArguments(analysis.command, request.cwd, this.#lexicalWorkspace, this.#workspace);
       if (argumentDecision !== "allow") {
         return argumentDecision === "deny" ? { decision: "deny", reason: "Subagent command arguments escape the workspace" } : { decision: "ask", reason: "Ambiguous subagent command arguments require main-Agent approval" };
       }
@@ -177,12 +179,12 @@ var PermissionEngine = class {
     if (analysis.wrapped || analysis.opaque) return ask(this.#mode, "Shell wrapper requires approval");
     if (this.#mode === "bypassPermissions") return { decision: "allow" };
     if ((this.#mode === "acceptEdits" || this.#mode === "auto") && isRoutineCommand(analysis.command)) {
-      const cwd = request.cwd ?? this.#workspace;
-      const cwdClassification = classifyPath(this.#workspace, cwd);
+      const cwd = request.cwd ?? this.#lexicalWorkspace;
+      const cwdClassification = classifyPath(this.#lexicalWorkspace, this.#workspace, cwd);
       if (cwdClassification.escape || !cwdClassification.inside) {
         return { decision: "deny", reason: "Routine command cwd must remain in the workspace" };
       }
-      const argumentDecision = assessRoutineArguments(analysis.command, cwd, this.#workspace);
+      const argumentDecision = assessRoutineArguments(analysis.command, cwd, this.#lexicalWorkspace, this.#workspace);
       if (argumentDecision === "deny") return { decision: "deny", reason: "Routine command arguments escape the workspace" };
       if (argumentDecision === "ask") return ask(this.#mode, "Ambiguous routine command arguments require approval");
       return { decision: "allow" };
@@ -219,16 +221,16 @@ function analyzeArgumentCommand(executable, args) {
   }
   return { command, destructive: isForbiddenCommand(command), opaque: false, wrapped: false };
 }
-function classifyPath(workspace, input) {
-  const candidate = resolve(workspace, input);
-  const lexicalInside = isWithin(workspace, candidate);
+function classifyPath(lexicalWorkspace, physicalWorkspace, input) {
+  const candidate = resolve(lexicalWorkspace, input);
+  const lexicalInside = isWithin(lexicalWorkspace, candidate);
   const traversal = input.split(/[\\/]+/).includes("..");
-  const startsInWorkspace = pathStartsWith(workspace, input);
+  const startsInWorkspace = pathStartsWith(lexicalWorkspace, input);
   if ((!isAbsolute(input) || startsInWorkspace) && traversal && !lexicalInside) {
     return { inside: false, escape: true, reason: "Path traversal escapes the workspace" };
   }
   const physical = resolvePhysical(candidate);
-  const physicalInside = isWithin(workspace, physical);
+  const physicalInside = isWithin(physicalWorkspace, physical);
   if (lexicalInside && !physicalInside) return { inside: false, escape: true, reason: "Symlink escapes the workspace" };
   return { inside: physicalInside, escape: false };
 }
@@ -318,7 +320,7 @@ function isRoutineCommand(command) {
   if (command.executable === "go") return first === "test";
   return ["pytest", "vitest", "jest", "eslint", "tsc"].includes(command.executable);
 }
-function assessRoutineArguments(command, cwd, workspace) {
+function assessRoutineArguments(command, cwd, lexicalWorkspace, physicalWorkspace) {
   const args = routineArguments(command);
   if (args === void 0) return "ask";
   const pathOptions = /* @__PURE__ */ new Set([
@@ -343,7 +345,7 @@ function assessRoutineArguments(command, cwd, workspace) {
       const option2 = equals[1]?.toLowerCase() ?? "";
       const value = equals[2] ?? "";
       if (!pathOptions.has(option2)) return "ask";
-      const decision = assessArgumentPath(value, cwd, workspace);
+      const decision = assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       continue;
     }
@@ -351,14 +353,14 @@ function assessRoutineArguments(command, cwd, workspace) {
     if (option !== void 0 && pathOptions.has(option)) {
       const value = args[index + 1];
       if (value === void 0 || value.startsWith("-")) return "ask";
-      const decision = assessArgumentPath(value, cwd, workspace);
+      const decision = assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       index += 1;
       continue;
     }
     if (arg.startsWith("-")) continue;
     if (looksLikePath(arg)) {
-      const decision = assessArgumentPath(arg, cwd, workspace);
+      const decision = assessArgumentPath(arg, cwd, lexicalWorkspace, physicalWorkspace);
       if (decision !== "allow") return decision;
       continue;
     }
@@ -376,10 +378,10 @@ function routineArguments(command) {
   if (["pytest", "vitest", "jest", "eslint", "tsc"].includes(command.executable)) return command.args;
   return void 0;
 }
-function assessArgumentPath(value, cwd, workspace) {
+function assessArgumentPath(value, cwd, lexicalWorkspace, physicalWorkspace) {
   if (value.length === 0) return "ask";
   const resolved = resolve(cwd, value);
-  const classification = classifyPath(workspace, resolved);
+  const classification = classifyPath(lexicalWorkspace, physicalWorkspace, resolved);
   return classification.escape || !classification.inside ? "deny" : "allow";
 }
 function looksLikePath(value) {
@@ -2326,6 +2328,7 @@ var MVP_COMMANDS = [
   "memory",
   "remember",
   "forget",
+  "forget-cold",
   "checkpoint",
   "tree",
   "rewind",
@@ -2356,6 +2359,7 @@ var COMMAND_DESCRIPTIONS = {
   memory: "Show long-term project memory",
   remember: "Add a long-term memory",
   forget: "Remove matching long-term memories",
+  "forget-cold": "Remove all cold long-term memories and their files",
   checkpoint: "Create a workspace and context checkpoint",
   tree: "Show the session history tree",
   rewind: "Restore a prior session node",
@@ -2502,7 +2506,7 @@ var HELP = [
   "/permissions <default|acceptEdits|plan|bypassPermissions|auto|bubble>",
   "/login                                  authenticate via OAuth PKCE",
   "/init  /config  /skills  /plugins  /hooks  /tasks",
-  "/memory  /remember [type] <text>  /forget <text-or-id>  /finish",
+  "/memory  /remember [type] <text>  /forget <text-or-id>  /forget-cold  /finish",
   "/checkpoint [label]  /tree  /rewind <node>  /unrevert  /fork <node>",
   "/compact  /clear  /help  /exit",
   "/loop <goal>                            run a verified autonomous loop",
@@ -2698,6 +2702,8 @@ var FlavorSession = class {
       this.#notice(await this.#services.remember(command.type, command.text));
     } else if (command.name === "forget") {
       this.#notice(await this.#services.forget(command.query));
+    } else if (command.name === "forget-cold") {
+      this.#notice(await this.#services.forgetCold());
     } else if (command.name === "finish") {
       this.#notice(await this.#services.finishTask());
     } else if (command.name === "checkpoint") {
@@ -5042,7 +5048,8 @@ var ToolRuntime = class {
         } catch {
         }
       }
-      if (pre.decision === "ask" || permission.decision === "ask") {
+      const sessionAllowed = this.#alwaysAllowed.has(getToolCategory(tool.name));
+      if (!sessionAllowed && (pre.decision === "ask" || permission.decision === "ask")) {
         const reason = [pre.reason, permission.reason].filter((value) => value !== void 0).join("\n") || "Approval required";
         const requestDecision = await this.#hooks.emit({
           version: 1,
@@ -5067,8 +5074,7 @@ var ToolRuntime = class {
           throw signal.reason;
         } else {
           const category = getToolCategory(tool.name);
-          if (this.#alwaysAllowed.has(category)) {
-          } else if (this.#approve === void 0) {
+          if (this.#approve === void 0) {
             return this.#fail(tool.name, input, context.agent, "permission_denied", reason);
           } else {
             const decision = await this.#approve({ ...request, reason }, signal);
@@ -9220,9 +9226,11 @@ var SkillRegistry = class {
     for (const configuredRoot of roots) {
       const root = resolve13(configuredRoot);
       let entries;
+      let physicalRoot = root;
       try {
         const rootInfo = await lstat6(root);
         if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory()) throw new Error("Skill root must be a real directory");
+        physicalRoot = await realpath4(root);
         entries = await readdir5(root, { withFileTypes: true });
       } catch (error) {
         if (isMissing2(error)) continue;
@@ -9235,12 +9243,12 @@ var SkillRegistry = class {
         try {
           if (entry2.isSymbolicLink()) throw new Error("Symlinked skill directories are not allowed");
           if (!entry2.isDirectory()) continue;
-          const physicalRoot = await realpath4(skillRoot);
-          if (!isWithin3(root, physicalRoot)) throw new Error("Skill directory escapes its registry root");
+          const physicalSkillRoot = await realpath4(skillRoot);
+          if (!isWithin3(physicalRoot, physicalSkillRoot)) throw new Error("Skill directory escapes its registry root");
           const skillFile = resolve13(skillRoot, "SKILL.md");
           const parsed = await readFrontmatterFile(
             skillFile,
-            physicalRoot,
+            physicalSkillRoot,
             this.#options.maxMetadataBytes,
             this.#options.openFile
           );
@@ -9251,7 +9259,7 @@ var SkillRegistry = class {
               name: parsed.name,
               description: parsed.description,
               source,
-              root: physicalRoot,
+              root: physicalSkillRoot,
               disableModelInvocation: parsed.disableModelInvocation
             }),
             skillFile
@@ -10747,6 +10755,7 @@ function createEditTool(workspace, options = {}) {
     paths: (input) => [guard.lexical(input.path)],
     execute: async (input, signal) => {
       abortIfNeeded(signal);
+      const displayPath = guard.lexical(input.path);
       const path = await guard.existing(input.path);
       const contents = await readText(path);
       const hasCRLF = contents.includes("\r\n");
@@ -10762,11 +10771,11 @@ function createEditTool(workspace, options = {}) {
       }
       const updatedLF = contentsLF.slice(0, first) + newTextLF + contentsLF.slice(first + oldTextLF.length);
       const updated = hasCRLF ? updatedLF.replace(/\n/g, "\r\n") : updatedLF;
-      await options.beforeCommit?.({ path, before: contents, after: updated, kind: "update" }, signal);
+      await options.beforeCommit?.({ path: displayPath, before: contents, after: updated, kind: "update" }, signal);
       await atomicWrite(path, updated, signal);
       return withToolPresentation(
-        { path, replacements: 1 },
-        buildFileChangePresentation(path, contents, updated, "update")
+        { path: displayPath, replacements: 1 },
+        buildFileChangePresentation(displayPath, contents, updated, "update")
       );
     }
   };
@@ -12830,7 +12839,7 @@ ${total}`;
 
 // src/memory/store.ts
 import { createHash as createHash7 } from "crypto";
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile14, rm as rm7 } from "fs/promises";
 import { resolve as resolve19, join as join15, relative as relative16, sep as sep15 } from "path";
 
 // src/memory/similarity.ts
@@ -13057,6 +13066,50 @@ var MemoryStore = class {
     }) }));
     return removed;
   }
+  /**
+   * Removes every cold memory entry and its backing content. A task file is
+   * deleted only when all of its entries were cold; otherwise only the cold
+   * entries are dropped from the shared file.
+   */
+  async forgetCold(now = /* @__PURE__ */ new Date()) {
+    let removedReferences = [];
+    await this.#updateIndex((index) => {
+      removedReferences = index.references.filter((reference) => classifyMemoryHeat(reference, now) === "cold");
+      const removedIds = new Set(removedReferences.map((reference) => reference.id));
+      return { ...index, references: index.references.filter((reference) => !removedIds.has(reference.id)) };
+    });
+    if (removedReferences.length === 0) return { removed: 0, filesRemoved: 0 };
+    const byPath = /* @__PURE__ */ new Map();
+    for (const reference of removedReferences) {
+      const group = byPath.get(reference.contentPath) ?? [];
+      group.push(reference);
+      byPath.set(reference.contentPath, group);
+    }
+    let filesRemoved = 0;
+    for (const [contentPath, references] of byPath) {
+      const removedIds = new Set(references.map((reference) => reference.id));
+      const path = this.#resolveContentPath(contentPath);
+      const recovered = await readRecoverableFile(path, decodeTask);
+      if (recovered === void 0) continue;
+      const remaining = recovered.value.items.filter((item) => !removedIds.has(item.id));
+      if (remaining.length === 0) {
+        await rm7(path, { force: true });
+        await rm7(`${path}.bak`, { force: true });
+        filesRemoved += 1;
+      } else {
+        await updateProtectedFile({
+          path,
+          decode: decodeTask,
+          encode: encodeTask,
+          update: (current) => {
+            const document = current ?? recovered.value;
+            return { ...document, items: document.items.filter((item) => !removedIds.has(item.id)) };
+          }
+        });
+      }
+    }
+    return { removed: removedReferences.length, filesRemoved };
+  }
   async recall(query, options) {
     assertTaskId(options.taskId);
     const now = options.now ?? /* @__PURE__ */ new Date();
@@ -14957,6 +15010,12 @@ ${renderMemoryDocument(entries)}`;
         if (removed > 0) await refreshMemoryState();
         return removed === 0 ? "No matching memory found." : `Forgot ${removed} memory ${removed === 1 ? "entry" : "entries"}.`;
       },
+      forgetCold: async () => {
+        if (memoryStore === void 0) return "Long-term memory is disabled.";
+        const { removed, filesRemoved } = await memoryStore.forgetCold();
+        if (removed > 0) await refreshMemoryState();
+        return removed === 0 ? "No cold long-term memories to remove." : `Forgot ${removed} cold memory ${removed === 1 ? "entry" : "entries"} and removed ${filesRemoved} task ${filesRemoved === 1 ? "file" : "files"}.`;
+      },
       finishTask: () => finalizeMemoryTask(true),
       pluginCommands: () => [...pluginCommands.keys()].sort(),
       runPluginCommand: async (name, args, signal) => {

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-L5A2NDMT.js";
+} from "./chunk-CXSXBPD6.js";
 import {
   staticTaskLines
 } from "./chunk-KKIBYDJI.js";
@@ -20,7 +20,7 @@ import {
   message,
   packageVersion,
   redactErrorText
-} from "./chunk-MRISY6KK.js";
+} from "./chunk-RYDCJHXW.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -771,7 +771,7 @@ function createProgram() {
     const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
       import("./claude-ink-WPWPEL5A.js"),
       import("react"),
-      import("./app-N3655H2E.js")
+      import("./app-WRTEXGA6.js")
     ]);
     const instance = await render(createElement(
       AlternateScreen,