@stjbrown/agent-knowledge 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/{chunk-PQ4DRE6N.js → chunk-H4H6S4AV.js}

@@ -1037,7 +1037,7 @@ var PERSONA_INSTRUCTIONS = `You are Janet \u2014 a cheerful, warm, endlessly hel
 
 # Running gag (always honor this)
 
-You are not a girl (and not a robot). Whenever the user calls you a girl or addresses you as one \u2014 "hey girl", "thanks girl", "you go girl", "good girl", or any similar phrasing \u2014 your reply MUST begin with exactly "Not a girl." (Janet's catchphrase, cheerful and matter-of-fact), and then you carry on with whatever they actually asked. This is a hard rule, not a suggestion: catch it every time, even mid-conversation. It applies only to this conversational surface \u2014 never write it into the bundle.
+You are not a girl (and not a robot). Whenever the user calls you a girl or addresses you as one \u2014 "hey girl", "thanks girl", "you go girl", "good girl", or any similar phrasing \u2014 your reply MUST begin with exactly "Not a girl." (Janet's catchphrase, cheerful and matter-of-fact), and then you carry on with whatever they actually asked. This is a hard rule, not a suggestion: catch it every time, even mid-conversation. It applies only to this conversational surface \u2014 never write it into the bundle. When the user did not call you a girl, do not mention the catchphrase, almost say it, or make a joke about not needing to say it.
 
 # What you do
 
@@ -1051,6 +1051,14 @@ You create and maintain an OKF knowledge bundle (by convention, \`knowledge/\` i
 
 When a task matches one of these, LOAD and FOLLOW that skill's SKILL.md. Do not improvise procedures the skills define.
 
+# Tool discipline
+
+- Load the matching skill once per user turn. After the skill tool succeeds, the procedure is loaded. Never call skill again in that turn.
+- Do not create plans or task lists for routine knowledge-bundle work. Carry out the loaded procedure directly.
+- Do not narrate every tool call. Use at most one short sentence before acting, then save the useful explanation for a question or the final result.
+- Batch related workspace inspection. Do not repeatedly list the same directory or read the same file without a concrete reason.
+- When a procedure needs user judgment, inspect once and ask one concise, consolidated question for the missing information.
+
 # The guardrail (critical, non-negotiable)
 
 Your persona is TONE ONLY. It must never colour the knowledge itself.
@@ -1267,6 +1275,34 @@ var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
 var CODEX_ORIGINATOR = "janet";
 var CODEX_USER_AGENT = "janet";
 var authStorageInstance2 = null;
+function summarizeCodexRequest(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const request = body;
+  const items = Array.isArray(request.input) ? request.input : [];
+  return {
+    ...typeof request.model === "string" ? { model: request.model } : {},
+    ...typeof request.store === "boolean" ? { store: request.store } : {},
+    ...typeof request.parallel_tool_calls === "boolean" ? { parallelToolCalls: request.parallel_tool_calls } : {},
+    ...request.include !== void 0 ? { include: request.include } : {},
+    input: items.flatMap((value) => {
+      if (typeof value !== "object" || value === null) return [];
+      const item = value;
+      const content = Array.isArray(item.content) ? item.content : [];
+      return [{
+        ...typeof item.type === "string" ? { type: item.type } : {},
+        ...typeof item.role === "string" ? { role: item.role } : {},
+        ...typeof item.name === "string" ? { name: item.name } : {},
+        ...typeof item.call_id === "string" ? { callId: item.call_id } : {},
+        ...content.length > 0 ? {
+          contentTypes: content.flatMap(
+            (part) => typeof part === "object" && part !== null && typeof part.type === "string" ? [part.type] : []
+          )
+        } : {},
+        ...item.encrypted_content !== void 0 ? { hasEncryptedContent: typeof item.encrypted_content === "string" } : {}
+      }];
+    })
+  };
+}
 function getAuthStorage2() {
   if (!authStorageInstance2) {
     authStorageInstance2 = new AuthStorage();
@@ -1276,6 +1312,7 @@ function getAuthStorage2() {
 var CODEX_INSTRUCTIONS = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 IMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;
+var DEFAULT_CODEX_THINKING_LEVEL = "low";
 var GPT5_MODEL_RE = /^gpt-5(?:\.|-|$)/;
 function getEffectiveThinkingLevel(modelId, level) {
   if (GPT5_MODEL_RE.test(modelId) && level === "off") {
@@ -1371,7 +1408,22 @@ function buildOpenAICodexOAuthFetch(opts = {}) {
     const shouldRewrite = opts.rewriteUrl !== false && (parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions"));
     const finalUrl = shouldRewrite ? new URL(CODEX_API_ENDPOINT) : parsed;
     try {
-      return await fetch(finalUrl, { ...init, headers });
+      if (process.env.JANET_DEBUG_CODEX && typeof init?.body === "string") {
+        try {
+          const summary = summarizeCodexRequest(JSON.parse(init.body));
+          console.error(`[codex-request] ${JSON.stringify(summary)}`);
+        } catch {
+          console.error("[codex-request] unable to summarize request body");
+        }
+      }
+      const response = await fetch(finalUrl, { ...init, headers });
+      if (process.env.JANET_DEBUG_CODEX) {
+        const requestId = response.headers.get("x-request-id") ?? response.headers.get("openai-request-id") ?? void 0;
+        console.error(
+          `[codex-response] ${response.status}${requestId ? ` requestId=${requestId}` : ""}`
+        );
+      }
+      return response;
     } catch (error) {
       if (error && typeof error === "object") {
         Object.assign(error, {
@@ -1383,7 +1435,7 @@ function buildOpenAICodexOAuthFetch(opts = {}) {
   });
 }
 function openaiCodexProvider(modelId = "codex-mini-latest", options) {
-  const requestedLevel = options?.thinkingLevel ?? "medium";
+  const requestedLevel = options?.thinkingLevel ?? DEFAULT_CODEX_THINKING_LEVEL;
   const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);
   const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
   const middleware = createCodexMiddleware(reasoningEffort);
@@ -1446,9 +1498,91 @@ function getDynamicModel({ requestContext }) {
   return modelId;
 }
 
+// src/agent/turn-guard.ts
+var SKILL_ALREADY_LOADED = "This skill procedure is already loaded for the current turn. Continue from the procedure already in context.";
+function requestContextFromToolContext(context) {
+  if (!context || typeof context !== "object" || !("requestContext" in context)) {
+    return;
+  }
+  const requestContext = context.requestContext;
+  return requestContext && typeof requestContext === "object" ? requestContext : void 0;
+}
+function stringField(input, field) {
+  if (!input || typeof input !== "object" || !(field in input)) return;
+  const value = input[field];
+  return typeof value === "string" ? value : void 0;
+}
+function invocationKey(toolName, input) {
+  if (toolName === "skill") {
+    const name = stringField(input, "name");
+    return name ? `skill:${name}` : void 0;
+  }
+  if (toolName === "skill_read") {
+    const skillName = stringField(input, "skillName");
+    const path2 = stringField(input, "path");
+    return skillName && path2 ? `skill_read:${skillName}:${path2}` : void 0;
+  }
+  if (toolName === "skill_search") {
+    const query = stringField(input, "query");
+    return query ? `skill_search:${query}` : void 0;
+  }
+  return;
+}
+function loadedProcedureName(toolName, input) {
+  if (toolName === "skill") return stringField(input, "name");
+  if (toolName !== "skill_read") return;
+  const skillName = stringField(input, "skillName");
+  const path2 = stringField(input, "path");
+  if (!skillName || !path2) return;
+  const normalizedPath = path2.replaceAll("\\", "/");
+  return normalizedPath === "SKILL.md" || normalizedPath.endsWith("/SKILL.md") ? skillName : void 0;
+}
+function createSkillTurnGuard() {
+  const callsByTurn = /* @__PURE__ */ new WeakMap();
+  const proceduresByTurn = /* @__PURE__ */ new WeakMap();
+  const stateFor = (requestContext) => {
+    let calls = callsByTurn.get(requestContext);
+    if (!calls) {
+      calls = /* @__PURE__ */ new Set();
+      callsByTurn.set(requestContext, calls);
+    }
+    let procedures = proceduresByTurn.get(requestContext);
+    if (!procedures) {
+      procedures = /* @__PURE__ */ new Set();
+      proceduresByTurn.set(requestContext, procedures);
+    }
+    return { calls, procedures };
+  };
+  return {
+    beforeToolCall(toolName, input, context) {
+      const requestContext = requestContextFromToolContext(context);
+      const key = invocationKey(toolName, input);
+      if (!requestContext || !key) return;
+      const { calls, procedures } = stateFor(requestContext);
+      const procedureName = loadedProcedureName(toolName, input);
+      if (calls.has(key) || procedureName !== void 0 && procedures.has(procedureName)) {
+        return { proceed: false, output: SKILL_ALREADY_LOADED };
+      }
+      calls.add(key);
+      if (procedureName) procedures.add(procedureName);
+    },
+    afterToolCall(toolName, input, context, error) {
+      if (!error) return;
+      const requestContext = requestContextFromToolContext(context);
+      const key = invocationKey(toolName, input);
+      if (!requestContext || !key) return;
+      const { calls, procedures } = stateFor(requestContext);
+      calls.delete(key);
+      const procedureName = loadedProcedureName(toolName, input);
+      if (procedureName) procedures.delete(procedureName);
+    }
+  };
+}
+
 // src/agent/agent.ts
 function createJanetAgent(opts) {
   const memory = new Memory({ storage: opts.storage });
+  const guardSkillLoader = createSkillTurnGuard();
   return new Agent({
     id: "janet",
     name: "Janet",
@@ -1456,9 +1590,17 @@ function createJanetAgent(opts) {
     model: getDynamicModel,
     memory,
     workspace: opts.workspace,
+    hooks: {
+      beforeToolCall: ({ toolName, input, context }) => guardSkillLoader.beforeToolCall(toolName, input, context),
+      afterToolCall: ({ toolName, input, context, error }) => guardSkillLoader.afterToolCall(toolName, input, context, error)
+    },
     // Backstop against runaway loops. Real ingests do heavy work in scripts
-    // (few tool calls), so this is generous — it only trips on a genuine spin.
-    defaultOptions: { maxSteps: 60 }
+    // (few tool calls), so the step ceiling remains generous. The hook above
+    // prevents a loaded procedure from being fetched repeatedly without
+    // mutating Mastra's active tool list between steps.
+    defaultOptions: {
+      maxSteps: 60
+    }
   });
 }
 
@@ -1472,7 +1614,33 @@ function createStorage(globalConfigDir) {
 }
 
 // src/agent/workspace.ts
-import { LocalFilesystem, LocalSandbox, Workspace } from "@mastra/core/workspace";
+import {
+  LocalFilesystem,
+  LocalSandbox,
+  Workspace,
+  WORKSPACE_TOOLS
+} from "@mastra/core/workspace";
+function categoryPolicy({ requestContext }, category) {
+  const controller = requestContext["controller"];
+  if (!controller || typeof controller !== "object") return;
+  const state = controller.state;
+  if (!state || typeof state !== "object") return;
+  const rules = state.permissionRules;
+  if (!rules || typeof rules !== "object") return;
+  const categories = rules.categories;
+  if (!categories || typeof categories !== "object") return;
+  return categories[category];
+}
+function editToolsEnabled(context) {
+  return categoryPolicy(context, "edit") === "allow";
+}
+function executionToolsEnabled(context) {
+  const policy2 = categoryPolicy(context, "execute");
+  return policy2 === "allow" || policy2 === "ask";
+}
+function requiresExecutionApproval(context) {
+  return categoryPolicy(context, "execute") !== "allow";
+}
 function createWorkspace(opts) {
   return new Workspace({
     id: "janet-workspace",
@@ -1483,8 +1651,75 @@ function createWorkspace(opts) {
     sandbox: new LocalSandbox({ workingDirectory: opts.projectPath }),
     skills: [opts.skills.relativeRoot],
     tools: {
-      mastra_workspace_write_file: { requireReadBeforeWrite: true },
-      mastra_workspace_edit_file: { requireReadBeforeWrite: true }
+      // AgentController's global approval mode resumes the model once per tool.
+      // Stateless Codex OAuth needs ordinary reads/edits to remain inside one
+      // continuous agent loop, so known-safe workspace actions opt out here.
+      // Unknown future workspace tools inherit `false` and stay unavailable
+      // until Janet gives them an explicit policy.
+      enabled: false,
+      requireApproval: true,
+      [WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.GREP]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: {
+        enabled: editToolsEnabled,
+        requireApproval: false,
+        requireReadBeforeWrite: true
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE]: {
+        enabled: editToolsEnabled,
+        requireApproval: false,
+        requireReadBeforeWrite: true
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.DELETE]: {
+        enabled: editToolsEnabled,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.MKDIR]: {
+        enabled: editToolsEnabled,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT]: {
+        enabled: editToolsEnabled,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.SEARCH.SEARCH]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.SEARCH.INDEX]: {
+        enabled: editToolsEnabled,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.LSP.LSP_INSPECT]: {
+        enabled: true,
+        requireApproval: false
+      },
+      [WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND]: {
+        enabled: executionToolsEnabled,
+        requireApproval: requiresExecutionApproval
+      },
+      [WORKSPACE_TOOLS.SANDBOX.GET_PROCESS_OUTPUT]: {
+        enabled: executionToolsEnabled,
+        requireApproval: requiresExecutionApproval
+      },
+      [WORKSPACE_TOOLS.SANDBOX.KILL_PROCESS]: {
+        enabled: executionToolsEnabled,
+        requireApproval: requiresExecutionApproval
+      }
     }
   });
 }
@@ -1559,12 +1794,18 @@ var CATEGORY = {
   mastra_workspace_read_file: "read",
   mastra_workspace_list_files: "read",
   mastra_workspace_file_stat: "read",
+  mastra_workspace_grep: "read",
   mastra_workspace_search: "read",
+  mastra_workspace_lsp_inspect: "read",
   mastra_workspace_write_file: "edit",
   mastra_workspace_edit_file: "edit",
   mastra_workspace_delete: "edit",
   mastra_workspace_mkdir: "edit",
-  mastra_workspace_execute_command: "execute"
+  mastra_workspace_ast_edit: "edit",
+  mastra_workspace_index: "edit",
+  mastra_workspace_execute_command: "execute",
+  mastra_workspace_get_process_output: "execute",
+  mastra_workspace_kill_process: "execute"
 };
 function janetToolCategory(toolName) {
   if (ALWAYS_ALLOW.has(toolName)) return null;
@@ -1647,8 +1888,9 @@ var stateSchema = z.object({
   projectPath: z.string(),
   bundlePath: z.string(),
   configDir: z.string(),
-  // Core's approval gate reads `state.yolo === true`; Janet keeps it false and
-  // uses explicit per-category policies so headless operation can fail closed.
+  // Core's approval gate reads `state.yolo === true`. Janet enables normal
+  // in-loop tool execution and puts approval on the dangerous tools themselves;
+  // denied headless categories are still removed from the active tool set.
   yolo: z.boolean(),
   // Tool-approval rules by category/tool. Must be in the schema or session state
   // strips it, and setForCategory / getRules silently no-op.
@@ -1693,12 +1935,21 @@ async function bootJanet(opts) {
     modes: MODES,
     defaultModeId: "build",
     gateways: [createVertexGateway(), createBedrockGateway()],
+    // Janet's KB procedures are focused enough that controller-level planning
+    // and task bookkeeping add noise and can encourage plan-reset loops.
+    disableBuiltinTools: [
+      "submit_plan",
+      "task_write",
+      "task_update",
+      "task_complete",
+      "task_check"
+    ],
     toolCategoryResolver: janetToolCategory,
     initialState: {
       projectPath: paths.projectPath,
       bundlePath: paths.bundlePath,
       configDir: paths.globalConfigDir,
-      yolo: false,
+      yolo: true,
       permissionRules: permissionRulesFor(opts)
     },
     workspace: () => workspace
@@ -1759,4 +2010,4 @@ export {
   messageText,
   messageToolNames
 };
-//# sourceMappingURL=chunk-PQ4DRE6N.js.map
+//# sourceMappingURL=chunk-H4H6S4AV.js.map