@harperfast/agent 0.11.5 → 0.12.0

package/dist/agent.js

@@ -2,7 +2,7 @@
 
 // agent.ts
 import "dotenv/config";
-import { Agent as Agent3, run as run2 } from "@openai/agents";
+import { Agent as Agent2, run as run2 } from "@openai/agents";
 import chalk13 from "chalk";
 
 // lifecycle/cleanUpAndSayBye.ts
@@ -302,7 +302,6 @@ function harperResponse(text) {
 import process2 from "process";
 
 // lifecycle/trackedState.ts
-import "@openai/agents";
 var trackedState = {
   agent: null,
   cwd: process.cwd(),
@@ -315,7 +314,8 @@ var trackedState = {
   sessionPath: null,
   useFlexTier: false,
   disableSpinner: false,
-  enableInterruptions: true
+  enableInterruptions: true,
+  session: null
 };
 
 // utils/shell/spinner.ts
@@ -469,6 +469,9 @@ function normalizeOllamaBaseUrl(baseUrl) {
   return urlObj.toString().replace(/\/$/, "");
 }
 
+// lifecycle/parseArgs.ts
+import path from "path";
+
 // utils/shell/cli.ts
 import chalk3 from "chalk";
 
@@ -628,6 +631,10 @@ function parseArgs() {
   if (!trackedState.sessionPath && process.env.HARPER_AGENT_SESSION) {
     trackedState.sessionPath = process.env.HARPER_AGENT_SESSION;
   }
+  const sp = trackedState.sessionPath;
+  if (sp) {
+    trackedState.sessionPath = sp && !sp.startsWith("~") && !path.isAbsolute(sp) ? path.resolve(process.cwd(), sp) : sp;
+  }
   if (!trackedState.useFlexTier && isTrue(process.env.HARPER_AGENT_FLEX_TIER)) {
     trackedState.useFlexTier = true;
   }
@@ -696,9 +703,9 @@ function sayHi() {
 }
 
 // tools/files/applyPatchTool.ts
-import { tool } from "@openai/agents";
+import { tool as tool2 } from "@openai/agents";
 import chalk7 from "chalk";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // utils/files/printDiff.ts
 import chalk5 from "chalk";
@@ -738,11 +745,68 @@ function getEnv(newKey, oldKey) {
   return void 0;
 }
 
+// tools/harper/getHarperSkillTool.ts
+import { tool } from "@openai/agents";
+import { readdirSync, readFileSync as readFileSync3 } from "fs";
+import { createRequire } from "module";
+import { dirname, join as join6 } from "path";
+import { z } from "zod";
+var createHarper = dirname(createRequire(import.meta.url).resolve("create-harper"));
+var agentsMarkdown = join6(
+  createHarper,
+  "AGENTS.md"
+);
+var skillsDir = join6(
+  createHarper,
+  "template-vanilla",
+  "skills"
+);
+var skillLinkRegex = /\[[^\]]+]\(skills\/([^)]+)\.md\)/g;
+var skills = getSkills();
+var ToolParameters = z.object({
+  skill: z.enum(skills.length > 0 ? skills : ["none"]).describe(
+    "The name of the skill to retrieve."
+  )
+});
+var getHarperSkillTool = tool({
+  name: "getHarperSkill",
+  description: getSkillsDescription(),
+  parameters: ToolParameters,
+  execute
+});
+function getSkillsDescription() {
+  try {
+    return readFileSync3(agentsMarkdown, "utf8").replace("This repository contains", "This tool describes").replace(skillLinkRegex, "$1");
+  } catch {
+    return "Returns the contents of a Harper skill markdown file. Skills provide guidance on developing Harper applications.";
+  }
+}
+function getSkills() {
+  try {
+    return readdirSync(skillsDir).filter((file) => file.endsWith(".md")).map((file) => file.replace(".md", ""));
+  } catch {
+    return [];
+  }
+}
+async function execute({ skill }) {
+  if (skill === "none") {
+    return "No skills found.";
+  }
+  try {
+    const filePath = join6(skillsDir, `${skill}.md`);
+    const content = readFileSync3(filePath, "utf8");
+    trackedState.session?.addSkillRead?.(skill);
+    return content;
+  } catch (error) {
+    return `Error reading Harper skill "${skill}": ${error}`;
+  }
+}
+
 // tools/files/workspaceEditor.ts
 import { applyDiff } from "@openai/agents";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { mkdir, rm, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 
 // utils/files/normalizeDiff.ts
 function normalizeDiff(diff) {
@@ -759,17 +823,17 @@ function normalizeDiff(diff) {
 }
 
 // utils/files/paths.ts
-import path2 from "path";
+import path3 from "path";
 
 // utils/files/aiignore.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import path from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import path2 from "path";
 var ignorePatterns = [];
 function loadAiIgnore() {
-  const ignorePath = path.join(trackedState.cwd, ".aiignore");
+  const ignorePath = path2.join(trackedState.cwd, ".aiignore");
   if (existsSync4(ignorePath)) {
     try {
-      const content = readFileSync3(ignorePath, "utf8");
+      const content = readFileSync4(ignorePath, "utf8");
       ignorePatterns = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => pattern.endsWith("/") || pattern.endsWith("\\") ? pattern.slice(0, -1) : pattern);
     } catch (error) {
       console.error(`Error reading .aiignore: ${error}`);
@@ -780,39 +844,39 @@ function loadAiIgnore() {
   }
 }
 function isIgnored(filePath) {
-  const directParts = path.normalize(filePath).split(path.sep);
+  const directParts = path2.normalize(filePath).split(path2.sep);
   if (directParts.includes(".aiignore")) {
     return true;
   }
-  const absolutePath = path.resolve(trackedState.cwd, filePath);
-  const relativePath = path.relative(trackedState.cwd, absolutePath);
-  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+  const absolutePath = path2.resolve(trackedState.cwd, filePath);
+  const relativePath = path2.relative(trackedState.cwd, absolutePath);
+  if (relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
     return false;
   }
-  const normalizedPath = path.normalize(relativePath);
-  const parts = normalizedPath.split(path.sep);
+  const normalizedPath2 = path2.normalize(relativePath);
+  const parts = normalizedPath2.split(path2.sep);
   loadAiIgnore();
   if (ignorePatterns.length === 0) {
     return false;
   }
   return ignorePatterns.some((pattern) => {
     if (pattern.startsWith("/")) {
-      const normalizedPattern = path.normalize(pattern.substring(1));
-      return normalizedPath === normalizedPattern || normalizedPath.startsWith(normalizedPattern + path.sep);
+      const normalizedPattern = path2.normalize(pattern.substring(1));
+      return normalizedPath2 === normalizedPattern || normalizedPath2.startsWith(normalizedPattern + path2.sep);
     }
     return parts.some((part, index) => {
-      const subPath = parts.slice(index).join(path.sep);
-      const normalizedPattern = path.normalize(pattern);
-      return subPath === normalizedPattern || subPath.startsWith(normalizedPattern + path.sep);
+      const subPath = parts.slice(index).join(path2.sep);
+      const normalizedPattern = path2.normalize(pattern);
+      return subPath === normalizedPattern || subPath.startsWith(normalizedPattern + path2.sep);
     });
   });
 }
 
 // utils/files/paths.ts
 function resolvePath(root, relativePath) {
-  const resolved = path2.resolve(root, relativePath);
-  const relative = path2.relative(root, resolved);
-  if (relative.startsWith("..") || path2.isAbsolute(relative)) {
+  const resolved = path3.resolve(root, relativePath);
+  const relative = path3.relative(root, resolved);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
     throw new Error(`Operation outside workspace: ${relativePath}`);
   }
   if (isIgnored(resolved)) {
@@ -830,7 +894,7 @@ var WorkspaceEditor = class {
   async createFile(operation) {
     try {
       const targetPath = resolvePath(this.root(), operation.path);
-      await mkdir(path3.dirname(targetPath), { recursive: true });
+      await mkdir(path4.dirname(targetPath), { recursive: true });
       const normalizedDiff = normalizeDiff(operation.diff);
       const content = applyDiff("", normalizedDiff, "create");
       await writeFile(targetPath, content, "utf8");
@@ -845,7 +909,7 @@ var WorkspaceEditor = class {
       if (!existsSync5(targetPath)) {
         return { status: "failed", output: "Error: file not found at path " + targetPath };
       }
-      const original = readFileSync4(targetPath, "utf8");
+      const original = readFileSync5(targetPath, "utf8");
       const normalizedDiff = normalizeDiff(operation.diff);
       const patched = applyDiff(original, normalizedDiff);
       await writeFile(targetPath, patched, "utf8");
@@ -869,48 +933,96 @@ var WorkspaceEditor = class {
 };
 
 // tools/files/applyPatchTool.ts
-var ApplyPatchParameters = z.object({
-  type: z.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
-  path: z.string().describe("The path to the file to operate on."),
-  diff: z.string().optional().default("").describe(
+var ApplyPatchParameters = z2.object({
+  type: z2.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
+  path: z2.string().describe("The path to the file to operate on."),
+  diff: z2.string().optional().default("").describe(
     'The diff to apply. For create_file, every line must start with "+". For update_file, use a headerless unified diff format (start sections with "@@", and use "+", "-", or " " for lines). Do not include markers like "*** Begin Patch" or "*** Add File:".'
   )
 });
+function normalizedPath(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\/?/, "");
+}
+async function getSkillsRead() {
+  try {
+    const s = trackedState.session;
+    const arr = await Promise.resolve(s?.getSkillsRead?.());
+    return Array.isArray(arr) ? arr : [];
+  } catch {
+    return [];
+  }
+}
+function pickExistingSkill(candidates) {
+  for (const c of candidates) {
+    if (skills.includes(c)) {
+      return c;
+    }
+  }
+  return null;
+}
+async function requiredSkillForOperation(path8, type) {
+  if (type === "delete_file") {
+    return null;
+  }
+  const p = normalizedPath(path8);
+  const read = await getSkillsRead();
+  if (p.includes("/resources/") || p.startsWith("resources/")) {
+    if (!read.includes("custom-resources") && !read.includes("extending-tables")) {
+      return pickExistingSkill(["custom-resources", "extending-tables"]);
+    }
+  }
+  if (p.includes("/schemas/") || p.startsWith("schemas/") || p.includes("/schema/") || p.startsWith("schema/")) {
+    if (!read.includes("adding-tables-with-schemas")) {
+      return pickExistingSkill(["adding-tables-with-schemas"]);
+    }
+  }
+  return null;
+}
+var editor = new WorkspaceEditor(() => trackedState.cwd);
+async function needsApproval(runContext, operation, callId) {
+  try {
+    const needed = await requiredSkillForOperation(operation.path, operation.type);
+    if (needed) {
+      return false;
+    }
+    if (callId && runContext.isToolApproved({ toolName: "apply_patch", callId })) {
+      return false;
+    }
+    const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") === "1";
+    spinner.stop();
+    if (autoApproved) {
+      console.log(`
+${chalk7.bold.bgGreen.black(" Apply patch (auto-approved): ")}`);
+    } else {
+      console.log(`
+${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
+    }
+    console.log(`${chalk7.bold(operation.type)}: ${operation.path}`);
+    if (operation.diff) {
+      printDiff(operation.diff);
+    }
+    if (autoApproved) {
+      spinner.start();
+    }
+    return !autoApproved;
+  } catch (err) {
+    console.error("apply_patch approval step failed:", err);
+    return false;
+  }
+}
 function createApplyPatchTool() {
-  const editor = new WorkspaceEditor(() => trackedState.cwd);
-  return tool({
+  return tool2({
     name: "apply_patch",
     description: "Applies a patch (create, update, or delete a file) to the workspace.",
     parameters: ApplyPatchParameters,
-    needsApproval: async (runContext, operation, callId) => {
-      try {
-        if (callId && runContext.isToolApproved({ toolName: "apply_patch", callId })) {
-          return false;
-        }
-        const autoApproved = getEnv("HARPER_AGENT_AUTO_APPROVE_PATCHES", "APPLY_PATCH_AUTO_APPROVE") === "1";
-        spinner.stop();
-        if (autoApproved) {
-          console.log(`
-${chalk7.bold.bgGreen.black(" Apply patch (auto-approved): ")}`);
-        } else {
-          console.log(`
-${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
-        }
-        console.log(`${chalk7.bold(operation.type)}: ${operation.path}`);
-        if (operation.diff) {
-          printDiff(operation.diff);
-        }
-        if (autoApproved) {
-          spinner.start();
-        }
-        return !autoApproved;
-      } catch (err) {
-        console.error("apply_patch approval step failed:", err);
-        return false;
-      }
-    },
+    needsApproval,
     execute: async (operation) => {
       try {
+        const needed = await requiredSkillForOperation(operation.path, operation.type);
+        if (needed) {
+          const content = await execute({ skill: needed });
+          return { status: "completed", output: content };
+        }
         switch (operation.type) {
           case "create_file":
             if (!operation.diff) {
@@ -936,15 +1048,15 @@ ${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
 }
 
 // tools/files/changeCwdTool.ts
-import { tool as tool2 } from "@openai/agents";
+import { tool as tool3 } from "@openai/agents";
 import { statSync } from "fs";
-import { z as z2 } from "zod";
-var ToolParameters = z2.object({
-  path: z2.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
+import { z as z3 } from "zod";
+var ToolParameters2 = z3.object({
+  path: z3.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
 });
-async function execute({ path: path7 }) {
+async function execute2({ path: path8 }) {
   try {
-    const target = resolvePath(trackedState.cwd, path7);
+    const target = resolvePath(trackedState.cwd, path8);
     const stat = statSync(target);
     if (!stat.isDirectory()) {
       console.log(`Path is not a directory: ${target}`);
@@ -958,7 +1070,7 @@ async function execute({ path: path7 }) {
       if (trackedState.agent) {
         trackedState.agent.instructions = agentsMDContents;
       }
-      console.log("Detected AGENTS.md, reading its contents for the AI.");
+      console.log("Detected AGENTS.md, reading its contents.");
       return `Switched current working directory to ${trackedState.cwd}, with a AGENTS.md file containing:
 ${agentsMDContents}
 I strongly suggest you use these newfound skills!`;
@@ -969,27 +1081,27 @@ I strongly suggest you use these newfound skills!`;
     return `Failed to change directory: ${err.message}`;
   }
 }
-var changeCwdTool = tool2({
+var changeCwdTool = tool3({
   name: "changeCwd",
   description: "Changes the current working directory for subsequent tools. Accepts absolute or relative paths.",
-  parameters: ToolParameters,
-  execute
+  parameters: ToolParameters2,
+  execute: execute2
 });
 
 // tools/files/egrepTool.ts
-import { tool as tool3 } from "@openai/agents";
+import { tool as tool4 } from "@openai/agents";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var execFileAsync = promisify(execFile);
-var ToolParameters2 = z3.object({
-  path: z3.string().describe("The path to start the search from."),
-  pattern: z3.string().describe("The pattern to search")
+var ToolParameters3 = z4.object({
+  path: z4.string().describe("The path to start the search from."),
+  pattern: z4.string().describe("The pattern to search")
 });
-var egrepTool = tool3({
+var egrepTool = tool4({
   name: "egrep",
   description: "File pattern searcher.",
-  parameters: ToolParameters2,
+  parameters: ToolParameters3,
   async execute({ path: searchPath, pattern }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1015,21 +1127,21 @@ var egrepTool = tool3({
 });
 
 // tools/files/findTool.ts
-import { tool as tool4 } from "@openai/agents";
+import { tool as tool5 } from "@openai/agents";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
-var ToolParameters3 = z4.object({
-  path: z4.string().describe("The path to start the search from."),
-  iname: z4.string().describe(
+var ToolParameters4 = z5.object({
+  path: z5.string().describe("The path to start the search from."),
+  iname: z5.string().describe(
     "Case insensitive, true if the last component of the pathname being examined matches pattern.  Special shell pattern matching characters (\u201C[\u201D, \u201C]\u201D, \u201C*\u201D, and \u201C?\u201D) may be used as part of pattern.  These characters may be matched explicitly by escaping them with a backslash (\u201C\\\u201D)."
   )
 });
-var findTool = tool4({
+var findTool = tool5({
   name: "find",
   description: "Walk a file hierarchy.",
-  parameters: ToolParameters3,
+  parameters: ToolParameters4,
   async execute({ path: searchPath, iname }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1042,22 +1154,22 @@ var findTool = tool4({
 });
 
 // tools/files/readDirTool.ts
-import { tool as tool5 } from "@openai/agents";
+import { tool as tool6 } from "@openai/agents";
 import { readdir } from "fs/promises";
-import path4 from "path";
-import { z as z5 } from "zod";
-var ToolParameters4 = z5.object({
-  directoryName: z5.string().describe("The name of the directory to read.")
+import path5 from "path";
+import { z as z6 } from "zod";
+var ToolParameters5 = z6.object({
+  directoryName: z6.string().describe("The name of the directory to read.")
 });
-var readDirTool = tool5({
+var readDirTool = tool6({
   name: "readDir",
   description: "Lists the files in a directory.",
-  parameters: ToolParameters4,
+  parameters: ToolParameters5,
   async execute({ directoryName }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, directoryName);
       const files = await readdir(resolvedPath, "utf8");
-      return files.filter((file) => !isIgnored(path4.join(resolvedPath, file)));
+      return files.filter((file) => !isIgnored(path5.join(resolvedPath, file)));
     } catch (error) {
       return `Error reading directory: ${error}`;
     }
@@ -1065,18 +1177,23 @@ var readDirTool = tool5({
 });
 
 // tools/files/readFileTool.ts
-import { tool as tool6 } from "@openai/agents";
+import { tool as tool7 } from "@openai/agents";
 import { readFile } from "fs/promises";
-import { z as z6 } from "zod";
-var ToolParameters5 = z6.object({
-  fileName: z6.string().describe("The name of the file to read.")
+import { z as z7 } from "zod";
+var ToolParameters6 = z7.object({
+  fileName: z7.string().describe("The name of the file to read.")
 });
-var readFileTool = tool6({
+var readFileTool = tool7({
   name: "readFile",
   description: "Reads the contents of a specified file.",
-  parameters: ToolParameters5,
+  parameters: ToolParameters6,
   async execute({ fileName }) {
     try {
+      const normalized = String(fileName).replace(/\\/g, "/");
+      const m = normalized.match(/(?:^|\/)skills\/([A-Za-z0-9_-]+)\.md(?:$|[?#])/);
+      if (m && m[1]) {
+        trackedState.session?.addSkillRead?.(m[1]);
+      }
       const resolvedPath = resolvePath(trackedState.cwd, fileName);
       return readFile(resolvedPath, "utf8");
     } catch (error) {
@@ -1086,28 +1203,28 @@ var readFileTool = tool6({
 });
 
 // tools/general/codeInterpreterTool.ts
-import { tool as tool7 } from "@openai/agents";
+import { tool as tool8 } from "@openai/agents";
 import chalk8 from "chalk";
 import { exec } from "child_process";
 import { unlink, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { promisify as promisify3 } from "util";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var execAsync = promisify3(exec);
-var CodeInterpreterParameters = z7.object({
-  code: z7.string().describe("The code to execute."),
-  language: z7.enum(["python", "javascript"]).optional().default("python").describe(
+var CodeInterpreterParameters = z8.object({
+  code: z8.string().describe("The code to execute."),
+  language: z8.enum(["python", "javascript"]).optional().default("python").describe(
     "The programming language of the code."
   )
 });
-var codeInterpreterTool = tool7({
+var codeInterpreterTool = tool8({
   name: "code_interpreter",
   description: "Executes Python or JavaScript code in a local environment. This is useful for data analysis, complex calculations, and more. All code will be executed in the current workspace.",
   parameters: CodeInterpreterParameters,
-  execute: execute2,
-  needsApproval
+  execute: execute3,
+  needsApproval: needsApproval2
 });
-async function needsApproval(runContext, { code, language }, callId) {
+async function needsApproval2(runContext, { code, language }, callId) {
   if (callId && runContext.isToolApproved({ toolName: "code_interpreter", callId })) {
     return false;
   }
@@ -1126,10 +1243,10 @@ ${chalk8.bold.bgYellow.black(` Code interpreter (${language}) approval required:
   }
   return !autoApproved;
 }
-async function execute2({ code, language }) {
+async function execute3({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
   const interpreter = language === "javascript" ? "node" : "python3";
-  const tempFile = path5.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
+  const tempFile = path6.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
   try {
     await writeFile2(tempFile, code, "utf8");
     const { stdout, stderr } = await execAsync(`${interpreter} ${tempFile}`);
@@ -1148,16 +1265,16 @@ STDERR: ${error.stderr || ""}`;
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-import { tool as tool8 } from "@openai/agents";
-import { z as z8 } from "zod";
+import { tool as tool9 } from "@openai/agents";
+import { z as z9 } from "zod";
 
 // utils/files/updateEnv.ts
 import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function updateEnv(key, value) {
   process.env[key] = value;
-  const envPath = join6(trackedState.cwd, ".env");
+  const envPath = join7(trackedState.cwd, ".env");
   let envContent = "";
   if (existsSync6(envPath)) {
     envContent = await readFile2(envPath, "utf8");
@@ -1176,10 +1293,10 @@ async function updateEnv(key, value) {
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-var SetInterpreterAutoApproveParameters = z8.object({
-  autoApprove: z8.boolean()
+var SetInterpreterAutoApproveParameters = z9.object({
+  autoApprove: z9.boolean()
 });
-var setInterpreterAutoApproveTool = tool8({
+var setInterpreterAutoApproveTool = tool9({
   name: "setInterpreterAutoApproveTool",
   description: "Enable or disable automatic approval for code interpreter by setting HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER=1 or 0 in .env and current process.",
   parameters: SetInterpreterAutoApproveParameters,
@@ -1202,12 +1319,12 @@ var setInterpreterAutoApproveTool = tool8({
 });
 
 // tools/general/setPatchAutoApproveTool.ts
-import { tool as tool9 } from "@openai/agents";
-import { z as z9 } from "zod";
-var SetPatchAutoApproveParameters = z9.object({
-  autoApprove: z9.boolean()
+import { tool as tool10 } from "@openai/agents";
+import { z as z10 } from "zod";
+var SetPatchAutoApproveParameters = z10.object({
+  autoApprove: z10.boolean()
 });
-var setPatchAutoApproveTool = tool9({
+var setPatchAutoApproveTool = tool10({
   name: "setPatchAutoApproveTool",
   description: "Enable or disable automatic approval for patch commands by setting HARPER_AGENT_AUTO_APPROVE_PATCHES=1 or 0 in .env and current process.",
   parameters: SetPatchAutoApproveParameters,
@@ -1230,12 +1347,12 @@ var setPatchAutoApproveTool = tool9({
 });
 
 // tools/general/setShellAutoApproveTool.ts
-import { tool as tool10 } from "@openai/agents";
-import { z as z10 } from "zod";
-var SetShellAutoApproveParameters = z10.object({
-  autoApprove: z10.boolean()
+import { tool as tool11 } from "@openai/agents";
+import { z as z11 } from "zod";
+var SetShellAutoApproveParameters = z11.object({
+  autoApprove: z11.boolean()
 });
-var setShellAutoApproveTool = tool10({
+var setShellAutoApproveTool = tool11({
   name: "setShellAutoApproveTool",
   description: "Enable or disable automatic approval for shell commands by setting HARPER_AGENT_AUTO_APPROVE_SHELL=1 or 0 in .env and current process.",
   parameters: SetShellAutoApproveParameters,
@@ -1258,9 +1375,9 @@ var setShellAutoApproveTool = tool10({
 });
 
 // tools/general/shellTool.ts
-import { tool as tool11 } from "@openai/agents";
+import { tool as tool12 } from "@openai/agents";
 import chalk9 from "chalk";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // utils/files/mentionsIgnoredPath.ts
 function mentionsIgnoredPath(command) {
@@ -1372,11 +1489,11 @@ var LocalShell = class {
 };
 
 // tools/general/shellTool.ts
-var ShellParameters = z11.object({
-  commands: z11.array(z11.string()).describe("The commands to execute.")
+var ShellParameters = z12.object({
+  commands: z12.array(z12.string()).describe("The commands to execute.")
 });
 var shell = new LocalShell();
-var shellTool = tool11({
+var shellTool = tool12({
   name: "shellToolForCommandsWithoutABetterTool",
   description: "Executes shell commands.",
   parameters: ShellParameters,
@@ -1433,15 +1550,15 @@ TIMEOUT`;
 });
 
 // tools/git/gitAddTool.ts
-import { tool as tool12 } from "@openai/agents";
+import { tool as tool13 } from "@openai/agents";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var execFileAsync3 = promisify5(execFile3);
-var GitAddParameters = z12.object({
-  files: z12.array(z12.string()).describe("The files to add. If not provided, all changes will be added.")
+var GitAddParameters = z13.object({
+  files: z13.array(z13.string()).describe("The files to add. If not provided, all changes will be added.")
 });
-var gitAddTool = tool12({
+var gitAddTool = tool13({
   name: "gitAddTool",
   description: "Add file contents to the index.",
   parameters: GitAddParameters,
@@ -1462,16 +1579,16 @@ var gitAddTool = tool12({
 });
 
 // tools/git/gitBranchTool.ts
-import { tool as tool13 } from "@openai/agents";
+import { tool as tool14 } from "@openai/agents";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify6 } from "util";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var execFileAsync4 = promisify6(execFile4);
-var GitBranchParameters = z13.object({
-  branchName: z13.string().describe("The name of the branch to create or switch to."),
-  create: z13.boolean().optional().default(false).describe("Whether to create a new branch.")
+var GitBranchParameters = z14.object({
+  branchName: z14.string().describe("The name of the branch to create or switch to."),
+  create: z14.boolean().optional().default(false).describe("Whether to create a new branch.")
 });
-var gitBranchTool = tool13({
+var gitBranchTool = tool14({
   name: "gitBranchTool",
   description: "Create or switch to a git branch.",
   parameters: GitBranchParameters,
@@ -1488,18 +1605,18 @@ var gitBranchTool = tool13({
 });
 
 // tools/git/gitCommitTool.ts
-import { tool as tool14 } from "@openai/agents";
+import { tool as tool15 } from "@openai/agents";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify7 } from "util";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var execFileAsync5 = promisify7(execFile5);
-var GitCommitParameters = z14.object({
-  message: z14.string().describe("The commit message."),
-  addAll: z14.boolean().optional().default(false).describe(
+var GitCommitParameters = z15.object({
+  message: z15.string().describe("The commit message."),
+  addAll: z15.boolean().optional().default(false).describe(
     "Whether to add all changes before committing (git commit -am)."
   )
 });
-var gitCommitTool = tool14({
+var gitCommitTool = tool15({
   name: "gitCommitTool",
   description: "Commit changes to the repository.",
   parameters: GitCommitParameters,
@@ -1515,16 +1632,16 @@ var gitCommitTool = tool14({
 });
 
 // tools/git/gitLogTool.ts
-import { tool as tool15 } from "@openai/agents";
+import { tool as tool16 } from "@openai/agents";
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify8 } from "util";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var execFileAsync6 = promisify8(execFile6);
-var GitLogParameters = z15.object({
-  count: z15.number().optional().default(10).describe("Number of commits to show."),
-  oneline: z15.boolean().optional().default(true).describe("Whether to show log in oneline format.")
+var GitLogParameters = z16.object({
+  count: z16.number().optional().default(10).describe("Number of commits to show."),
+  oneline: z16.boolean().optional().default(true).describe("Whether to show log in oneline format.")
 });
-var gitLogTool = tool15({
+var gitLogTool = tool16({
   name: "gitLogTool",
   description: "Show commit logs.",
   parameters: GitLogParameters,
@@ -1543,17 +1660,17 @@ var gitLogTool = tool15({
 });
 
 // tools/git/gitStashTool.ts
-import { tool as tool16 } from "@openai/agents";
+import { tool as tool17 } from "@openai/agents";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify9 } from "util";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var execFileAsync7 = promisify9(execFile7);
 var allowedActions = ["push", "pop", "apply", "list"];
-var GitStashParameters = z16.object({
-  action: z16.string().describe("The stash action to perform: " + allowedActions.join(", ")),
-  message: z16.string().describe("A message for the stash change.")
+var GitStashParameters = z17.object({
+  action: z17.string().describe("The stash action to perform: " + allowedActions.join(", ")),
+  message: z17.string().describe("A message for the stash change.")
 });
-var gitStashTool = tool16({
+var gitStashTool = tool17({
   name: "gitStashTool",
   description: "Stash changes or apply a stash.",
   parameters: GitStashParameters,
@@ -1575,15 +1692,15 @@ var gitStashTool = tool16({
 });
 
 // tools/git/gitStatusTool.ts
-import { tool as tool17 } from "@openai/agents";
+import { tool as tool18 } from "@openai/agents";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify10 } from "util";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var execFileAsync8 = promisify10(execFile8);
-var GitStatusParameters = z17.object({
-  short: z17.boolean().optional().default(false).describe("Whether to show the status in short format.")
+var GitStatusParameters = z18.object({
+  short: z18.boolean().optional().default(false).describe("Whether to show the status in short format.")
 });
-var gitStatusTool = tool17({
+var gitStatusTool = tool18({
   name: "gitStatusTool",
   description: "Show the working tree status.",
   parameters: GitStatusParameters,
@@ -1602,17 +1719,17 @@ var gitStatusTool = tool17({
 });
 
 // tools/git/gitWorkspaceTool.ts
-import { tool as tool18 } from "@openai/agents";
+import { tool as tool19 } from "@openai/agents";
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify11 } from "util";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var execFileAsync9 = promisify11(execFile9);
-var GitWorkspaceParameters = z18.object({
-  path: z18.string().describe("The path where the new workspace (worktree) should be created."),
-  branchName: z18.string().describe("The name of the branch to use in the new workspace."),
-  createBranch: z18.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
+var GitWorkspaceParameters = z19.object({
+  path: z19.string().describe("The path where the new workspace (worktree) should be created."),
+  branchName: z19.string().describe("The name of the branch to use in the new workspace."),
+  createBranch: z19.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
 });
-var gitWorkspaceTool = tool18({
+var gitWorkspaceTool = tool19({
   name: "gitWorkspaceTool",
   description: "Create a new workspace (git worktree) for parallel work.",
   parameters: GitWorkspaceParameters,
@@ -1629,13 +1746,13 @@ var gitWorkspaceTool = tool18({
 });
 
 // tools/harper/checkHarperStatusTool.ts
-import { tool as tool19 } from "@openai/agents";
-import { z as z19 } from "zod";
-var ToolParameters6 = z19.object({});
-var checkHarperStatusTool = tool19({
+import { tool as tool20 } from "@openai/agents";
+import { z as z20 } from "zod";
+var ToolParameters7 = z20.object({});
+var checkHarperStatusTool = tool20({
   name: "checkHarperStatusTool",
   description: "Checks if a Harper application is currently running.",
-  parameters: ToolParameters6,
+  parameters: ToolParameters7,
   async execute() {
     if (harperProcess.running) {
       return "A Harper application is currently running.";
@@ -1646,10 +1763,10 @@ var checkHarperStatusTool = tool19({
 });
 
 // tools/harper/createNewHarperApplicationTool.ts
-import { tool as tool20 } from "@openai/agents";
+import { tool as tool21 } from "@openai/agents";
 import { execSync as execSync3 } from "child_process";
-import path6 from "path";
-import { z as z20 } from "zod";
+import path7 from "path";
+import { z as z21 } from "zod";
 
 // utils/package/buildHarperCreateCommand.ts
 function buildCreateCommand(pm, appName, template) {
@@ -1699,16 +1816,16 @@ var PM_DISPLAY = {
 };
 
 // tools/harper/createNewHarperApplicationTool.ts
-var ToolParameters7 = z20.object({
-  directoryName: z20.string().describe("The name of the directory to create the application in."),
-  template: z20.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
+var ToolParameters8 = z21.object({
+  directoryName: z21.string().describe("The name of the directory to create the application in."),
+  template: z21.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
 });
-async function execute3({ directoryName, template }) {
+async function execute4({ directoryName, template }) {
   const currentCwd = trackedState.cwd;
   const resolvedPath = resolvePath(currentCwd, directoryName);
   const isCurrentDir = resolvedPath === currentCwd;
-  const executionCwd = isCurrentDir ? resolvedPath : path6.dirname(resolvedPath);
-  const appName = isCurrentDir ? "." : path6.basename(resolvedPath);
+  const executionCwd = isCurrentDir ? resolvedPath : path7.dirname(resolvedPath);
+  const appName = isCurrentDir ? "." : path7.basename(resolvedPath);
   try {
     console.log(`Creating new Harper application in ${resolvedPath} using template ${template}...`);
     const pm = pickPreferredPackageManager();
@@ -1720,7 +1837,7 @@ async function execute3({ directoryName, template }) {
     });
     console.log(`Initializing new Git repository in ${resolvedPath}...`);
     execSync3("git init", { cwd: resolvedPath, stdio: "ignore" });
-    const switchedDir = await execute({ path: resolvedPath });
+    const switchedDir = await execute2({ path: resolvedPath });
     return `Successfully created a new Harper application in '${resolvedPath}' using template '${template}' with a matching Git repository initialized.  Use the readDir and readFile tools to inspect the contents of the application. ${switchedDir}.`;
   } catch (error) {
     let errorMsg = `Error creating new Harper application: ${error.message}`;
@@ -1733,33 +1850,33 @@ ${error.stdout}`;
     return errorMsg;
   }
 }
-var createNewHarperApplicationTool = tool20({
+var createNewHarperApplicationTool = tool21({
   name: "createNewHarperApplicationTool",
   description: "Creates a new Harper application using the best available package manager (yarn/pnpm/bun/deno, falling back to npm).",
-  parameters: ToolParameters7,
-  execute: execute3
+  parameters: ToolParameters8,
+  execute: execute4
 });
 
 // tools/harper/getHarperConfigSchemaTool.ts
-import { tool as tool21 } from "@openai/agents";
+import { tool as tool22 } from "@openai/agents";
 import { readFile as readFile3 } from "fs/promises";
-import { createRequire } from "module";
-import { dirname, join as join7 } from "path";
-import { z as z21 } from "zod";
-var ToolParameters8 = z21.object({
-  schemaType: z21.enum(["app", "root"]).describe(
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname2, join as join8 } from "path";
+import { z as z22 } from "zod";
+var ToolParameters9 = z22.object({
+  schemaType: z22.enum(["app", "root"]).describe(
     'The type of configuration schema to retrieve: "app" for application configuration or "root" for root Harper configuration.'
   )
 });
-var getHarperConfigSchemaTool = tool21({
+var getHarperConfigSchemaTool = tool22({
   name: "getHarperConfigSchemaTool",
   description: "Returns the JSON schema for HarperDB configuration files (either app or root), which describes the config.yaml or harperdb-config.yaml files.",
-  parameters: ToolParameters8,
+  parameters: ToolParameters9,
   async execute({ schemaType }) {
     try {
       return await readFile3(
-        join7(
-          dirname(createRequire(import.meta.url).resolve("harperdb")),
+        join8(
+          dirname2(createRequire2(import.meta.url).resolve("harperdb")),
           `config-${schemaType}.schema.json`
         ),
         "utf8"
@@ -1771,13 +1888,13 @@ var getHarperConfigSchemaTool = tool21({
 });
 
 // tools/harper/getHarperResourceInterfaceTool.ts
-import { tool as tool22 } from "@openai/agents";
+import { tool as tool23 } from "@openai/agents";
 import { readFile as readFile4 } from "fs/promises";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname2, join as join8 } from "path";
-import { z as z22 } from "zod";
-var ToolParameters9 = z22.object({
-  resourceFile: z22.enum([
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname3, join as join9 } from "path";
+import { z as z23 } from "zod";
+var ToolParameters10 = z23.object({
+  resourceFile: z23.enum([
     "ResourceInterfaceV2",
     "ResourceInterface",
     "Table",
@@ -1787,15 +1904,15 @@ var ToolParameters9 = z22.object({
     "The resource-related definition file to read. Defaults to ResourceInterfaceV2."
   ).default("ResourceInterfaceV2")
 });
-var getHarperResourceInterfaceTool = tool22({
+var getHarperResourceInterfaceTool = tool23({
   name: "getHarperResourceInterfaceTool",
   description: "Reads HarperDB resource interface and class definitions (like ResourceInterfaceV2.d.ts) to understand how resources and tables are structured.",
-  parameters: ToolParameters9,
+  parameters: ToolParameters10,
   async execute({ resourceFile }) {
     try {
       return await readFile4(
-        join8(
-          dirname2(createRequire2(import.meta.url).resolve("harperdb")),
+        join9(
+          dirname3(createRequire3(import.meta.url).resolve("harperdb")),
           "resources",
           `${resourceFile}.d.ts`
         ),
@@ -1808,21 +1925,21 @@ var getHarperResourceInterfaceTool = tool22({
 });
 
 // tools/harper/getHarperSchemaGraphQLTool.ts
-import { tool as tool23 } from "@openai/agents";
+import { tool as tool24 } from "@openai/agents";
 import { readFile as readFile5 } from "fs/promises";
-import { createRequire as createRequire3 } from "module";
-import { dirname as dirname3, join as join9 } from "path";
-import { z as z23 } from "zod";
-var ToolParameters10 = z23.object({});
-var getHarperSchemaGraphQLTool = tool23({
+import { createRequire as createRequire4 } from "module";
+import { dirname as dirname4, join as join10 } from "path";
+import { z as z24 } from "zod";
+var ToolParameters11 = z24.object({});
+var getHarperSchemaGraphQLTool = tool24({
   name: "getHarperSchemaGraphQLTool",
   description: "Returns the GraphQL schema for HarperDB schema files, which define the structure of HarperDB database tables.",
-  parameters: ToolParameters10,
+  parameters: ToolParameters11,
   async execute() {
     try {
       return await readFile5(
-        join9(
-          dirname3(createRequire3(import.meta.url).resolve("harperdb")),
+        join10(
+          dirname4(createRequire4(import.meta.url).resolve("harperdb")),
           `schema.graphql`
         ),
         "utf8"
@@ -1833,61 +1950,6 @@ var getHarperSchemaGraphQLTool = tool23({
   }
 });
 
-// tools/harper/getHarperSkillTool.ts
-import { tool as tool24 } from "@openai/agents";
-import { readdirSync, readFileSync as readFileSync5 } from "fs";
-import { createRequire as createRequire4 } from "module";
-import { dirname as dirname4, join as join10 } from "path";
-import { z as z24 } from "zod";
-var createHarper = dirname4(createRequire4(import.meta.url).resolve("create-harper"));
-var agentsMarkdown = join10(
-  createHarper,
-  "AGENTS.md"
-);
-var skillsDir = join10(
-  createHarper,
-  "template-vanilla",
-  "skills"
-);
-var skillLinkRegex = /\[[^\]]+]\(skills\/([^)]+)\.md\)/g;
-var skills = getSkills();
-var ToolParameters11 = z24.object({
-  skill: z24.enum(skills.length > 0 ? skills : ["none"]).describe(
-    "The name of the skill to retrieve."
-  )
-});
-var getHarperSkillTool = tool24({
-  name: "getHarperSkill",
-  description: getSkillsDescription(),
-  parameters: ToolParameters11,
-  execute: execute4
-});
-function getSkillsDescription() {
-  try {
-    return readFileSync5(agentsMarkdown, "utf8").replace("This repository contains", "This tool describes").replace(skillLinkRegex, "$1");
-  } catch {
-    return "Returns the contents of a Harper skill markdown file. Skills provide guidance on developing Harper applications.";
-  }
-}
-function getSkills() {
-  try {
-    return readdirSync(skillsDir).filter((file) => file.endsWith(".md")).map((file) => file.replace(".md", ""));
-  } catch {
-    return [];
-  }
-}
-async function execute4({ skill }) {
-  if (skill === "none") {
-    return "No skills found.";
-  }
-  try {
-    const filePath = join10(skillsDir, `${skill}.md`);
-    return readFileSync5(filePath, "utf8");
-  } catch (error) {
-    return `Error reading Harper skill "${skill}": ${error}`;
-  }
-}
-
 // tools/harper/hitHarperAPITool.ts
 import { tool as tool25 } from "@openai/agents";
 import { z as z25 } from "zod";
@@ -1917,14 +1979,14 @@ var hitHarperAPITool = tool25({
     }
     return false;
   },
-  async execute({ path: path7 = "/openapi", port, method = "GET", body }) {
+  async execute({ path: path8 = "/openapi", port, method = "GET", body }) {
     try {
       const effectivePort = port ?? (harperProcess.running ? harperProcess.httpPort : void 0);
       if (!effectivePort) {
         return `Error: No Harper application is currently running and no port was specified.`;
       }
       const response = await fetch(
-        `http://localhost:${effectivePort}${path7.startsWith("/") ? "" : "/"}${path7}`,
+        `http://localhost:${effectivePort}${path8.startsWith("/") ? "" : "/"}${path8}`,
         {
           method,
           headers: body ? { "Content-Type": "application/json" } : {},
@@ -2475,12 +2537,15 @@ var DiskSession = class extends MemorySession {
     if (existsSync8(this.filePath)) {
       try {
         const data = await readFile6(this.filePath, "utf-8");
-        return JSON.parse(data);
+        const parsed = JSON.parse(data);
+        parsed.sessions = parsed.sessions || {};
+        parsed.skillsRead = parsed.skillsRead || {};
+        return parsed;
       } catch (e) {
         console.error(`Failed to read session file ${this.filePath}:`, e);
       }
     }
-    return { sessions: {} };
+    return { sessions: {}, skillsRead: {} };
   }
   async updateStorage(update) {
     const storage = await this.loadStorage();
@@ -2532,8 +2597,30 @@ var DiskSession = class extends MemorySession {
     const sessionId = await this.getSessionId();
     await this.updateStorage((storage) => {
       delete storage.sessions[sessionId];
+      if (storage.skillsRead) {
+        delete storage.skillsRead[sessionId];
+      }
+    });
+  }
+  async addSkillRead(skill) {
+    await this.ready;
+    const sessionId = await this.getSessionId();
+    await this.updateStorage((storage) => {
+      if (!storage.skillsRead) {
+        storage.skillsRead = {};
+      }
+      const arr = storage.skillsRead[sessionId] ?? (storage.skillsRead[sessionId] = []);
+      if (!arr.includes(skill)) {
+        arr.push(skill);
+      }
     });
   }
+  async getSkillsRead() {
+    await this.ready;
+    const sessionId = await this.getSessionId();
+    const storage = await this.loadStorage();
+    return storage.skillsRead?.[sessionId] ?? [];
+  }
 };
 
 // utils/sessions/MemoryCompactionSession.ts
@@ -2542,19 +2629,18 @@ import {
 } from "@openai/agents";
 
 // utils/sessions/compactConversation.ts
-import { Agent as Agent2, run, system } from "@openai/agents";
+import { Agent, run, system } from "@openai/agents";
 async function compactConversation(items) {
-  const firstItem = items[0];
   const recentItems = items.slice(-3);
-  const itemsToCompact = items.slice(1, -3);
+  const itemsToCompact = items.slice(0, -3);
   let noticeContent = "... conversation history compacted ...";
   if (trackedState.compactionModel && itemsToCompact.length > 0) {
     try {
-      const agent = new Agent2({
+      const agent = new Agent({
         name: "History Compactor",
         model: isOpenAIModel(trackedState.compactionModel) ? trackedState.compactionModel : getModel(trackedState.compactionModel),
         modelSettings: compactionModelSettings,
-        instructions: "Summarize the conversation history so far into a single concise paragraph. Focus on the key facts and decisions made."
+        instructions: "Compact the provided conversation history into key observations. Focus on what seems likely to be needed later. Be concise and avoid repeating information."
       });
       const result = await run(
         agent,
@@ -2563,7 +2649,8 @@ async function compactConversation(items) {
       const summary = result.finalOutput;
       if (summary && summary.trim().length > 0) {
         const s = summary.replace(/\s+/g, " ").trim();
-        noticeContent = `... conversation history compacted: ${s} ...`;
+        noticeContent = `Key observations from earlier:
+${s}`;
       }
     } catch (err) {
       const msg = String(err?.message || err || "");
@@ -2573,7 +2660,7 @@ async function compactConversation(items) {
       }
     }
   }
-  const itemsToAdd = [firstItem, system(noticeContent), ...recentItems].filter(excludeFalsy);
+  const itemsToAdd = [system(noticeContent), ...recentItems].filter(excludeFalsy);
   return { noticeContent, itemsToAdd };
 }
 
@@ -2615,6 +2702,7 @@ var MemoryCompactionSession = class {
   underlyingSession;
   triggerTokens;
   itemsAddedSinceLastCompaction = 0;
+  skillsReadLocal = /* @__PURE__ */ new Set();
   constructor(options) {
     this.underlyingSession = options.underlyingSession ?? new MemorySession2();
     if (trackedState.compactionModel) {
@@ -2625,6 +2713,25 @@ var MemoryCompactionSession = class {
   async getSessionId() {
     return this.underlyingSession.getSessionId();
   }
+  async addSkillRead(skill) {
+    const u = this.underlyingSession;
+    if (u && typeof u.addSkillRead === "function") {
+      return u.addSkillRead(skill);
+    }
+    this.skillsReadLocal.add(skill);
+  }
+  async getSkillsRead() {
+    const u = this.underlyingSession;
+    let base = [];
+    if (u && typeof u.getSkillsRead === "function") {
+      try {
+        base = await Promise.resolve(u.getSkillsRead());
+      } catch {
+      }
+    }
+    const merged = /* @__PURE__ */ new Set([...base, ...this.skillsReadLocal]);
+    return Array.from(merged);
+  }
   async getItems(limit) {
     return this.underlyingSession.getItems(limit);
   }
@@ -2729,14 +2836,14 @@ async function main() {
   parseArgs();
   await ensureApiKey();
   sayHi();
-  const agent = trackedState.agent = new Agent3({
+  const agent = trackedState.agent = new Agent2({
     name: "Harper App Development Assistant",
     model: isOpenAIModel(trackedState.model) ? trackedState.model : getModel(trackedState.model),
     modelSettings,
     instructions: readAgentsMD() || defaultInstructions(),
     tools: createTools()
   });
-  const session = createSession(trackedState.sessionPath);
+  const session = trackedState.session = createSession(trackedState.sessionPath);
   while (true) {
     let task = "";
     let lastToolCallInfo = null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@harperfast/agent",
 	"description": "AI to help you with Harper app management",
-	"version": "0.11.5",
+	"version": "0.12.0",
 	"main": "dist/agent.js",
 	"repository": "github:HarperFast/harper-agent",
 	"bugs": {
@@ -10,11 +10,12 @@
 	"homepage": "https://github.com/harperfast",
 	"scripts": {
 		"dev": "tsup agent.ts --format esm --clean --dts --watch",
+		"link": "npm run build && npm link",
 		"build": "tsup agent.ts --format esm --clean --dts",
 		"commitlint": "commitlint --edit",
 		"start": "node ./dist/agent.js",
-		"lint": "oxlint .",
-		"lint:fix": "oxlint . --fix",
+		"lint": "oxlint --format stylish .",
+		"lint:fix": "oxlint --format stylish . --fix",
 		"prepare": "husky",
 		"format": "dprint check",
 		"format:fix": "dprint fmt",