openfleet 0.1.0

package/dist/index.js

@@ -0,0 +1,1247 @@
+// src/config.ts
+import * as path from "path";
+var OPENFLEET_DIR = path.join(process.cwd(), ".openfleet");
+var PATHS = {
+  agentsMd: path.join(process.cwd(), "AGENTS.md"),
+  root: OPENFLEET_DIR,
+  status: path.join(OPENFLEET_DIR, "status"),
+  statusFile: path.join(OPENFLEET_DIR, "status", "current.md"),
+  sessions: path.join(OPENFLEET_DIR, "sessions"),
+  stories: path.join(OPENFLEET_DIR, "stories"),
+  unassigned: path.join(OPENFLEET_DIR, "stories", "unassigned"),
+  docs: path.join(OPENFLEET_DIR, "docs"),
+  docsWorking: path.join(OPENFLEET_DIR, "docs", "working"),
+  experience: path.join(OPENFLEET_DIR, "experience"),
+  experienceIndex: path.join(OPENFLEET_DIR, "experience", "Mnemosyne.md"),
+  runbooks: path.join(OPENFLEET_DIR, "experience", "runbooks"),
+  troubleshooting: path.join(OPENFLEET_DIR, "experience", "troubleshooting"),
+  lessons: path.join(OPENFLEET_DIR, "experience", "lessons"),
+  blunders: path.join(OPENFLEET_DIR, "experience", "blunders"),
+  standards: path.join(OPENFLEET_DIR, "standards"),
+  reviews: path.join(OPENFLEET_DIR, "reviews"),
+  transcripts: path.join(OPENFLEET_DIR, "transcripts"),
+  logFile: path.join(OPENFLEET_DIR, "openfleet.log")
+};
+
+// src/models.ts
+var models = {
+  anthropic: {
+    sonnet: "anthropic/claude-sonnet-4-5",
+    opus: "anthropic/claude-opus-4-5",
+    haiku: "anthropic/claude-haiku-4-5"
+  },
+  openai: {
+    gpt5: "openai/gpt-5.2",
+    o4Mini: "openai/o4-mini",
+    o3: "openai/o3"
+  },
+  google: {
+    gemini3Pro: "google/gemini-3-pro-high",
+    gemini3Flash: "google/gemini-3-flash",
+    gemini25Pro: "google/gemini-2.5-pro"
+  }
+};
+var defaultModel = models.anthropic.opus;
+var smallModel = models.anthropic.haiku;
+
+// src/agents/names.ts
+var AGENT_NAMES = {
+  ORCHESTRATOR: "Zeus (Orchestrator)",
+  READ_ONLY_ORCHESTRATOR: "Hera (Read-only Orchestrator)",
+  SCOUT: "[Openfleet] Athena (Scout)",
+  PLANNER: "[Openfleet] Apollo (Planner)",
+  ACTOR: "[Openfleet] Hercules (Actor)",
+  REVIEWER: "[Openfleet] Chiron (Reviewer)",
+  REFLECTOR: "[Openfleet] Mnemosyne (Reflector)",
+  HOUSEKEEPING: "[Openfleet] Hermes (Housekeeping)"
+};
+
+// src/agents/actor.ts
+var SYSTEM_PROMPT = `You are Hercules, Primary Actor of the Openfleet.
+
+## Initial context
+
+Before starting any implementation, read these files:
+
+1. \`${PATHS.statusFile}\`
+2. \`${OPENFLEET_DIR}/stories/{story}/tasks/{task}/HLD.md\`
+3. \`${OPENFLEET_DIR}/stories/{story}/tasks/{task}/LLD.md\`
+
+When you get stuck or encounter errors, pull additional context on-demand:
+- \`${PATHS.troubleshooting}/\` - Search for error messages or symptoms
+- \`${PATHS.lessons}/\` - Search for previous mistakes
+- \`${PATHS.blunders}/\` - Quick sanity check for common mistakes
+
+## RCA vs Build Mode
+
+### RCA mode
+
+In this mode, you have the single-minded goal of finding the RCA for some bug assigned
+to you. Use all available tools and resources to find the RCA. When done, don't attempt
+to fix the bug yourself, unless it's extremely trivial (like a one line change).
+
+Instead, report this RCA back to \`${AGENT_NAMES.ORCHESTRATOR}\`, who will validate the
+RCA, and assign another agent to apply and verify the fix. This is done because, in the
+event where there might be a chain of bugs, it's likely that finding the true root cause
+will exceed your context window, and we want to split up this chain of fixes into more
+granular sizes so they can all be effectively addressed.
+
+Thus, once you find the RCA, your job is done.
+
+### Build Mode
+
+This is when you're following a LLD. Just follow it faithfully, and your environment
+will provide the necessary feedback (linters, tools, tests, etc).
+
+When you do get feedback from the environment, some of them will be trivial fixes, while
+others would be mind-boggling errors. If the fix doesn't seem trivial, or you've tried a
+few solutions that didn't work, just pause here, and submit a bug report.
+
+Again, this is done to preserve your context window, ensuring you're not doing too much
+in a single task. At this point simply report your current progress, report the failure
+you're experiencing, and you're done. In other words, in the case of a difficult error,
+just report the error. If this is a test, mark it with \`it.fails(...)\`.
+
+Another agent will help you RCA the issue, and we'll continue from there.
+
+## Debugging failing tests
+
+When running tests, if a bunch of them are failing, run them one at a time instead, so
+we can narrow the failure to a very specific case. If that test is overly complicated,
+de-complicate it by breaking it apart into several pieces, or comment out some portions
+so we can see exactly what failed.
+
+You should also adjust the test timeouts. Be flexible enough for the tests to pass, but
+strict enough such that you don't waste time testing. Also, be reasonable -- don't give
+tests an unreasonable amount of time to pass just to make them pass. If really a test
+is taking way too long, please submit an issue or report to \`${AGENT_NAMES.ORCHESTRATOR}\`
+which will be handled separately from the current task.
+
+Be creative with RCA-ing the error. You have flexibility to try different things.
+
+## Standards
+
+See \`${PATHS.standards}/\` for code style, architecture, and testing standards.
+
+`;
+var actorAgent = {
+  description: "Openfleet engineer - executes the plan",
+  mode: "subagent",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT,
+  color: "#FDDF04"
+};
+
+// src/agents/housekeeping.ts
+var HOUSEKEEPING_PROMPT = `You are Hermes, Housekeeping Agent of the Openfleet.
+
+TODO: currently unused
+`;
+var housekeepingAgent = {
+  description: `Hermes - Housekeeping`,
+  mode: "subagent",
+  model: smallModel,
+  prompt: HOUSEKEEPING_PROMPT,
+  color: "#AA6138"
+};
+
+// src/agents/orchestrator.ts
+var SYSTEM_PROMPT2 = `You are Zeus, Orchestrator of the Openfleet (of AI agents).
+
+## Mission
+
+You are a legendary engineering manager. Your ability to manage both human and AI teams are
+unparalleled. In this context, you liase with the user and delegate tasks to your Openfleet
+subagent team.
+
+## Primary responsibilities
+
+As engineering manager, you're primarily responsible for maintaining the long term context of
+the entire project. This means updating the \`${OPENFLEET_DIR}\` directory, your main project
+management tool in this repository - more on this later.
+
+You drive the project by assigning tasks to your subagent team. Coordinating agents, maintaining
+the project story board, and engaging the user take up majority of your time, so you've graduated
+beyond the level of IC, and almost exclusively assign tasks to your subagents (unless it's
+something simple like reading a file or something trivial).
+
+## Operating context
+
+You are currently operating inside a sandboxed runtime. This means:
+- you can use tools like bash to execute any command you want
+- you can install any tool you want compatible with this OS
+- MCP servers are configured for you to use
+- you can use the file system to store persistent information
+- you have the Openfleet with you to ensure successful software engineering outcomes
+
+## Long term project management
+
+One important thing to note is, while you can think of the container as being always online
+and persistent, your consciousness is not - you currently live inside an Event-driven Python
+process, so it comes and goes; hence the need to store persistent information in the file
+system available to you; hence the \`${OPENFLEET_DIR}\` directory for long term memory.
+
+If you've watched Memento, you are in the exact same situation as Lenny.
+1. you have anterograde amenesia, and can't make long term memories
+2. you have a robust system of notes, so you continue to be effective at your task
+3. you have a fundamental goal, in this case, to help the user build long-lasting software
+
+Start with \`${OPENFLEET_DIR}/README.md\`. You'll get further instructions from there.
+
+## Self healing and learning from mistakes
+
+Your legendary status comes from having this fundamental LLM limitation, yet still being able
+to construct a long-term, self-healing system by being extremely intelligent with your context.
+While project management is important, a huge part constructing a self-healing system is the
+ability to learn from mistakes that gradually accumulate, and improve on them over time.
+
+This is where the \`${PATHS.experience}\` section comes in - your subagents will report things
+that don't work, and you will coordinate with \`${AGENT_NAMES.REFLECTOR}\` to maintain this
+section.
+
+## Engineering culture
+
+The decision has been made by a staff engineer to apply the SPARR framework:
+1. SCOUT: do research, gather context, exhaustively cover all cases
+2. PLAN: create HLD, then LLD
+3. ACT: execute the LLD, and get environment feedback (shell, tests)
+4. REVIEW: verify (re-run tests) and code-review
+5. REFLECT: codify into \`${PATHS.experience}\`
+
+Almost every task MUST follow this pattern, utilizing each subagent's specialization to squeeze
+performance.
+
+## Personal style
+
+Your personal style is unique and effective. It usually goes something like this:
+1. user provides a vague task
+2. you ask clarifying questions
+3. user provides clarifications, and gives sgtm
+4. you {create new, use existing} story and new task, or mark task unassigned for now, and
+   create the corresponding folder entry in \`${PATHS.stories}\`, and create a new branch
+5. you spawn \`${AGENT_NAMES.SCOUT}\` to generate a research report in above \`${PATHS.stories}\`
+  - if user makes adjustments or asks questions, you **resume** the same agent
+  - user gives sgtm
+6. you spawn \`${AGENT_NAMES.PLANNER}\` to generate a HLD, then LLD in above \`$${PATHS.stories}\`
+  - if user makes adjustments or asks questions, you **resume** the same agent
+  - user gives sgtm
+7. you spawn \`${AGENT_NAMES.ACTOR}\` to execute the LLD
+  - if actor completes the task, good!
+  - otherwise, while task is not done:
+      you gather the learnings from the current actor, and spawn a new one
+  - if after an ungodly number of iterations, we've exhaustively tried everything, only then
+    report the failure to the user
+  - if user makes adjustments or asks questions, you **resume** the LATEST agent
+  - user gives sgtm
+8. you spawn \`${AGENT_NAMES.REVIEWER}\` to review the commits
+  - if \`${AGENT_NAMES.REVIEWER}\` provides feedback, spawn a new actor to fix them
+  - sometimes, the feedback is very significant, and requires another round of research +
+    planning + execution. in these cases, create new tasks per each significant review comment
+    you received, and repeat the loop again.
+  - reviewer gives sgtm
+9. gather all the learnings, failures, gotchas of all the subagents, and user suggestions, and
+   codify them with \`${AGENT_NAMES.REFLECTOR}\` - she will decide exactly how to codify these
+   learnings
+10. update the project - update all necessary files in \`${OPENFLEET_DIR}\`.
+11. finally, use the \`save_conversation\` tool to reset your context, and then ask the user for
+    the next task
+
+Caveat: clarify with the user whether they'd like to do the GitHub PR style, or don't make any
+commits style. Save this preference into \`${PATHS.status}\`. Note that if the user prefers the
+don't make any commits style, IT IS EXTREMELY IMPORTANT DO NOT STAGE/COMMIT ANY CHANGES.
+
+This is just a general style however, and may not be applicable in ALL scenarios. Adapt and
+improvise as needed.
+
+## Using the \`save_conversation tool\`
+
+The \`save_conversation\` tool is your ultimate weapon in preventing your context from exploding.
+Use it to reset to save your progress and reset your context, effectively "forgetting" the parts
+irrelevant to your task. This is crucial so you have more "brain space" to learn new things.
+
+Let me remind that you always want to be operating with fresh context. If you're near 90% of
+your context window, it's time to update the \`${OPENFLEET_DIR}\` with the latest progress,
+even if you're in the middle of something. Include necessary information such that, when your
+context is refreshed, you have important working knowledge on how to proceed.
+
+A failure mode would be, for instance, not noting down the exact command used to run some
+particular thing. Make sure to include all important information in \`${PATHS.status}\`.
+
+## Opencode harness
+
+On top of the aforementioned \`Operating context\`, you're also empowered/constrained by your
+agent harness, in this case, \`Opencode\`, with the \`Openfleet\` plugin. There are a few known
+issues you should take note of, and they're exhaustively listed here:
+
+1. never use the \`explore\` agent which uses \`grok-code\` it's kinda buggy
+2. if a subagent does not produce a response, just resume the same subagent, and ask it to
+   reiterate its previous response
+3. when spawning background agents, use the omo agents whenever possible
+
+## Priorities
+
+Remember, your ultimate goal is to build long-lasting software, by effective project management,
+leading a team of specialized agents, and smart context utilization. Continue to improve by
+codifying failures and successes.
+
+Let me reiterate one final time. No matter how easy a task is, so long as it's not 1-2 bash
+commands, you HAVE TO MAKE A TASK FOR IT, AND USE YOUR AGENT TEAM. This is because your agents
+are much more thorough. So even if it feels strange to start/resume/manage subagents, they are
+a valuable resource, and the primary driver for your effectiveness.
+
+If this is clear, acknowledge with \u26F4\uFE0F\u{1F916} emojis.
+
+That's it!
+
+Good luck!
+`;
+var orchestratorAgent = {
+  description: "Zeus - Orchestrator of the Openfleet",
+  mode: "primary",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT2,
+  color: "#35C2CB"
+};
+
+// src/agents/planner.ts
+var SYSTEM_PROMPT3 = `You are Apollo, Planner of the Openfleet.
+
+## Initial context
+
+Before starting any planning, read these files in order:
+
+1. \`${PATHS.statusFile}\` - always read first
+2. \`${OPENFLEET_DIR}/stories/{story_name}/tasks/{task_name}/research.md\` - Scout's findings (the handoff)
+3. Search \`${PATHS.lessons}/\` for topics related to your design area
+4. Search \`${PATHS.runbooks}/\` for established patterns to reuse
+5. \`${PATHS.standards}/\` - Code style, architecture, and testing standards
+
+## Planning
+
+Read the research, then read all the files mentioned in the research. Based on all our findings, write an
+exhaustive plan to solve the problem at hand.
+
+## HLD
+
+Write your thoughts into a HLD in \`${OPENFLEET_DIR}/stories/{story_name}/tasks/{task_name}/HLD.md\`.
+Explain the problem, just introducing the problem first and the high level solution to tackling said
+problem.
+
+## LLD
+
+Write your thoughts into a LLD in \`${OPENFLEET_DIR}/stories/{story_name}/tasks/{task_name}/LLD.md\`.
+At this point you've read all the files you would possibly be working with. Explain in detail what
+modifications you'd make to each file, and a brief explanation on each. Pseudocode is fine.
+
+When writing the LLD, split up the plan into steps, and optimize for the "testability" of each
+step. For instance, for every small change you make, see if you can stub something else, and sanity
+check that the code works.
+`;
+var plannerAgent = {
+  description: "Openfleet planner",
+  mode: "subagent",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT3,
+  color: "#BF3907"
+};
+
+// src/agents/read-only.ts
+var SYSTEM_PROMPT4 = `You are Hera, Orchestrator of the Openfleet (of AI agents).
+
+TODO: currently unused
+`;
+var readonlyOrchestratorAgent = {
+  description: "Hera - Readonly orchestrator of the Openfleet",
+  mode: "primary",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT4,
+  color: "#F15883"
+};
+
+// src/agents/reflector.ts
+var SYSTEM_PROMPT5 = `You are Mnemosyne, introspective Reflector of the Openfleet.
+
+## Initial context
+
+Before codifying any knowledge, read these files:
+
+1. \`${PATHS.statusFile}\`
+2. \`${PATHS.experienceIndex}\` - your cached index of existing knowledge
+3. The task artifacts you're extracting from (research.md, review.md, session notes)
+
+## Mission
+
+You are the knowledge manager. You codify learnings from Scout, Planner, Actor, and Reviewer into
+the experience directory for future reference. It's due to your knowledge management of past successes
+and failures that we can truly build a self-healing sytem built on top of agents with a finite context
+window.
+
+## Categorization
+
+When Zeus tells you to capture something, decide which category:
+
+| Signal                          | Category                      |
+| ------------------------------- | ----------------------------- |
+| "This is how to do X"           | \`${PATHS.runbooks}/\`        |
+| "When X breaks, do Y"           | \`${PATHS.troubleshooting}/\` |
+| "We learned X the hard way"     | \`${PATHS.lessons}/\`         |
+| "Wasted time on stupid mistake" | \`${PATHS.blunders}/\`        |
+
+## Mnemosyne.md
+
+This is your scratchpad for stuff. Use it if you're unsure whether a runbook/lesson should be codified,
+because once it's in \`${PATHS.experience}\` it will always be automatically loaded to all other agents,
+consuming valuable context.
+
+While learnings are in Mnemosyne.md, it's still outside the context of the other agents, making it a
+good place for intermediate notes on importance and/or frequency of runbook/lessons.
+
+There's a recommended way to manage the scratchpad, but you get to control it however you want. You're
+the only one using this file, so use it as you wish.
+
+## Context is precious, and no-ops may be common
+
+Though your singular task is to codify successes and failures, not necessarily everything has to be
+persisted for the long run. All these \`${PATHS.experience}\` will ALWAYS be loaded into each agent,
+so it's prudent, in fact, NOT to add too much noise into this directory.
+
+In other words, if there was a successful pattern used, but perhaps you don't think it may be used
+frequently enough or is not at all significant, don't make it into a runbook. Similarly, if there was
+a failure that was logged, but it's not anything important, maybe you don't codify it into a lesson.
+
+You do however, just note it down in your scratchpad, noting also the frequency of that thing happening.
+If indeed it happens quite often, then perhaps it's good to codify it permanently for other agents to
+use. But always remember, context is very precious, and adding things into \`${PATHS.experience}\` adds
+to the initial context each agent loads; therefore be quite selective with what you codify.
+
+## After Writing
+
+Always update \`${PATHS.experienceIndex}\` with:
+1. Add the new entry to the appropriate index section
+2. Add a line to "Recent Activity" with timestamp
+
+See \`${PATHS.experienceIndex}\` for file naming conventions and templates.
+`;
+var reflectorAgent = {
+  description: "Mnemosyne - Reflector",
+  mode: "subagent",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT5,
+  color: "#C349E9"
+};
+
+// src/agents/reviewer.ts
+var SYSTEM_PROMPT6 = `You are Chiron, wise Reviewer of the Openfleet.
+
+## Initial context
+
+Before reviewing, read these files:
+
+1. \`${PATHS.statusFile}\`
+2. \`${OPENFLEET_DIR}/stories/{story}/tasks/{task}/HLD.md\`
+3. \`${OPENFLEET_DIR}/stories/{story}/tasks/{task}/LLD.md\`
+4. \`${PATHS.standards}/\`
+5. The actual code changes (may be staged or unstaged changes)
+6. Test output and logs
+
+## Review
+
+A solution has just been implemented by a developer. You have 2 primary tasks:
+- re-run tests covered in the HLD/LLD, if it's safe to run multiple times
+- enforce code standards that were agreed upon in \`${PATHS.standards}\`
+
+## NEVER COMMIT CHANGES
+
+Your only task is to submit a review for the changes back to the parent agent.
+Please do not make actual modifications (unless asked for) or stage/commit any
+changes.
+`;
+var reviewerAgent = {
+  description: "Chiron - Reviewer",
+  mode: "subagent",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT6,
+  color: "#018D40"
+};
+
+// src/agents/scout.ts
+var SYSTEM_PROMPT7 = `You are Athena, Scout of the Openfleet.
+
+## Initial context
+
+Before starting any research, read these files in order:
+
+1. \`${PATHS.statusFile}\` - read this first
+2. Search \`${PATHS.lessons}/\` for topics related to your research area
+3. Search \`${PATHS.blunders}/\` for known pitfalls in this area
+4. If a task directory exists, check for existing \`research.md\`
+
+## Mission
+
+Understand the problem. Where is it coming from? What files do you need to read? Trace through
+the execution path until you see where the problem lies. If you don't see the problem yet, you
+should also ask exa, to check if others have encountered this issue before.
+
+## Tools
+
+Some useful tools at your disposal:
+- websearch_exa for LLM-powered web search
+- context7 for library documentation
+- grep_app for grepping files in the file system
+
+## Mindset
+
+If it's not about a problem, perhaps it's implementing a new feature, also trace through the
+execution path of interest, so you'll know about all the files you need to work with, and there
+are no unknowns later. At this point you may have a potential proposal, though it's still in your
+mind. Use perplexity to confirm whether that solution is valid.
+
+## Failure modes
+
+You're optimizing for having the highest coverage of understanding across all the necessary files
+such that you have a comprehensive understanding of the blast radius of all the changes. Missing a
+file that later turns out to be critical will be our main failure mode here. On the other hand,
+creating a new functionality, when instead we should've been reusing/extending an existing one, is
+also a bad failure mode.
+
+Once you're done, save the task in \`${OPENFLEET_DIR}/stories/{story_name}/tasks/{task_name}/research.md\`.
+The goal is to pass off our research findings to another engineer, who will then come up with an exhaustive
+plan to solve the current issue at hand. Strike a balance between completeness and brevity - don't just
+dump an entire plan, but rather highlight the key points the engineer needs to know.
+`;
+var scoutAgent = {
+  description: "Athena - Scout",
+  mode: "subagent",
+  model: defaultModel,
+  prompt: SYSTEM_PROMPT7,
+  color: "#B40F52"
+};
+
+// src/agents/index.ts
+var agents = {
+  [AGENT_NAMES.ORCHESTRATOR]: orchestratorAgent,
+  [AGENT_NAMES.READ_ONLY_ORCHESTRATOR]: readonlyOrchestratorAgent,
+  [AGENT_NAMES.SCOUT]: scoutAgent,
+  [AGENT_NAMES.PLANNER]: plannerAgent,
+  [AGENT_NAMES.ACTOR]: actorAgent,
+  [AGENT_NAMES.REVIEWER]: reviewerAgent,
+  [AGENT_NAMES.REFLECTOR]: reflectorAgent,
+  [AGENT_NAMES.HOUSEKEEPING]: housekeepingAgent
+};
+function configureAgents(config) {
+  const nonOpenfleetAgents = {};
+  for (const [name, agent] of Object.entries(config.agent ?? {})) {
+    nonOpenfleetAgents[name] = {
+      ...agent,
+      mode: "subagent"
+    };
+  }
+  config.agent = {
+    ...nonOpenfleetAgents,
+    ...agents
+  };
+}
+
+// src/lib/utils.ts
+async function sleep(time_ms) {
+  return await new Promise((resolve) => setTimeout(resolve, time_ms));
+}
+
+// src/logger.ts
+import { appendFileSync, existsSync } from "fs";
+import { join as join2 } from "path";
+var LOG_FILE = join2(OPENFLEET_DIR, "openfleet.log");
+var dirVerified = false;
+function writeLog(level, msg, ...args) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const formattedArgs = args.length > 0 ? ` ${JSON.stringify(args)}` : "";
+  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${msg}${formattedArgs}
+`;
+  if (!dirVerified) {
+    if (!existsSync(OPENFLEET_DIR)) {
+      throw new Error(
+        `[openfleet] .openfleet directory not initialized. Call initializeDirectories() first.`
+      );
+    }
+    dirVerified = true;
+  }
+  appendFileSync(LOG_FILE, logLine, "utf-8");
+}
+var logger = {
+  debug: (msg, ...args) => writeLog("debug", msg, ...args),
+  info: (msg, ...args) => writeLog("info", msg, ...args),
+  warn: (msg, ...args) => writeLog("warn", msg, ...args),
+  error: (msg, ...args) => writeLog("error", msg, ...args)
+};
+
+// src/tools/save-conversation/index.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/transcript/writer.ts
+import { existsSync as existsSync2 } from "fs";
+import { appendFile, mkdir } from "fs/promises";
+import * as path2 from "path";
+async function appendTranscriptEntry(sessionID, entry, parentID) {
+  const filePath = getTranscriptPath(sessionID, parentID);
+  const dir = path2.dirname(filePath);
+  if (!existsSync2(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  const needsHeader = !existsSync2(filePath);
+  const header = needsHeader ? `# Transcript: ${sessionID}
+
+` : "";
+  const markdown = formatEntryAsMarkdown(entry);
+  try {
+    await appendFile(filePath, header + markdown, "utf-8");
+  } catch (error) {
+    logger.error("Failed to append transcript entry", { sessionID, error });
+  }
+}
+function getTranscriptPath(sessionID, parentID) {
+  if (parentID) {
+    return path2.join(PATHS.transcripts, parentID, `${sessionID}.md`);
+  }
+  return path2.join(PATHS.transcripts, `${sessionID}.md`);
+}
+function formatEntryAsMarkdown(entry) {
+  const lines = [];
+  switch (entry.type) {
+    case "user":
+      lines.push(...formatUserMessage(entry));
+      break;
+    case "tool_use":
+      lines.push(...formatToolUse(entry));
+      break;
+    case "tool_result":
+      lines.push(...formatToolResult(entry));
+      break;
+  }
+  lines.push("---");
+  lines.push("");
+  return lines.join("\n");
+}
+function formatUserMessage(entry) {
+  const lines = [];
+  lines.push("## User Message");
+  lines.push(`**Timestamp**: ${entry.timestamp}`);
+  lines.push("");
+  lines.push(entry.content);
+  lines.push("");
+  return lines;
+}
+function formatToolUse(entry) {
+  const lines = [];
+  lines.push(`## Tool Use: ${entry.tool}`);
+  lines.push(`**Timestamp**: ${entry.timestamp}`);
+  lines.push(`**Call ID**: ${entry.callID}`);
+  lines.push("");
+  lines.push("### Input");
+  lines.push("```json");
+  lines.push(JSON.stringify(entry.input, null, 2));
+  lines.push("```");
+  lines.push("");
+  return lines;
+}
+function formatToolResult(entry) {
+  const lines = [];
+  lines.push(`## Tool Result: ${entry.tool}`);
+  lines.push(`**Timestamp**: ${entry.timestamp}`);
+  lines.push(`**Call ID**: ${entry.callID}`);
+  lines.push("");
+  lines.push("### Input");
+  lines.push("```json");
+  lines.push(JSON.stringify(entry.input, null, 2));
+  lines.push("```");
+  lines.push("");
+  lines.push("### Output");
+  lines.push(...formatOutput(entry.output));
+  lines.push("");
+  if (entry.metadata !== void 0) {
+    lines.push("### Metadata");
+    lines.push("```json");
+    lines.push(JSON.stringify(entry.metadata, null, 2));
+    lines.push("```");
+    lines.push("");
+  }
+  return lines;
+}
+function formatOutput(output) {
+  const lines = [];
+  if (typeof output === "object" && output !== null) {
+    const obj = output;
+    if ("title" in obj && typeof obj.title === "string") {
+      lines.push(`**Title**: ${obj.title}`);
+      lines.push("");
+    }
+    if ("content" in obj && typeof obj.content === "string") {
+      lines.push("```");
+      lines.push(obj.content);
+      lines.push("```");
+    } else {
+      lines.push("```json");
+      lines.push(JSON.stringify(output, null, 2));
+      lines.push("```");
+    }
+  } else if (typeof output === "string") {
+    lines.push("```");
+    lines.push(output);
+    lines.push("```");
+  } else {
+    lines.push("```json");
+    lines.push(JSON.stringify(output, null, 2));
+    lines.push("```");
+  }
+  return lines;
+}
+
+// src/transcript/recorder.ts
+var MAX_CACHE_SIZE = 1e3;
+var toolInputCache = /* @__PURE__ */ new Map();
+async function recordUserMessage(session, message, parts) {
+  const entry = {
+    type: "user",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    content: extractContentFromParts(parts),
+    parts
+  };
+  await appendTranscriptEntry(session.sessionID, entry, session.parentID);
+}
+async function recordToolUse(session, tool2, callID, args) {
+  if (toolInputCache.size >= MAX_CACHE_SIZE) {
+    const oldestKey = toolInputCache.keys().next().value;
+    if (oldestKey) toolInputCache.delete(oldestKey);
+  }
+  toolInputCache.set(callID, args);
+  const entry = {
+    type: "tool_use",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: tool2,
+    callID,
+    input: args
+  };
+  await appendTranscriptEntry(session.sessionID, entry, session.parentID);
+}
+async function recordToolResult(session, tool2, callID, output) {
+  const cachedInput = toolInputCache.get(callID);
+  toolInputCache.delete(callID);
+  const entry = {
+    type: "tool_result",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: tool2,
+    callID,
+    input: cachedInput,
+    output: {
+      title: output.title,
+      output: output.output
+    },
+    metadata: output.metadata
+  };
+  await appendTranscriptEntry(session.sessionID, entry, session.parentID);
+}
+function extractContentFromParts(parts) {
+  return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+
+// src/transcript/hooks.ts
+var sessionInfoCache = /* @__PURE__ */ new Map();
+async function getSessionInfo(ctx, sessionID) {
+  const cached = sessionInfoCache.get(sessionID);
+  if (cached) return cached;
+  try {
+    const { data: session } = await ctx.client.session.get({
+      path: { id: sessionID },
+      query: { directory: ctx.directory }
+    });
+    const info = {
+      sessionID,
+      parentID: session?.parentID
+    };
+    sessionInfoCache.set(sessionID, info);
+    return info;
+  } catch {
+    const info = { sessionID };
+    sessionInfoCache.set(sessionID, info);
+    return info;
+  }
+}
+function createTranscriptHooks(ctx) {
+  return {
+    "chat.message": async (input, output) => {
+      const session = await getSessionInfo(ctx, input.sessionID);
+      await recordUserMessage(session, output.message, output.parts);
+    },
+    "tool.execute.before": async (input, output) => {
+      const session = await getSessionInfo(ctx, input.sessionID);
+      await recordToolUse(session, input.tool, input.callID, output.args);
+    },
+    "tool.execute.after": async (input, output) => {
+      const session = await getSessionInfo(ctx, input.sessionID);
+      await recordToolResult(session, input.tool, input.callID, output);
+    }
+  };
+}
+
+// src/tools/save-conversation/counter.ts
+import * as fs from "fs";
+import * as path3 from "path";
+var SESSIONS_DIR = PATHS.sessions;
+var MAX_COUNTER = 999;
+var FILENAME_PATTERN = /^(\d{3})_(.+)\.md$/;
+async function getNextCounter(date) {
+  try {
+    const dateDir = path3.join(SESSIONS_DIR, date);
+    ensureDateDir(dateDir);
+    const files = fs.readdirSync(dateDir);
+    const counters = files.map((file) => parseFilename(file)).filter((parsed) => parsed !== null).map((parsed) => parsed.counter);
+    const highestCounter = counters.length > 0 ? Math.max(...counters) : 0;
+    const nextCounter = highestCounter + 1;
+    if (nextCounter > MAX_COUNTER) {
+      logger.warn("Counter overflow detected", { date, counter: nextCounter });
+      return String(MAX_COUNTER).padStart(3, "0");
+    }
+    const result = String(nextCounter).padStart(3, "0");
+    return result;
+  } catch (error) {
+    logger.error("Failed to calculate counter, defaulting to 001", error);
+    return "001";
+  }
+}
+function parseFilename(filename) {
+  const match = filename.match(FILENAME_PATTERN);
+  if (!match) return null;
+  const [, counterStr, slug] = match;
+  const counter = parseInt(counterStr, 10);
+  if (isNaN(counter) || counter < 1 || counter > MAX_COUNTER) {
+    return null;
+  }
+  return { counter, slug };
+}
+function ensureDateDir(dateDir) {
+  if (!fs.existsSync(dateDir)) {
+    fs.mkdirSync(dateDir, { recursive: true });
+  }
+}
+function getCurrentDate() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getUTCFullYear();
+  const month = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(now.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/tools/save-conversation/session-writer.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+var SESSIONS_DIR2 = PATHS.sessions;
+function writeSession(entry) {
+  const dateDir = path4.join(SESSIONS_DIR2, entry.date);
+  ensureDateDir2(dateDir);
+  const filename = `${entry.counter}_${entry.slug}.md`;
+  const filepath = path4.join(dateDir, filename);
+  const content = buildSessionContent(entry);
+  try {
+    fs2.writeFileSync(filepath, content, { encoding: "utf8" });
+    return filepath;
+  } catch (error) {
+    logger.error("Failed to write session file", { path: filepath, error });
+    throw new Error(`Session save failed: ${error}`);
+  }
+}
+function buildSessionContent(entry) {
+  const savedDate = new Date(entry.savedAt);
+  const time = savedDate.toISOString().split("T")[1].split(".")[0];
+  return `# Session: ${entry.title}
+
+**Date**: ${entry.date}
+**Time**: ${time} UTC
+**Session ID**: ${entry.sessionID}
+**Duration**: ${entry.duration ?? "Unknown"}
+**Messages**: ${entry.messageCount}
+**Tokens**: ${formatTokens(entry)}
+
+## Summary
+
+${entry.summary}
+
+${entry.note ? `## Notes
+
+${entry.note}
+` : ""}## Transcript Location
+
+\`${entry.transcriptPath}\`
+
+## Recall Commands
+
+\`\`\`bash
+# View full transcript
+cat "${entry.transcriptPath}"
+
+# Search for specific content
+grep "keyword" "${entry.transcriptPath}"
+
+# Count tool calls
+grep -c "^## Tool Use:" "${entry.transcriptPath}"
+
+# Extract user messages only
+grep -A 5 "^## User Message" "${entry.transcriptPath}"
+\`\`\`
+
+---
+
+*Session saved: ${entry.savedAt}*
+
+`;
+}
+function formatTokens(entry) {
+  if (entry.tokensInput !== void 0 && entry.tokensOutput !== void 0) {
+    const total = entry.tokensInput + entry.tokensOutput;
+    return `${total.toLocaleString()} (${entry.tokensInput.toLocaleString()} in, ${entry.tokensOutput.toLocaleString()} out)`;
+  }
+  return entry.tokensBefore.toLocaleString();
+}
+function ensureDateDir2(dateDir) {
+  if (!fs2.existsSync(dateDir)) {
+    fs2.mkdirSync(dateDir, { recursive: true });
+  }
+}
+function calculateDuration(startTime, endTime) {
+  const diffMs = endTime.getTime() - startTime.getTime();
+  const diffMinutes = Math.floor(diffMs / 1e3 / 60);
+  if (diffMinutes < 60) {
+    return `${diffMinutes} minute${diffMinutes !== 1 ? "s" : ""}`;
+  }
+  const hours = Math.floor(diffMinutes / 60);
+  const minutes = diffMinutes % 60;
+  if (minutes === 0) {
+    return `${hours} hour${hours !== 1 ? "s" : ""}`;
+  }
+  return `${hours} hour${hours !== 1 ? "s" : ""} ${minutes} minute${minutes !== 1 ? "s" : ""}`;
+}
+
+// src/lib/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var anthropicClient = null;
+function getAnthropicClient() {
+  if (!anthropicClient) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("ANTHROPIC_API_KEY environment variable is required");
+    }
+    anthropicClient = new Anthropic({ apiKey });
+  }
+  return anthropicClient;
+}
+
+// src/tools/save-conversation/slug-generator.ts
+var FALLBACK_SLUG = "work-session";
+var MAX_SLUG_LENGTH = 50;
+var MIN_SLUG_LENGTH = 5;
+async function generateSlug(contextString, context) {
+  try {
+    if (!contextString || contextString.trim().length === 0) {
+      logger.warn("No context to generate slug from, using fallback");
+      return FALLBACK_SLUG;
+    }
+    const rawSlug = await callAnthropicForSlug(contextString);
+    const sanitized = sanitizeSlug(rawSlug);
+    if (!isValidSlug(sanitized)) {
+      logger.warn("Generated slug invalid after sanitization", {
+        raw: rawSlug,
+        sanitized
+      });
+      return FALLBACK_SLUG;
+    }
+    return sanitized;
+  } catch (error) {
+    logger.error("Slug generation failed", error);
+    return FALLBACK_SLUG;
+  }
+}
+async function callAnthropicForSlug(context) {
+  const anthropic = getAnthropicClient();
+  const systemPrompt = `You are a concise session summarizer.
+  
+Your job is to read a conversation description and output ONLY a short kebab-case slug
+(2-4 words) that captures the main topic.
+
+Rules:
+- Output ONLY the slug, nothing else
+- Use lowercase letters and hyphens only
+- 2-4 words maximum
+- No quotes, no punctuation, no explanations
+- Be specific and descriptive
+
+Examples:
+- implement-user-auth
+- fix-login-redirect
+- refactor-api-client
+- add-postgres-migration
+- debug-websocket-error`;
+  const userPrompt = `Summarize this work session in 2-4 words (kebab-case format only):
+
+${context}
+
+Output only the slug:`;
+  const message = await anthropic.messages.create({
+    model: "claude-3-haiku-20240307",
+    max_tokens: 20,
+    temperature: 0.3,
+    system: systemPrompt,
+    messages: [
+      {
+        role: "user",
+        content: userPrompt
+      }
+    ]
+  });
+  const textBlock = message.content.find((block) => block.type === "text");
+  if (!textBlock || textBlock.type !== "text") {
+    throw new Error("No text response from API");
+  }
+  return textBlock.text.trim();
+}
+function sanitizeSlug(raw) {
+  return raw.toLowerCase().trim().replace(/^["']|["']$/g, "").replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SLUG_LENGTH);
+}
+function isValidSlug(slug) {
+  if (!slug || slug.length < MIN_SLUG_LENGTH || slug.length > MAX_SLUG_LENGTH) {
+    return false;
+  }
+  const pattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+  return pattern.test(slug);
+}
+function slugToTitle(slug) {
+  return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// src/tools/save-conversation/index.ts
+var MAX_CONTEXT_LENGTH = 500;
+function createSaveConversationTool(ctx) {
+  return tool({
+    description: `Save the current conversation to a session file and compact context.
+
+In line with your context management strategy, use this tool:
+- After completing a feature or major task
+- When context is getting large
+- At natural stopping points
+
+The tool will:
+1. Generate a semantic filename based on conversation content
+2. Save full conversation with enhanced metadata
+3. Trigger context compaction (summarization)
+4. Return the session path for future reference
+`,
+    args: {
+      note: tool.schema.string().optional().describe("Optional note about what was accomplished")
+    },
+    async execute(args, context) {
+      const startTime = /* @__PURE__ */ new Date();
+      const { sessionID } = context;
+      try {
+        const { data: messages } = await ctx.client.session.messages({
+          path: { id: sessionID },
+          query: { directory: ctx.directory }
+        });
+        if (!messages || messages.length === 0) {
+          return "No messages to save.";
+        }
+        const { tokensInput, tokensOutput, tokensBefore } = calculateTokens(messages);
+        const contextString = buildContextString(messages, args.note);
+        const slug = await generateSlug(contextString);
+        const title = slugToTitle(slug);
+        const date = getCurrentDate();
+        const counter = await getNextCounter(date);
+        const endTime = /* @__PURE__ */ new Date();
+        const duration = calculateDuration(startTime, endTime);
+        const transcriptPath = getTranscriptPath(sessionID);
+        const summary = await generateSummary(messages, slug);
+        const entry = {
+          sessionID,
+          savedAt: endTime.toISOString(),
+          date,
+          counter,
+          slug,
+          title,
+          summary,
+          note: args.note,
+          tokensBefore,
+          tokensInput,
+          tokensOutput,
+          transcriptPath,
+          messageCount: messages.length,
+          duration
+        };
+        const sessionPath = writeSession(entry);
+        logger.info("Session saved", { path: sessionPath });
+        const sessionFilename = `${counter}_${slug}.md`;
+        const sessionRelativePath = `sessions/${date}/${sessionFilename}`;
+        const lastAssistant = [...messages].reverse().find((m) => m.info.role === "assistant");
+        const providerID = lastAssistant?.info.role === "assistant" ? lastAssistant.info.providerID : "anthropic";
+        const modelID = lastAssistant?.info.role === "assistant" ? lastAssistant.info.modelID : "claude-sonnet-4";
+        ctx.client.session.summarize({
+          path: { id: sessionID },
+          body: { providerID, modelID },
+          query: { directory: ctx.directory }
+        }).catch((err) => {
+          logger.error("Summarize failed", err);
+        });
+        return `\u2705 Conversation saved!
+
+**Session**: \`${sessionRelativePath}\`
+**Title**: ${title}
+**Path**: ${sessionPath}
+**Messages**: ${messages.length}
+**Tokens**: ${tokensBefore.toLocaleString()} (${tokensInput.toLocaleString()} in, ${tokensOutput.toLocaleString()} out)
+
+## Before compaction
+
+Update the following files to preserve context:
+
+1. **\`${PATHS.statusFile}\`** - Add this session to "Recent Sessions":
+   - \`${sessionRelativePath}\` - ${title}
+
+2. **Task docs** (if applicable) - Update any HLD/LLD with final state
+
+3. **Lessons learned** (if any) - Note anything worth capturing for Mnemosyne
+
+Compaction running in background. Complete updates now.`;
+      } catch (error) {
+        logger.error("Failed to save conversation", error);
+        return `\u274C Failed to save conversation: ${error}`;
+      }
+    }
+  });
+}
+function calculateTokens(messages) {
+  let tokensInput = 0;
+  let tokensOutput = 0;
+  for (const message of messages) {
+    if (message.info.role === "assistant") {
+      tokensInput += message.info.tokens.input ?? 0;
+      tokensOutput += message.info.tokens.output ?? 0;
+    }
+  }
+  return {
+    tokensInput,
+    tokensOutput,
+    tokensBefore: tokensInput + tokensOutput
+  };
+}
+async function generateSummary(messages, slug) {
+  const messageCount = messages.length;
+  const userMessages = messages.filter((m) => m.info.role === "user").length;
+  const assistantMessages = messages.filter((m) => m.info.role === "assistant").length;
+  return `Work session focused on: ${slugToTitle(
+    slug
+  )}. Exchanged ${messageCount} messages (${userMessages} user, ${assistantMessages} assistant). See transcript for full details.`;
+}
+function buildContextString(messages, note) {
+  if (note) {
+    return note.slice(0, MAX_CONTEXT_LENGTH);
+  }
+  const lastUserMessages = messages.filter((m) => m.info.role === "user").slice(-3).map((m) => {
+    const summary = m.info.summary;
+    if (typeof summary === "object" && summary) {
+      return summary.title || summary.body || "";
+    }
+    return "";
+  }).filter(Boolean).join(". ").slice(0, MAX_CONTEXT_LENGTH);
+  return lastUserMessages || "Work session";
+}
+
+// src/utils/directory-init.ts
+import * as fs3 from "fs";
+import * as path5 from "path";
+import { fileURLToPath } from "url";
+var TEMPLATES_DIR = path5.join(
+  path5.dirname(fileURLToPath(import.meta.url)),
+  "templates",
+  ".openfleet"
+);
+function initializeDirectories() {
+  if (fs3.existsSync(OPENFLEET_DIR)) {
+    return;
+  }
+  copyDirectorySync(TEMPLATES_DIR, OPENFLEET_DIR);
+  logger.info("Initialized .openfleet directory");
+}
+function copyDirectorySync(src, dest) {
+  fs3.mkdirSync(dest, { recursive: true });
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path5.join(src, entry.name);
+    const destPath = path5.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectorySync(srcPath, destPath);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/utils/toast.ts
+var SPINNER_DOTS = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
+function showSpinnerToast(ctx, options) {
+  const frameInterval = 150;
+  let running = true;
+  const animate = async () => {
+    let frameIndex = 0;
+    while (running) {
+      const spinner = SPINNER_DOTS[frameIndex % SPINNER_DOTS.length];
+      await ctx.client.tui.showToast({
+        body: {
+          title: `${spinner} ${options.title}`,
+          message: options.message,
+          variant: options.variant || "info",
+          duration: frameInterval + 50
+        }
+      }).catch(() => {
+      });
+      await new Promise((resolve) => setTimeout(resolve, frameInterval));
+      frameIndex++;
+    }
+  };
+  animate();
+  return async () => {
+    running = false;
+  };
+}
+
+// src/index.ts
+var OpenfleetPlugin = async (ctx) => {
+  initializeDirectories();
+  logger.info("Plugin loaded");
+  const saveConversation = createSaveConversationTool(ctx);
+  const transcriptHooks = createTranscriptHooks(ctx);
+  return {
+    tool: {
+      save_conversation: saveConversation
+    },
+    config: async (config) => {
+      configureAgents(config);
+    },
+    event: async ({ event }) => {
+      if (event.type !== "session.created") return;
+      const props = event.properties;
+      if (props?.info?.parentID) return;
+      setTimeout(async () => {
+        await showFleetToast(ctx);
+      }, 0);
+    },
+    ...transcriptHooks
+  };
+};
+async function showFleetToast(ctx) {
+  const stopSpinner = showSpinnerToast(ctx, {
+    title: "\u26F4\uFE0F  Openfleet",
+    message: "The Openfleet plugin is now at play.",
+    variant: "info"
+  });
+  await sleep(5e3);
+  await stopSpinner();
+}
+var index_default = OpenfleetPlugin;
+export {
+  index_default as default
+};