akm-cli 0.10.261008-beta → 0.10.261010-beta

package/dist/commands/ui/workspace-actions.js

@@ -0,0 +1,264 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { execFile } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
+import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { getConfigValueSource, loadConfig, mutateConfig, resetConfigCache, sanitizeConfigForWrite, } from "../../core/config/config.js";
+import { AkmError, UsageError } from "../../core/errors.js";
+import { appendEvent } from "../../core/events.js";
+import { resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
+import { setConfigValue, unsetConfigValue } from "../config-cli.js";
+import { writeMarkdownAsset } from "../read/knowledge.js";
+import { readDocumentSource } from "./document-source.js";
+import { assertWriteLeaseFree, classifyProposalError } from "./proposal-actions.js";
+import { redactForUi, redactUrlsInText } from "./redact.js";
+const ROUTES = {
+    "/api/feedback": "feedback",
+    "/api/bundles/add": "bundle-add",
+    "/api/bundles/remove": "bundle-remove",
+    "/api/bundles/update": "bundle-update",
+    "/api/bundles/settings": "bundle-settings",
+    "/api/knowledge/create": "knowledge-create",
+    "/api/asset/save": "document-save",
+};
+export function matchWorkspaceAction(path) {
+    return ROUTES[path] ?? null;
+}
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new UsageError("A JSON object is required.");
+    return value;
+}
+function text(body, key) {
+    const value = body[key];
+    if (typeof value !== "string" || !value.trim())
+        throw new UsageError(`${key} is required.`);
+    return value.trim();
+}
+function positional(body, key) {
+    const value = text(body, key);
+    if (value.startsWith("-"))
+        throw new UsageError(`${key} must be a target, not a command option. Use ./ for a relative path beginning with a dash.`);
+    return value;
+}
+function preserveUnrelatedConfig(config = loadConfig()) {
+    if (!isDeepStrictEqual(sanitizeConfigForWrite(config, { quiet: true }), config)) {
+        throw new UsageError("AKM's config sanitizer would remove unrelated credentials. Move literal API keys to $VAR or secret:// references and remove registry URL credentials using the CLI before changing bundle configuration in the UI.");
+    }
+}
+/** The error kind behind each exit code of the CLI contract (`EXIT_CODES`, `src/cli/shared.ts`). */
+const KIND_BY_EXIT = { 1: "not-found", 2: "usage", 75: "transient", 78: "config" };
+/** Preserve the CLI's error identity while crossing a process boundary. */
+class CommandError extends AkmError {
+    code;
+    kind;
+    /** Exit 70, a signal or a failed spawn: akm itself failed, not the request. */
+    internal;
+    constructor(message, code, exitCode) {
+        super(message);
+        this.code = code;
+        const kind = typeof exitCode === "number" ? KIND_BY_EXIT[exitCode] : undefined;
+        this.internal = kind === undefined;
+        this.kind = kind ?? "config";
+    }
+    hint() {
+        return undefined;
+    }
+}
+/** Exit zero is not sufficient evidence that the expected action returned a valid result. */
+export function parseCommandResponse(stdout, expectedShape) {
+    try {
+        const result = JSON.parse(stdout);
+        if (!result ||
+            typeof result !== "object" ||
+            Array.isArray(result) ||
+            result.shape !== expectedShape ||
+            !Number.isInteger(result.schemaVersion) ||
+            result.ok === false)
+            throw new Error("Invalid command envelope");
+        return redactForUi(result);
+    }
+    catch {
+        throw new CommandError("AKM returned an invalid action response. State may already have changed. Reload the view before retrying; do not automatically repeat the action.", "INVALID_COMMAND_RESPONSE", 70);
+    }
+}
+/**
+ * HTTP status and code for a failed workspace action. A config refusal (a
+ * read-only bundle, exit 78) is something the user can address: `409`. Exit 70
+ * and anything unclassified stay `500`; the rest map as for proposal decisions.
+ */
+export function classifyWorkspaceError(error) {
+    if (error instanceof CommandError && error.internal)
+        return { status: 500, code: error.code, message: error.message };
+    const classified = classifyProposalError(error);
+    return error instanceof AkmError && error.kind === "config" ? { ...classified, status: 409 } : classified;
+}
+/** Fixed UI actions use the real CLI, including feedback's argv-dependent tag validation and bundle install audits. */
+async function command(args, input, userFeedback = false) {
+    const [bin, ...prefix] = resolveAkmInvocation().argv;
+    // Options go before a `--` that ends them, so a positional name may begin with a dash.
+    const end = args.indexOf("--");
+    const argv = end === -1 ? [...args, "--format=json"] : [...args.slice(0, end), "--format=json", ...args.slice(end)];
+    return new Promise((resolve, reject) => {
+        const child = execFile(bin, [...prefix, ...argv], {
+            encoding: "utf8",
+            maxBuffer: 16 * 1024 * 1024,
+            // An ambient event source (an improve or task run) wins, as for every akm child.
+            ...(userFeedback ? { env: { ...process.env, AKM_EVENT_SOURCE: process.env.AKM_EVENT_SOURCE || "user" } } : {}),
+        }, (error, stdout, stderr) => {
+            resetConfigCache();
+            if (error) {
+                const json = stderr.slice(stderr.lastIndexOf("\n{") + 1).trim();
+                let detail = {};
+                try {
+                    detail = JSON.parse(json);
+                }
+                catch {
+                    /* Keep the command's readable error. */
+                }
+                reject(new CommandError(redactUrlsInText(detail.error ?? (stderr.trim() || error.message)), detail.code ?? "COMMAND_FAILED", error.code));
+                return;
+            }
+            try {
+                resolve(parseCommandResponse(stdout, args[0] === "bundle" ? args[1] : args[0]));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        // Argument validation can close the child before a Markdown body finishes writing.
+        child.stdin?.on("error", (error) => {
+            if (error.code !== "EPIPE")
+                reject(error);
+        });
+        child.stdin?.end(input);
+    });
+}
+function settings(body) {
+    const result = mutateConfig((current) => {
+        let updated = current;
+        if (body.bundle !== undefined) {
+            const name = text(body, "bundle");
+            const entry = current.bundles?.[name];
+            if (!entry || !Object.hasOwn(current.bundles ?? {}, name))
+                throw new UsageError(`No configured bundle named "${name}".`);
+            for (const key of ["enabled", "writable"]) {
+                if (body[key] === undefined)
+                    continue;
+                if (typeof body[key] !== "boolean")
+                    throw new UsageError(`${key} must be a boolean.`);
+                updated = setConfigValue(updated, `bundles.${name}.${key}`, String(body[key]));
+            }
+            if (body.componentWritability !== undefined) {
+                for (const [id, writable] of Object.entries(object(body.componentWritability))) {
+                    if (!Object.hasOwn(entry.components ?? {}, id) || id.includes(".") || typeof writable !== "boolean") {
+                        throw new UsageError("Only existing components with a boolean writable value can be changed.");
+                    }
+                    updated = setConfigValue(updated, `bundles.${name}.components.${id}.writable`, String(writable));
+                }
+            }
+        }
+        for (const key of ["defaultBundle", "defaultWriteTarget"]) {
+            if (body[key] === undefined)
+                continue;
+            if (typeof body[key] !== "string")
+                throw new UsageError(`${key} must be a bundle name or empty.`);
+            const name = body[key].trim();
+            if (name && !Object.hasOwn(current.bundles ?? {}, name))
+                throw new UsageError(`No configured bundle named "${name}".`);
+            const source = name ? "" : getConfigValueSource(key);
+            if (source.startsWith("extends:"))
+                throw new UsageError(`Config key "${key}" is inherited from ${source} and cannot be unset here.`, "TARGET_NOT_UPDATABLE", `Override it locally with "akm config set ${key} <value>", or edit the base file directly.`);
+            updated = name ? setConfigValue(updated, key, name) : unsetConfigValue(updated, key);
+        }
+        // Only a write can drop credentials, so a request that changes nothing is never refused.
+        if (updated !== current)
+            preserveUnrelatedConfig(current);
+        return updated;
+    });
+    return { saved: result.written };
+}
+export async function handleWorkspaceAction(action, value) {
+    const body = object(value);
+    // `bundle update` writes only the lockfile, so it never passes config through the sanitizer.
+    if (action === "bundle-add" || action === "bundle-remove")
+        preserveUnrelatedConfig();
+    switch (action) {
+        case "feedback": {
+            const signal = text(body, "signal");
+            if (signal !== "positive" && signal !== "negative")
+                throw new UsageError("signal must be positive or negative.");
+            const args = ["feedback", positional(body, "ref"), `--${signal}`];
+            if (typeof body.reason === "string" && body.reason.trim())
+                args.push(`--reason=${body.reason.trim()}`);
+            if (body.tags !== undefined) {
+                if (!Array.isArray(body.tags) || body.tags.some((tag) => typeof tag !== "string"))
+                    throw new UsageError("tags must be strings.");
+                for (const tag of body.tags)
+                    args.push(`--tag=${tag}`);
+            }
+            return command(args, undefined, true);
+        }
+        case "bundle-add": {
+            const args = ["bundle", "add", positional(body, "source")];
+            if (typeof body.name === "string" && body.name.trim())
+                args.push(`--name=${body.name.trim()}`);
+            if (body.writable === true)
+                args.push("--writable");
+            return command(args);
+        }
+        case "bundle-remove": {
+            if (body.confirm !== true)
+                throw new UsageError("Confirm removal of this configured bundle first.");
+            const name = text(body, "bundle");
+            if (!Object.hasOwn(loadConfig().bundles ?? {}, name))
+                throw new UsageError(`No configured bundle named "${name}".`);
+            return command(["bundle", "remove", "--yes", "--", name]);
+        }
+        case "bundle-update": {
+            const name = text(body, "bundle");
+            if (!Object.hasOwn(loadConfig().bundles ?? {}, name))
+                throw new UsageError(`No configured bundle named "${name}".`);
+            return command(["bundle", "update", "--", name]);
+        }
+        case "bundle-settings":
+            return settings(body);
+        case "document-save": {
+            if (typeof body.content !== "string")
+                throw new UsageError("Markdown content is required.");
+            const content = body.content;
+            const revision = text(body, "revision");
+            const ref = text(body, "ref");
+            await assertWriteLeaseFree("ui-document-save");
+            // The writer takes the lease and compares `revision` with the live bytes inside it.
+            const source = await readDocumentSource(ref);
+            const identity = parseRefInput(source.ref);
+            const result = await writeMarkdownAsset({
+                type: source.type,
+                content,
+                name: identity.name,
+                fallbackPrefix: source.type,
+                target: identity.origin,
+                force: true,
+                expectedContentHash: revision,
+            });
+            if (!result.unchanged)
+                appendEvent({
+                    eventType: source.type === "knowledge" ? "import" : "remember",
+                    ref: result.ref,
+                    metadata: { source: "ui", path: result.path, force: true },
+                });
+            return result;
+        }
+        case "knowledge-create": {
+            if (typeof body.content !== "string" || !body.content.trim())
+                throw new UsageError("Document content is required.");
+            const args = ["import", "-", `--name=${text(body, "name")}`, `--bundle=${text(body, "bundle")}`];
+            if (typeof body.path === "string" && body.path.trim())
+                args.push(`--path=${body.path.trim()}`);
+            await assertWriteLeaseFree("ui-knowledge-create");
+            return command(args, body.content);
+        }
+    }
+}

package/dist/commands/workflow-cli.js

@@ -77,7 +77,9 @@ const workflowStatusCommand = defineJsonCommand({
 const workflowListCommand = defineJsonCommand({
     meta: {
         name: "list",
-        description: "List workflow runs in the current working scope",
+        description: "List workflow runs in the current working scope. A scheduled task runs from the scheduler's cwd, so its runs " +
+            "sit in another scope: get the run id from `akm task history <task-id> --limit 1` (detail.runId) and pass it " +
+            "to `akm workflow status <run-id>`, which works from any directory, or pass --all-scopes.",
     },
     args: {
         ref: { type: "string", description: "Filter to one workflow ref" },

package/dist/core/adapter/adapters/akm-adapter.js

@@ -192,6 +192,7 @@ const DOCUMENT_JSON_CARRIED_FIELDS = [
     "wikiRole",
     "sources",
     "evidenceSources",
+    "evidence",
     // #935: a workflow's step targets and a task's target, read as declared links.
     "uses",
     // D2 (#730): the OKF v0.2 provenance `promoteProposal` stamps onto AKM-native

package/dist/core/adapter/adapters/llm-wiki-adapter.js

@@ -73,6 +73,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { parseFrontmatter, parseFrontmatterBlock } from "../../asset/frontmatter.js";
+import { markdownLinkTargets } from "../../asset/markdown-link-targets.js";
 import { toPosix } from "../../common.js";
 import { hashContent, nonEmptyString } from "./shared.js";
 /** A wiki is a single-component bundle; its one component is conventionally `main` (recognition golden). */
@@ -169,13 +170,10 @@ function resolveXref(xref, bundleId) {
  */
 function resolveBodyLinks(body, fileRelPath) {
     const dir = path.posix.dirname(toPosix(fileRelPath));
-    const linkRe = /\[[^\]]*\]\(([^)]+)\)/g;
     const out = [];
     const seen = new Set();
-    let match;
-    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex loop
-    while ((match = linkRe.exec(body)) !== null) {
-        let target = match[1].trim();
+    for (const link of markdownLinkTargets(body, false)) {
+        let target = link.trim();
         const wsIdx = target.search(/\s/);
         if (wsIdx >= 0)
             target = target.slice(0, wsIdx);

package/dist/core/adapter/adapters/okf-adapter.js

@@ -31,6 +31,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseFrontmatter } from "../../asset/frontmatter.js";
+import { markdownLinkTargets } from "../../asset/markdown-link-targets.js";
 import { isRecord, toPosix } from "../../common.js";
 import { hashContent, nonEmptyString, RESERVED_FILES, readTags, runBaseValidateChecks } from "./shared.js";
 /** v0.2 frontmatter keys consumed into first-class fields below (§0.1) — excluded from the generic `documentJson` extras fold alongside the v0.1 five, so nothing is duplicated between a first-class field and the opaque extras bag. */
@@ -142,24 +143,10 @@ function isReservedFileName(name) {
  */
 export function resolveOkfLinks(body, fileRelPath) {
     const dir = path.posix.dirname(toPosix(fileRelPath));
-    const definitions = new Map();
-    for (const match of body.matchAll(/^\s*\[([^\]]+)\]:\s*(\S+)/gm)) {
-        definitions.set(match[1].trim().toLowerCase(), match[2]);
-    }
-    const candidates = [];
-    for (const match of body.matchAll(/\[[^\]]*\]\(([^)]+)\)/g)) {
-        candidates.push({ index: match.index, target: match[1] });
-    }
-    for (const match of body.matchAll(/(?<!!)\[[^\]]*\]\[([^\]]+)\]/g)) {
-        const target = definitions.get(match[1].trim().toLowerCase());
-        if (target)
-            candidates.push({ index: match.index, target });
-    }
-    candidates.sort((a, b) => a.index - b.index);
     const out = [];
     const seen = new Set();
-    for (const candidate of candidates) {
-        let target = candidate.target.trim();
+    for (const link of markdownLinkTargets(body, true)) {
+        let target = link.trim();
         // Drop an optional markdown link title: `[x](/a.md "Title")`.
         const wsIdx = target.search(/\s/);
         if (wsIdx >= 0)

package/dist/core/asset/akm-markdown.js

@@ -32,12 +32,14 @@ import { parseFrontmatterBlock, replaceFrontmatterLine, spliceFrontmatterLine }
  * intended mapping; when it does not (a `type` value that spans several lines,
  * a flow-style `{…}` block), the document is re-serialized instead, as it
  * always used to be. A document with no frontmatter block gets a new one;
- * malformed YAML throws.
+ * malformed YAML throws. An inserted or re-serialized block uses CRLF when
+ * every line break in the document is CRLF, and LF otherwise.
  */
 export function ensureAkmMarkdownType(content, type, now = new Date()) {
+    const eol = documentLineEnding(content);
     const block = parseFrontmatterBlock(content);
     if (!block) {
-        return `---\n${serializeFrontmatter({ type, updated: localDateStamp(now) })}\n---\n${content}`;
+        return (`---\n${serializeFrontmatter({ type, updated: localDateStamp(now) })}\n---\n`.replaceAll("\n", eol) + content);
     }
     let parsed;
     try {
@@ -74,7 +76,21 @@ export function ensureAkmMarkdownType(content, type, now = new Date()) {
     const next = { type, ...rest };
     if (needsUpdated)
         next.updated = updated;
-    return `---\n${serializeFrontmatter(next)}\n---\n${block.content}`;
+    return `---\n${serializeFrontmatter(next)}\n---\n`.replaceAll("\n", eol) + block.content;
+}
+/**
+ * The exact text `writeAssetToSource` writes for an AKM Markdown asset: the
+ * conformant document from {@link ensureAkmMarkdownType}, ending in a line
+ * break in the document's own line-ending style.
+ */
+export function normalizeAkmMarkdown(content, type, now = new Date()) {
+    const authored = ensureAkmMarkdownType(content, type, now);
+    return authored.endsWith("\n") ? authored : authored + documentLineEnding(authored);
+}
+/** CRLF only when every line break is CRLF; LF for LF-only, mixed or single-line text. */
+function documentLineEnding(text) {
+    const breaks = text.split("\n").length - 1;
+    return breaks > 0 && text.split("\r\n").length - 1 === breaks ? "\r\n" : "\n";
 }
 /** True when the frontmatter of `text` parses to exactly `intended`. */
 function parsesTo(text, intended) {

package/dist/core/asset/markdown-link-targets.js

@@ -0,0 +1,43 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { Marked } from "marked";
+// A private instance keeps unrelated consumers' global Marked options out of indexing.
+const markdown = new Marked({ gfm: true });
+/**
+ * Actual document links, in authored order. The tokenizer owns code regions,
+ * escapes and nested containers; the adapter still owns its supported syntax
+ * and path resolution. In particular, shortcut/collapsed references and wiki
+ * links are not new indexed syntax. Inline images retain their existing treatment.
+ */
+export function markdownLinkTargets(body, references) {
+    const tokens = markdown.lexer(body);
+    const definitions = new Map();
+    if (references) {
+        markdown.walkTokens(tokens, (token) => {
+            if (token.type !== "def")
+                return;
+            const definition = /^\s*\[([^\]]+)\]:\s*(\S+)/.exec(token.raw);
+            if (definition)
+                definitions.set(definition[1].trim().toLowerCase(), definition[2]);
+        });
+    }
+    const targets = [];
+    markdown.walkTokens(tokens, (token) => {
+        if (token.type !== "link" && token.type !== "image")
+            return;
+        const inline = /^!?\[[\s\S]*\]\(/.test(token.raw);
+        if (inline) {
+            // Angle-wrapped destinations were outside the adapters' existing subset.
+            const angled = /\]\(\s*<[^>]*>(?:\s+["'(][\s\S]*["')])?\s*\)$/.test(token.raw);
+            if (!angled)
+                targets.push(token.href);
+            return;
+        }
+        const reference = references && token.type === "link" ? /^\[[\s\S]*\]\[([^\]]+)\]$/.exec(token.raw) : null;
+        const target = reference ? definitions.get(reference[1].trim().toLowerCase()) : undefined;
+        if (target)
+            targets.push(target);
+    });
+    return targets;
+}

package/dist/core/asset/markdown.js

@@ -16,7 +16,8 @@ export function markdownHeadingSlug(heading) {
 export function markdownFragmentSlugs(content) {
     return uniqueHeadingSlugs(parseMarkdownToc(content).headings).filter(Boolean);
 }
-function uniqueHeadingSlugs(headings) {
+/** One slug per heading, in order; a heading with no sluggable text gets "". */
+export function uniqueHeadingSlugs(headings) {
     const used = new Set();
     return headings.map((heading) => {
         const base = markdownHeadingSlug(heading.text);
@@ -36,15 +37,22 @@ export function parseMarkdownToc(content) {
     const headings = [];
     const parsed = parseFrontmatter(content);
     const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
-    let inFence = false;
+    // Fenced code blocks follow CommonMark, so headings inside them are skipped:
+    // a fence opens with 3+ backticks or tildes indented at most 3 spaces (a
+    // backtick fence's info string has no backtick) and closes only on a line of
+    // the same character, at least as long, followed by nothing but whitespace.
+    let fence;
     for (let i = start; i < lines.length; i++) {
-        // Track fenced code blocks (``` or ~~~) so headings inside them are skipped.
-        if (/^\s*(`{3,}|~{3,})/.test(lines[i])) {
-            inFence = !inFence;
+        const [, run = "", rest = ""] = lines[i].match(/^ {0,3}(`{3,}|~{3,})(.*)$/) ?? [];
+        if (fence) {
+            if (run[0] === fence.char && run.length >= fence.length && !rest.trim())
+                fence = undefined;
             continue;
         }
-        if (inFence)
+        if (run && !(run[0] === "`" && rest.includes("`"))) {
+            fence = { char: run[0], length: run.length };
             continue;
+        }
         const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
         if (match) {
             headings.push({

package/dist/core/config/config.js

@@ -752,9 +752,10 @@ export function schedulerSourceIdFor(config, bundleId) {
  * user knows their key was dropped and how to provide it at runtime (#474).
  * Previously the strip was silent — a user invoking `akm setup --from <file>
  * --yes` with an `apiKey` field expected persistence and got a wiped config
- * with no feedback.
+ * with no feedback. `quiet` skips the warnings for a caller that only asks
+ * whether a write would drop anything and writes nothing itself.
  */
-export function sanitizeConfigForWrite(config) {
+export function sanitizeConfigForWrite(config, options) {
     const sanitized = { ...config };
     const stripped = [];
     if (config.embedding?.apiKey !== undefined) {
@@ -787,7 +788,7 @@ export function sanitizeConfigForWrite(config) {
         }
         sanitized.engines = engines;
     }
-    if (stripped.length > 0) {
+    if (stripped.length > 0 && !options?.quiet) {
         warn(`Config sanitizer dropped API key(s) before writing to disk:\n  - ${stripped.join("\n  - ")}\n\nakm does not persist API keys to config.json. Set the listed environment variables to provide them at runtime, or use \`\${VAR}\` references in your config to defer lookup. See docs/reference/data-and-telemetry.md.`);
     }
     if (config.registries) {
@@ -800,7 +801,8 @@ export function sanitizeConfigForWrite(config) {
         });
         if (droppedRegistries.length > 0) {
             sanitized.registries = registries;
-            warn(`Config sanitizer dropped registry entr${droppedRegistries.length === 1 ? "y" : "ies"} with URL credentials before writing to disk:\n  - ${droppedRegistries.join("\n  - ")}\n\nRegistry URLs must be credential-free; configure a credential-free HTTPS endpoint.`);
+            if (!options?.quiet)
+                warn(`Config sanitizer dropped registry entr${droppedRegistries.length === 1 ? "y" : "ies"} with URL credentials before writing to disk:\n  - ${droppedRegistries.join("\n  - ")}\n\nRegistry URLs must be credential-free; configure a credential-free HTTPS endpoint.`);
         }
     }
     return sanitized;

package/dist/core/non-task-input.js

@@ -3,18 +3,82 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /** The line of `src/assets/stash-skeleton/README.md` that reaches curate verbatim as a query. */
 const STASH_README_LINE = "This is an **AKM stash** — a structured knowledge repository that stores reusable";
+/** Exact normalized whole-message phrases; added task text must still retrieve. */
+const SOCIAL_INPUTS = new Set([
+    "thanks",
+    "thanks that worked",
+    "thank you",
+    "thank you that worked",
+    "ok",
+    "ok sounds good",
+    "ok go ahead",
+    "ok sounds good go ahead",
+    "okay",
+    "okay sounds good",
+    "okay go ahead",
+    "okay sounds good go ahead",
+    "hi",
+    "hi are you still there",
+    "hi ready when you are",
+    "hello",
+    "hello are you still there",
+    "hello ready when you are",
+    "hey",
+    "hey are you still there",
+    "hey ready when you are",
+    "good morning",
+    "good morning are you still there",
+    "good morning ready when you are",
+    "good afternoon",
+    "good afternoon are you still there",
+    "good afternoon ready when you are",
+    "good evening",
+    "good evening are you still there",
+    "good evening ready when you are",
+    "yes",
+    "yep",
+    "y",
+    "no",
+    "lgtm",
+    "ok do it",
+    "do it",
+    "go ahead",
+    "sounds good",
+    "looks good",
+    "continue",
+    "continue please",
+    "perfect",
+    "nice",
+    "cool",
+    "thx",
+    "thanks so much",
+    "great thanks",
+    "ok thanks",
+    "ok got it",
+    "hi there",
+    "hello there",
+    "hey thanks a lot",
+]);
 /**
  * What the (trimmed) curate input is when it is not a task, else undefined.
  * Harness and tool envelopes (`<task-notification>…`, `<system-reminder>…`,
  * `<cross-session-message …>…`) start with a tag and close one, and the stash
- * README line arrives verbatim; on the retrieval suite neither shape occurs in
- * a real query. Length is not a signal: prompts over 2,000 characters found
- * relevant assets at about the rate of shorter long prompts.
+ * README line arrives verbatim. Only the explicit normalized phrases
+ * above are withheld; this is not general conversational intent detection.
+ * Length is not a signal: prompts over 2,000 characters found relevant assets
+ * at about the rate of shorter long prompts.
  */
 export function nonTaskInput(query) {
     if (query.startsWith("<") && query.includes("</"))
         return "a harness or tool envelope";
     if (query === STASH_README_LINE)
         return "the akm stash README boilerplate";
+    const conversational = query
+        .toLowerCase()
+        .replace(/[,.!?]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (SOCIAL_INPUTS.has(conversational))
+        return "an exact conversational phrase";
     return undefined;
 }

package/dist/core/write-source.js

@@ -32,7 +32,7 @@ import { lockContentRootFor } from "../integrations/lockfile.js";
 import { GitStashPushError, getCachePaths, inspectGitUpstream, isGitBackedStash, parseGitRepoUrl, runGit, saveGitStash, } from "../sources/providers/git.js";
 import { listIgnoredExactPaths } from "../sources/providers/git-stash.js";
 import { detectAdapterId } from "./adapter/detect-adapter.js";
-import { ensureAkmMarkdownType } from "./asset/akm-markdown.js";
+import { normalizeAkmMarkdown } from "./asset/akm-markdown.js";
 import { assetPathForName, stashDirFor } from "./asset/asset-placement.js";
 import { conceptIdFromTypeName, displayRef } from "./asset/resolve-ref.js";
 import { deriveBundleId } from "./bundle-id.js";
@@ -236,7 +236,7 @@ export async function writeAssetToSource(source, config, ref, content) {
     assertSupportedKind(source);
     assertAkmAssetWrite(source);
     const filePath = resolveAssetFilePath(source, ref);
-    const authored = filePath.toLowerCase().endsWith(".md") ? ensureAkmMarkdownType(content, ref.type) : content;
+    const authored = filePath.toLowerCase().endsWith(".md") ? normalizeAkmMarkdown(content, ref.type) : content;
     const normalized = authored.endsWith("\n") ? authored : `${authored}\n`;
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     // Atomic: sibling temp file, fdatasync, rename — a crash or a full disk never

package/dist/indexer/index-writer-lock.js

@@ -138,7 +138,11 @@ export async function withAssetMutationLease(purpose, run) {
         return run();
     const context = inherited ?? new Set();
     const execute = async () => {
-        const lease = await acquireAssetMutationLease({ purpose });
+        const lease = await acquireAssetMutationLease({
+            purpose,
+            // #956: say who is in the way instead of waiting silently, as the sync path does.
+            onWait: ({ waitedMs }) => warn(`waiting for ${describeAssetMutationHolder(lockPath)} — ${Math.round(waitedMs / 1000)}s`),
+        });
         if (!lease)
             throw new Error(`asset mutation lease unavailable for ${purpose}`);
         context.add(lockPath);