npm - @rubytech/taskmaster - Versions diffs - 1.0.38 → 1.0.40 - Mend

@rubytech/taskmaster 1.0.38 → 1.0.40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/auto-reply/reply/dispatch-from-config.js +53 -1
package/dist/auto-reply/reply/get-reply-run.js +2 -1
package/dist/browser/chrome.js +26 -3
package/dist/build-info.json +3 -3
package/dist/control-ui/assets/index-BfV0Mtl7.css +1 -0
package/dist/control-ui/assets/index-RlAacvDz.js +2944 -0
package/dist/control-ui/assets/index-RlAacvDz.js.map +1 -0
package/dist/control-ui/index.html +2 -2
package/dist/gateway/chat-sanitize.js +24 -7
package/dist/gateway/server-methods/chat.js +100 -26
package/dist/gateway/server-methods/memory.js +36 -0
package/dist/hooks/bundled/conversation-archive/handler.js +15 -2
package/dist/memory/hybrid.js +28 -1
package/dist/memory/internal.js +136 -47
package/dist/memory/manager.js +37 -3
package/dist/memory/memory-schema.js +18 -0
package/package.json +1 -1
package/taskmaster-docs/USER-GUIDE.md +51 -8
package/dist/control-ui/assets/index-B0Q2Wmm1.js +0 -2892
package/dist/control-ui/assets/index-B0Q2Wmm1.js.map +0 -1
package/dist/control-ui/assets/index-DkMDU6zX.css +0 -1

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-B0Q2Wmm1.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-DkMDU6zX.css">
+    <script type="module" crossorigin src="./assets/index-RlAacvDz.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-BfV0Mtl7.css">
   </head>
   <body>
     <taskmaster-app></taskmaster-app>

package/dist/gateway/chat-sanitize.js CHANGED Viewed

@@ -15,6 +15,9 @@ const ENVELOPE_CHANNELS = [
     "BlueBubbles",
 ];
 const MESSAGE_ID_LINE = /^\s*\[message_id:\s*[^\]]+\]\s*$/i;
+// Internal annotations prepended by buildInboundMediaNote / get-reply-run
+const MEDIA_ATTACHED_LINE = /^\s*\[media attached(?:\s+\d+\/\d+)?:\s*[^\]]+\]\s*$/i;
+const MEDIA_REPLY_HINT = /^\s*To send an image back, prefer the message tool\b/;
 function looksLikeEnvelopeHeader(header) {
     if (/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z\b/.test(header))
         return true;
@@ -23,13 +26,16 @@ function looksLikeEnvelopeHeader(header) {
     return ENVELOPE_CHANNELS.some((label) => header.startsWith(`${label} `));
 }
 export function stripEnvelope(text) {
-    const match = text.match(ENVELOPE_PREFIX);
-    if (!match)
-        return text;
-    const header = match[1] ?? "";
-    if (!looksLikeEnvelopeHeader(header))
-        return text;
-    return text.slice(match[0].length);
+    let result = text;
+    const match = result.match(ENVELOPE_PREFIX);
+    if (match) {
+        const header = match[1] ?? "";
+        if (looksLikeEnvelopeHeader(header)) {
+            result = result.slice(match[0].length);
+        }
+    }
+    result = stripMediaAnnotations(result);
+    return result;
 }
 function stripMessageIdHints(text) {
     if (!text.includes("[message_id:"))
@@ -38,6 +44,17 @@ function stripMessageIdHints(text) {
     const filtered = lines.filter((line) => !MESSAGE_ID_LINE.test(line));
     return filtered.length === lines.length ? text : filtered.join("\n");
 }
+function stripMediaAnnotations(text) {
+    if (!text.includes("[media attached"))
+        return text;
+    const lines = text.split(/\r?\n/);
+    const filtered = lines.filter((line) => !MEDIA_ATTACHED_LINE.test(line) && !MEDIA_REPLY_HINT.test(line));
+    if (filtered.length === lines.length)
+        return text;
+    // Also strip the "[media attached: N files]" header line
+    const result = filtered.filter((line) => !/^\s*\[media attached:\s*\d+\s+files?\]\s*$/i.test(line));
+    return result.join("\n").trim();
+}
 function stripEnvelopeFromContent(content) {
     let changed = false;
     const next = content.map((item) => {

package/dist/gateway/server-methods/chat.js CHANGED Viewed

@@ -10,9 +10,9 @@ import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
 import { createReplyDispatcher } from "../../auto-reply/reply/reply-dispatcher.js";
 import { extractShortModelName, } from "../../auto-reply/reply/response-prefix-template.js";
 import { resolveSendPolicy } from "../../sessions/send-policy.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
 import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
 import { abortChatRunById, abortChatRunsForSessionKey, isChatStopCommandText, resolveChatRunExpiresAtMs, } from "../chat-abort.js";
-import { parseMessageWithAttachments } from "../chat-attachments.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatInjectParams, validateChatSendParams, } from "../protocol/index.js";
 import { getMaxChatHistoryMessagesBytes } from "../server-constants.js";
 import { capArrayByJsonBytes, loadSessionEntry, readSessionMessages, resolveSessionModelRef, } from "../session-utils.js";
@@ -250,35 +250,74 @@ export const chatHandlers = {
         // Separate document attachments (PDFs, text files) from image attachments
         const imageAttachments = normalizedAttachments.filter((a) => a.type !== "document");
         const documentAttachments = normalizedAttachments.filter((a) => a.type === "document");
-        let parsedMessage = p.message;
-        let parsedImages = [];
-        if (imageAttachments.length > 0) {
-            try {
-                const parsed = await parseMessageWithAttachments(p.message, imageAttachments, {
-                    maxBytes: 5_000_000,
-                    log: context.logGateway,
-                });
-                parsedMessage = parsed.message;
-                parsedImages = parsed.images;
-            }
-            catch (err) {
-                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, String(err)));
-                return;
-            }
-        }
-        // Save document attachments to workspace uploads dir (persistent, accessible by agent)
-        const savedDocPaths = [];
-        if (documentAttachments.length > 0) {
+        // Resolve workspace uploads dir for all attachments (persistent, no TTL).
+        // Both images and documents are saved as plain files — same as every other channel.
+        let uploadsDir = null;
+        if (normalizedAttachments.length > 0) {
             const { cfg: sessionCfg } = loadSessionEntry(p.sessionKey);
             const agentId = resolveSessionAgentId({ sessionKey: p.sessionKey, config: sessionCfg });
             const workspaceDir = resolveAgentWorkspaceDir(sessionCfg, agentId);
-            const uploadsDir = path.join(workspaceDir, "uploads");
+            uploadsDir = path.join(workspaceDir, "uploads");
             try {
                 fs.mkdirSync(uploadsDir, { recursive: true });
             }
             catch {
                 /* ignore if exists */
             }
+        }
+        // Save image attachments to workspace uploads dir (persistent, accessible by agent).
+        // The agent runner detects file path references via [media attached: ...] and
+        // loads them from disk at inference time — no inline base64 in transcripts.
+        const savedImagePaths = [];
+        const savedImageTypes = [];
+        if (imageAttachments.length > 0 && uploadsDir) {
+            for (const att of imageAttachments) {
+                if (!att.content || typeof att.content !== "string")
+                    continue;
+                try {
+                    let b64 = att.content.trim();
+                    const dataUrlMatch = /^data:[^;]+;base64,(.*)$/.exec(b64);
+                    if (dataUrlMatch)
+                        b64 = dataUrlMatch[1];
+                    const buffer = Buffer.from(b64, "base64");
+                    // Derive extension from mime type
+                    const mimeBase = att.mimeType?.split(";")[0]?.trim();
+                    const extMap = {
+                        "image/jpeg": ".jpg",
+                        "image/png": ".png",
+                        "image/gif": ".gif",
+                        "image/webp": ".webp",
+                        "image/heic": ".heic",
+                        "image/heif": ".heif",
+                        "image/svg+xml": ".svg",
+                        "image/avif": ".avif",
+                    };
+                    const ext = (mimeBase && extMap[mimeBase]) ?? ".jpg";
+                    const uuid = randomUUID();
+                    let safeName;
+                    if (att.fileName) {
+                        const base = path
+                            .parse(att.fileName)
+                            .name.replace(/[^a-zA-Z0-9._-]/g, "_")
+                            .slice(0, 60);
+                        safeName = base ? `${base}---${uuid}${ext}` : `${uuid}${ext}`;
+                    }
+                    else {
+                        safeName = `${uuid}${ext}`;
+                    }
+                    const destPath = path.join(uploadsDir, safeName);
+                    fs.writeFileSync(destPath, buffer);
+                    savedImagePaths.push(destPath);
+                    savedImageTypes.push(mimeBase ?? "image/png");
+                }
+                catch (err) {
+                    context.logGateway.warn(`chat image save failed: ${String(err)}`);
+                }
+            }
+        }
+        // Save document attachments to workspace uploads dir (persistent, accessible by agent)
+        const savedDocPaths = [];
+        if (documentAttachments.length > 0 && uploadsDir) {
             for (const doc of documentAttachments) {
                 if (!doc.content || typeof doc.content !== "string")
                     continue;
@@ -354,14 +393,14 @@ export const chatHandlers = {
                 status: "started",
             };
             respond(true, ackPayload, undefined, { runId: clientRunId });
-            const trimmedMessage = parsedMessage.trim();
+            const trimmedMessage = p.message.trim();
             const injectThinking = Boolean(p.thinking && trimmedMessage && !trimmedMessage.startsWith("/"));
-            const commandBody = injectThinking ? `/think ${p.thinking} ${parsedMessage}` : parsedMessage;
+            const commandBody = injectThinking ? `/think ${p.thinking} ${p.message}` : p.message;
             // If documents were saved, prepend file paths to message so the agent knows about them
             const docNote = savedDocPaths.length > 0
                 ? savedDocPaths.map((p) => `[file: ${p}]`).join("\n") + "\n\n"
                 : "";
-            const messageWithDocs = docNote + parsedMessage;
+            const messageWithDocs = docNote + p.message;
             const clientInfo = client?.connect?.client;
             const ctx = {
                 Body: messageWithDocs,
@@ -379,11 +418,30 @@ export const chatHandlers = {
                 SenderId: clientInfo?.id,
                 SenderName: clientInfo?.displayName,
                 SenderUsername: clientInfo?.displayName,
+                // Image/media paths — same pattern as WhatsApp. buildInboundMediaNote()
+                // will generate [media attached: ...] annotations that the agent runner
+                // detects and loads from disk at inference time.
+                MediaPaths: savedImagePaths.length > 0 ? savedImagePaths : undefined,
+                MediaPath: savedImagePaths[0],
+                MediaTypes: savedImageTypes.length > 0 ? savedImageTypes : undefined,
+                MediaType: savedImageTypes[0],
             };
             const agentId = resolveSessionAgentId({
                 sessionKey: p.sessionKey,
                 config: cfg,
             });
+            // Fire message:inbound hook for conversation archiving.
+            // Include image paths so the archive references the attached media.
+            const imageNote = savedImagePaths.length > 0 ? savedImagePaths.map((ip) => `[image: ${ip}]`).join("\n") : "";
+            const archiveText = [p.message, imageNote].filter(Boolean).join("\n").trim();
+            void triggerInternalHook(createInternalHookEvent("message", "inbound", p.sessionKey, {
+                text: archiveText || undefined,
+                timestamp: now,
+                chatType: "direct",
+                agentId,
+                channel: "webchat",
+                cfg,
+            }));
             let prefixContext = {
                 identityName: resolveIdentityName(cfg, agentId),
             };
@@ -419,6 +477,7 @@ export const chatHandlers = {
                 },
             });
             let agentRunStarted = false;
+            context.logGateway.info(`webchat dispatch: sessionKey=${p.sessionKey} runId=${clientRunId} body=${messageWithDocs.length}ch images=${savedImagePaths.length} docs=${savedDocPaths.length}`);
             void dispatchInboundMessage({
                 ctx,
                 cfg,
@@ -426,10 +485,10 @@ export const chatHandlers = {
                 replyOptions: {
                     runId: clientRunId,
                     abortSignal: abortController.signal,
-                    images: parsedImages.length > 0 ? parsedImages : undefined,
                     disableBlockStreaming: true,
-                    onAgentRunStart: () => {
+                    onAgentRunStart: (runId) => {
                         agentRunStarted = true;
+                        context.logGateway.info(`webchat agent run started: sessionKey=${p.sessionKey} runId=${runId}`);
                     },
                     onModelSelected: (ctx) => {
                         prefixContext.provider = ctx.provider;
@@ -440,6 +499,8 @@ export const chatHandlers = {
                 },
             })
                 .then(() => {
+                const { entry: postEntry } = loadSessionEntry(p.sessionKey);
+                context.logGateway.info(`webchat dispatch done: sessionKey=${p.sessionKey} agentRunStarted=${agentRunStarted} sessionId=${postEntry?.sessionId ?? "none"} sessionFile=${postEntry?.sessionFile ?? "none"}`);
                 if (!agentRunStarted) {
                     const combinedReply = finalReplyParts
                         .map((part) => part.trim())
@@ -479,6 +540,18 @@ export const chatHandlers = {
                         message,
                     });
                 }
+                // Fire message:outbound hook for conversation archiving
+                const outboundText = finalReplyParts.join("\n\n").trim();
+                if (outboundText) {
+                    void triggerInternalHook(createInternalHookEvent("message", "outbound", p.sessionKey, {
+                        text: outboundText,
+                        timestamp: Date.now(),
+                        chatType: "direct",
+                        agentId,
+                        channel: "webchat",
+                        cfg,
+                    }));
+                }
                 context.dedupe.set(`chat:${clientRunId}`, {
                     ts: Date.now(),
                     ok: true,
@@ -486,6 +559,7 @@ export const chatHandlers = {
                 });
             })
                 .catch((err) => {
+                context.logGateway.warn(`webchat dispatch failed: sessionKey=${p.sessionKey} runId=${clientRunId} error=${formatForLog(err)}`);
                 const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
                 context.dedupe.set(`chat:${clientRunId}`, {
                     ts: Date.now(),

package/dist/gateway/server-methods/memory.js CHANGED Viewed

@@ -74,6 +74,42 @@ export const memoryHandlers = {
             respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
         }
     },
+    "memory.search": async ({ params, respond }) => {
+        const query = typeof params.query === "string" ? params.query.trim() : "";
+        if (!query) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "query is required"));
+            return;
+        }
+        const cfg = loadConfig();
+        const agentId = typeof params.agentId === "string" && params.agentId.trim()
+            ? params.agentId.trim()
+            : resolveDefaultAgentId(cfg);
+        const { manager, error } = await getMemorySearchManager({ cfg, agentId });
+        if (!manager) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, error ?? "memory index unavailable"));
+            return;
+        }
+        try {
+            const maxResults = typeof params.maxResults === "number" ? params.maxResults : 10;
+            // minScore: 0 — show all results for diagnostic purposes
+            const results = await manager.search(query, { maxResults, minScore: 0 });
+            respond(true, {
+                ok: true,
+                agentId,
+                results: results.map((r) => ({
+                    path: r.path,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    score: r.score,
+                    snippet: r.snippet,
+                    source: r.source,
+                })),
+            });
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, String(err)));
+        }
+    },
     "memory.auditClear": async ({ params, respond }) => {
         try {
             const cfg = loadConfig();

package/dist/hooks/bundled/conversation-archive/handler.js CHANGED Viewed

@@ -31,6 +31,13 @@ function extractPeerFromSessionKey(sessionKey) {
     }
     return null;
 }
+/**
+ * Detect webchat session key format: agent:{agentId}:main
+ */
+function isWebchatSessionKey(sessionKey) {
+    const parts = sessionKey.toLowerCase().split(":").filter(Boolean);
+    return parts.length === 3 && parts[0] === "agent" && parts[2] === "main";
+}
 /**
  * Extract group ID from session key
  *
@@ -148,9 +155,10 @@ const archiveConversation = async (event) => {
         }
         // Get timestamp from context or event
         const timestamp = context.timestamp ?? event.timestamp;
-        // Try DM first, then group
+        // Determine conversation type from session key and route to correct archive path
         const peer = extractPeerFromSessionKey(event.sessionKey);
         const groupId = peer ? null : extractGroupIdFromSessionKey(event.sessionKey);
+        const isWebchat = !peer && !groupId && isWebchatSessionKey(event.sessionKey);
         if (peer) {
             // Admin DMs archive to memory/admin/conversations/ (not accessible by public agent).
             // Public DMs archive to memory/users/{peer}/conversations/.
@@ -187,8 +195,13 @@ const archiveConversation = async (event) => {
                 fileHeader,
             });
         }
+        else if (isWebchat) {
+            // Webchat (control panel) — archive under memory/admin/conversations/
+            const role = event.action === "inbound" ? "Admin" : "Assistant";
+            await archiveMessage({ workspaceDir, subdir: "admin", role, text, timestamp });
+        }
         else {
-            // Neither DM nor group — skip
+            // Unknown session key format — skip
             return;
         }
     }

package/dist/memory/hybrid.js CHANGED Viewed

@@ -12,6 +12,32 @@ export function bm25RankToScore(rank) {
     const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
     return 1 / (1 + normalized);
 }
+/**
+ * Path-based boost factors applied during hybrid merge.
+ * Curated knowledge (public/, shared/, root memory files) is boosted over
+ * raw logs (conversations/, session transcripts) so authoritative content
+ * outranks casual mentions at similar raw scores.
+ *
+ * Patterns are checked in order — first match wins.
+ */
+const PATH_BOOST_RULES = [
+    // Conversation archives — demote (high volume, low signal-to-noise)
+    { pattern: /\/conversations\//, boost: 0.6 },
+    // Session source transcripts — demote
+    { pattern: /^sessions\//, boost: 0.6 },
+    // Curated public/shared knowledge — boost
+    { pattern: /^memory\/public\//, boost: 1.4 },
+    { pattern: /^memory\/shared\//, boost: 1.3 },
+    // Root memory files (MEMORY.md etc.) — slight boost
+    { pattern: /^(?:MEMORY|memory)\.md$/, boost: 1.2 },
+];
+function pathBoost(filePath) {
+    for (const rule of PATH_BOOST_RULES) {
+        if (rule.pattern.test(filePath))
+            return rule.boost;
+    }
+    return 1.0;
+}
 export function mergeHybridResults(params) {
     const byId = new Map();
     for (const r of params.vector) {
@@ -47,7 +73,8 @@ export function mergeHybridResults(params) {
         }
     }
     const merged = Array.from(byId.values()).map((entry) => {
-        const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        const raw = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        const score = raw * pathBoost(entry.path);
         return {
             path: entry.path,
             startLine: entry.startLine,

package/dist/memory/internal.js CHANGED Viewed

@@ -89,77 +89,166 @@ export async function buildFileEntry(absPath, workspaceDir) {
         hash,
     };
 }
-export function chunkMarkdown(content, chunking) {
-    const lines = content.split("\n");
-    if (lines.length === 0)
+/**
+ * Heading level (1-6) parsed from a markdown heading line, or 0 if not a heading.
+ */
+function headingLevel(line) {
+    const match = line.match(/^(#{1,6})\s/);
+    return match ? match[1].length : 0;
+}
+/**
+ * Build a heading breadcrumb prefix from the current heading stack.
+ * E.g., ["# User Guide", "## Updating Taskmaster"] → "# User Guide > ## Updating Taskmaster"
+ */
+function headingPrefix(stack) {
+    const filtered = stack.filter(Boolean);
+    return filtered.length > 0 ? filtered.join(" > ") + "\n" : "";
+}
+/**
+ * Split lines into fixed-size chunks (the original algorithm).
+ * Used as a fallback when a single section exceeds maxChars.
+ */
+function chunkLinesFixed(entries, maxChars, prefix) {
+    if (entries.length === 0)
         return [];
-    const maxChars = Math.max(32, chunking.tokens * 4);
-    const overlapChars = Math.max(0, chunking.overlap * 4);
+    const prefixLen = prefix.length;
+    const effectiveMax = Math.max(32, maxChars - prefixLen);
     const chunks = [];
     let current = [];
     let currentChars = 0;
     const flush = () => {
         if (current.length === 0)
             return;
-        const firstEntry = current[0];
-        const lastEntry = current[current.length - 1];
-        if (!firstEntry || !lastEntry)
-            return;
-        const text = current.map((entry) => entry.line).join("\n");
-        const startLine = firstEntry.lineNo;
-        const endLine = lastEntry.lineNo;
+        const first = current[0];
+        const last = current[current.length - 1];
+        const body = current.map((e) => e.line).join("\n");
+        const text = prefix + body;
         chunks.push({
-            startLine,
-            endLine,
+            startLine: first.lineNo,
+            endLine: last.lineNo,
             text,
             hash: hashText(text),
         });
     };
-    const carryOverlap = () => {
-        if (overlapChars <= 0 || current.length === 0) {
-            current = [];
-            currentChars = 0;
-            return;
-        }
-        let acc = 0;
-        const kept = [];
-        for (let i = current.length - 1; i >= 0; i -= 1) {
-            const entry = current[i];
-            if (!entry)
-                continue;
-            acc += entry.line.length + 1;
-            kept.unshift(entry);
-            if (acc >= overlapChars)
-                break;
-        }
-        current = kept;
-        currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
-    };
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i] ?? "";
-        const lineNo = i + 1;
+    for (const entry of entries) {
+        // Split overly long lines into segments that fit within effectiveMax
         const segments = [];
-        if (line.length === 0) {
-            segments.push("");
+        if (entry.line.length === 0) {
+            segments.push(entry);
         }
         else {
-            for (let start = 0; start < line.length; start += maxChars) {
-                segments.push(line.slice(start, start + maxChars));
+            for (let start = 0; start < entry.line.length; start += effectiveMax) {
+                segments.push({
+                    line: entry.line.slice(start, start + effectiveMax),
+                    lineNo: entry.lineNo,
+                });
             }
         }
-        for (const segment of segments) {
-            const lineSize = segment.length + 1;
-            if (currentChars + lineSize > maxChars && current.length > 0) {
+        for (const seg of segments) {
+            const segSize = seg.line.length + 1;
+            if (currentChars + segSize > effectiveMax && current.length > 0) {
                 flush();
-                carryOverlap();
+                current = [];
+                currentChars = 0;
             }
-            current.push({ line: segment, lineNo });
-            currentChars += lineSize;
+            current.push(seg);
+            currentChars += segSize;
         }
     }
     flush();
     return chunks;
 }
+/**
+ * Semantic markdown chunker.
+ *
+ * Splits content at markdown headings so each chunk corresponds to a logical section.
+ * Each chunk is prefixed with the heading breadcrumb (ancestor headings) so the embedding
+ * model has structural context — e.g., "# User Guide > ## Updating Taskmaster\n...content...".
+ *
+ * If a section exceeds maxChars, it falls back to fixed-size splitting within that section,
+ * but each sub-chunk still receives the heading prefix.
+ *
+ * Files with no headings are chunked using fixed-size splitting (original behavior).
+ */
+export function chunkMarkdown(content, chunking) {
+    if (!content.trim())
+        return [];
+    const lines = content.split("\n");
+    const maxChars = Math.max(32, chunking.tokens * 4);
+    // Parse all lines to detect if there are any headings
+    const parsedLines = [];
+    let hasHeadings = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const level = headingLevel(line);
+        if (level > 0)
+            hasHeadings = true;
+        parsedLines.push({ line, lineNo: i + 1, level });
+    }
+    // No headings at all — fall back to fixed-size chunking (no prefix)
+    if (!hasHeadings) {
+        return chunkLinesFixed(parsedLines.map((p) => ({ line: p.line, lineNo: p.lineNo })), maxChars, "");
+    }
+    const sections = [];
+    // headingStack tracks the current heading hierarchy: index = level-1
+    const headingStack = [];
+    let currentSection = { headingStack: [], lines: [] };
+    for (const parsed of parsedLines) {
+        if (parsed.level > 0) {
+            // Flush the previous section if it has content
+            if (currentSection.lines.length > 0) {
+                sections.push(currentSection);
+            }
+            // Update the heading stack: trim to this level, then set this heading.
+            // Use splice to avoid sparse arrays (setting .length on a shorter array
+            // leaves undefined holes when the heading appears without ancestors).
+            if (headingStack.length >= parsed.level) {
+                headingStack.length = parsed.level - 1;
+            }
+            headingStack[parsed.level - 1] = parsed.line;
+            // Start a new section with the current heading stack as context
+            currentSection = {
+                headingStack: [...headingStack],
+                lines: [{ line: parsed.line, lineNo: parsed.lineNo }],
+            };
+        }
+        else {
+            currentSection.lines.push({ line: parsed.line, lineNo: parsed.lineNo });
+        }
+    }
+    // Flush final section
+    if (currentSection.lines.length > 0) {
+        sections.push(currentSection);
+    }
+    // Convert sections to chunks
+    const chunks = [];
+    for (const section of sections) {
+        // Build the prefix from ancestor headings (all except the current heading,
+        // which is already the first line of the section body)
+        const ancestors = section.headingStack.slice(0, -1);
+        const prefix = headingPrefix(ancestors);
+        const bodyText = section.lines.map((e) => e.line).join("\n");
+        const totalLen = prefix.length + bodyText.length;
+        if (totalLen <= maxChars) {
+            // Section fits in one chunk
+            const first = section.lines[0];
+            const last = section.lines[section.lines.length - 1];
+            const text = prefix + bodyText;
+            chunks.push({
+                startLine: first.lineNo,
+                endLine: last.lineNo,
+                text,
+                hash: hashText(text),
+            });
+        }
+        else {
+            // Section too large — split with fixed-size chunking, each sub-chunk gets prefix
+            const subChunks = chunkLinesFixed(section.lines, maxChars, prefix);
+            chunks.push(...subChunks);
+        }
+    }
+    return chunks;
+}
 export function parseEmbedding(raw) {
     try {
         const parsed = JSON.parse(raw);