@x12i/memorix-service 3.1.0 → 3.2.1

package/dist/live.js

@@ -8,8 +8,41 @@ import { createTrafficRing, createInstrumentedFetch, } from "@x12i/api-live-view
 import { createServiceInvokePorts, } from "@x12i/memorix-pipeline/v2";
 import { issueCallbackGrant } from "./callback-grant.js";
 import { createAiServicesClient } from "./ai-services/client.js";
+import { chunkMarkdown, markdownApproxTokens, } from "./ai-services/chunk-markdown.js";
 import { normalizeAiServiceStepOutput } from "./ai-services/normalize-output.js";
 import { defaultSkillExecutionForItem } from "./ai-services/skill-execution.js";
+import { associateDraftChunkSize, associateExistingCap, chunkArray, draftKey as associateDraftKey, mergeAssociateOutputs, prepareExistingKnowxForAssociate, slimDraftsForAssociate, slimKnowxForAssociate, } from "./ai-services/associate-prep.js";
+import { deliverViaPlatform } from "./destination-runtime.js";
+const DEFAULT_MAX_DOC_TOKENS = 200_000;
+/** Serial by default — OpenRouter cheap/default often 408s under parallel load. */
+const DEFAULT_CHUNK_CONCURRENCY = 1;
+const DEFAULT_CHUNK_RETRIES = 4;
+const DEFAULT_CHUNK_TARGET_TOKENS = 1500;
+/** Wired by platform so chunked AI extract can patch the running step attempt. */
+let stepProgressReporter = null;
+export function setStepProgressReporter(reporter) {
+    stepProgressReporter = reporter;
+}
+async function reportStepProgress(req, progress) {
+    const attemptId = req.attemptId?.trim();
+    if (!attemptId || !stepProgressReporter)
+        return;
+    try {
+        await stepProgressReporter(req.scope.orgId, attemptId, {
+            ...progress,
+        });
+    }
+    catch {
+        /* progress is best-effort */
+    }
+}
+function envInt(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
 export const memorixLiveRing = createTrafficRing();
 /** Outbound Memory connector pulls (opx-source, REST fixtures). */
 export const memoryPullFetch = createInstrumentedFetch(memorixLiveRing, {
@@ -33,27 +66,56 @@ function resolveAccess(raw) {
     return raw.filter((a) => a === "explore" || a === "checkpoints" || a === "raw");
 }
 const aiClient = createAiServicesClient({ fetchImpl: pipelineWorkerFetch });
+/**
+ * Paginate + collect knowx catalog for associate.
+ * Slim/cap applied later via prepareExistingKnowxForAssociate (same knobs as
+ * memorix-knowx-pack associate-ai.ts).
+ */
 async function fetchExistingKnowxForAssociate(memorix) {
     const objectTypes = ["content", "people", "work-items"];
     const out = [];
+    const seen = new Set();
     const headers = {
         "x-memorix-org-id": memorix.orgId,
         "x-memorix-agent-ids": memorix.agentIds.join(","),
     };
     if (memorix.grant)
         headers["x-memorix-invocation-grant"] = memorix.grant;
+    // Soft upper bound before slim/cap — avoid unbounded Explore walks.
+    const hardCap = Math.max(associateExistingCap() * 3, 360);
     for (const objectType of objectTypes) {
-        try {
-            const url = `${memorix.baseUrl}/api/data/content?objectType=${encodeURIComponent(objectType)}&contentType=knowx&limit=200`;
-            const res = await pipelineWorkerFetch(url, { headers });
-            if (!res.ok)
-                continue;
-            const body = (await res.json());
-            if (Array.isArray(body.records))
-                out.push(...body.records);
-        }
-        catch {
-            /* best-effort */
+        let cursor;
+        for (let page = 0; page < 20 && out.length < hardCap; page++) {
+            try {
+                const q = new URLSearchParams({
+                    objectType,
+                    contentType: "knowx",
+                    limit: "200",
+                });
+                if (cursor)
+                    q.set("cursor", cursor);
+                const url = `${memorix.baseUrl}/api/data/content?${q}`;
+                const res = await pipelineWorkerFetch(url, { headers });
+                if (!res.ok)
+                    break;
+                const body = (await res.json());
+                for (const raw of body.records ?? []) {
+                    const slim = slimKnowxForAssociate(raw);
+                    const key = associateDraftKey(slim);
+                    if (!key || seen.has(key))
+                        continue;
+                    seen.add(key);
+                    out.push(slim ?? raw);
+                    if (out.length >= hardCap)
+                        break;
+                }
+                cursor = body.pageInfo?.nextCursor ?? undefined;
+                if (!cursor)
+                    break;
+            }
+            catch {
+                break;
+            }
         }
     }
     return out;
@@ -92,49 +154,407 @@ function collectKnowxDrafts(inputs) {
     }
     return out;
 }
-/** Shape KnowX skill input + stamp templateTokens.input for Rendrix {{input}}. */
-function prepareKnowxSkillInvoke(itemId, serviceId, inputs, execution) {
+/**
+ * Shape KnowX FR `input` for skill invoke.
+ * ai-skills@0.3+ maps FR input to root `{{input}}` — do not stamp templateTokens.input.
+ */
+function prepareKnowxSkillInvoke(itemId, serviceId, inputs) {
     const isExtract = serviceId === "knowx-extract" || itemId === "knowx.extract";
     const isAssociate = serviceId === "knowx-associate-knowledge" ||
         itemId === "knowx.associate-knowledge";
-    let skillInput = inputs;
     if (isAssociate) {
-        const drafts = collectKnowxDrafts(inputs);
-        skillInput = {
-            knowxDrafts: drafts.length ? drafts : inputs.knowxDrafts,
-            existingKnowx: inputs.existingKnowx ?? [],
-        };
+        const collected = collectKnowxDrafts(inputs);
+        const drafts = slimDraftsForAssociate(collected.length
+            ? collected
+            : Array.isArray(inputs.knowxDrafts)
+                ? inputs.knowxDrafts
+                : []);
+        const draftKeys = new Set(drafts
+            .map((d) => associateDraftKey(d))
+            .filter((k) => Boolean(k)));
+        const existingRaw = Array.isArray(inputs.existingKnowx)
+            ? inputs.existingKnowx
+            : [];
+        const existingKnowx = prepareExistingKnowxForAssociate({
+            existing: existingRaw,
+            draftKeys,
+            cap: associateExistingCap(),
+        });
+        return { knowxDrafts: drafts, existingKnowx };
     }
-    else if (isExtract) {
-        skillInput = {
+    if (isExtract) {
+        // Chunk fan-out builds a per-chunk bag; keep legacy fields for short docs / fixtures.
+        return {
             text: inputs.text,
             knowledgeSource: inputs.knowledgeSource,
             contentId: inputs.contentId,
             contentIds: inputs.contentIds,
             contentDrafts: inputs.contentDrafts,
+            chunkText: inputs.chunkText,
+            chunkIndex: inputs.chunkIndex,
+            chunkCount: inputs.chunkCount,
+            contentHash: inputs.contentHash,
+            contentRevision: inputs.contentRevision,
+            pageStart: inputs.pageStart,
+            pageEnd: inputs.pageEnd,
         };
     }
-    let inputJson;
-    try {
-        inputJson = JSON.stringify(skillInput);
+    return inputs;
+}
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v)
+        ? v
+        : null;
+}
+/** Pull markdown sources for knowx.extract (contentDrafts, promote envelope, or inline text). */
+function collectExtractSources(inputs) {
+    const out = [];
+    const drafts = [];
+    const top = inputs.contentDrafts;
+    if (Array.isArray(top))
+        drafts.push(...top);
+    for (const value of Object.values(inputs)) {
+        const o = asRecord(value);
+        if (!o)
+            continue;
+        for (const key of ["value", "body", "data", "output", "result"]) {
+            const nested = asRecord(o[key]);
+            if (nested && Array.isArray(nested.contentDrafts)) {
+                drafts.push(...nested.contentDrafts);
+            }
+        }
+        if (Array.isArray(o.contentDrafts)) {
+            drafts.push(...o.contentDrafts);
+        }
     }
-    catch {
-        inputJson = "{}";
+    const seen = new Set();
+    for (const d of drafts) {
+        const md = typeof d.markdown === "string" ? d.markdown.trim() : "";
+        if (!md)
+            continue;
+        const key = `${d.contentId ?? ""}:${d.contentHash ?? md.slice(0, 40)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            contentId: typeof d.contentId === "string" ? d.contentId : undefined,
+            contentHash: typeof d.contentHash === "string" ? d.contentHash : undefined,
+            contentRevision: typeof d.revision === "number" ? d.revision : undefined,
+            title: typeof d.title === "string" ? d.title : undefined,
+            markdown: md,
+        });
+    }
+    if (!out.length) {
+        const text = typeof inputs.text === "string" ? inputs.text.trim() : "";
+        const ks = asRecord(inputs.knowledgeSource);
+        const ksBytes = typeof ks?.bytes === "string" ? String(ks.bytes).trim() : "";
+        const markdown = text || ksBytes;
+        if (markdown) {
+            out.push({
+                contentId: typeof inputs.contentId === "string" ? inputs.contentId : undefined,
+                markdown,
+            });
+        }
+    }
+    return out;
+}
+function draftKey(draft) {
+    if (!draft || typeof draft !== "object")
+        return "";
+    const d = draft;
+    const ot = String(d.objectType ?? "").trim();
+    const id = String(d.recordId ?? "").trim();
+    if (!ot || !id)
+        return "";
+    return `${ot}::${id}`;
+}
+function draftConfidence(draft) {
+    if (!draft || typeof draft !== "object")
+        return 0;
+    const data = asRecord(draft.data);
+    const epistemic = asRecord(data?.epistemic);
+    const score = Number(epistemic?.confidenceScore ?? 0);
+    return Number.isFinite(score) ? score : 0;
+}
+/** Merge chunk outputs: dedupe knowxDrafts by objectType::recordId (keep highest confidence). */
+export function mergeKnowxExtractChunkOutputs(parts) {
+    const byKey = new Map();
+    const untitled = [];
+    let docHash = "";
+    for (const part of parts) {
+        if (typeof part.docHash === "string" && part.docHash && !docHash) {
+            docHash = part.docHash;
+        }
+        const drafts = Array.isArray(part.knowxDrafts) ? part.knowxDrafts : [];
+        for (const draft of drafts) {
+            const key = draftKey(draft);
+            if (!key) {
+                untitled.push(draft);
+                continue;
+            }
+            const prev = byKey.get(key);
+            if (!prev || draftConfidence(draft) >= draftConfidence(prev)) {
+                byKey.set(key, draft);
+            }
+        }
     }
-    const priorTokens = execution.templateTokens && typeof execution.templateTokens === "object"
-        ? execution.templateTokens
-        : {};
     return {
-        input: skillInput,
-        execution: {
-            ...execution,
-            templateTokens: {
-                ...priorTokens,
-                input: inputJson,
-            },
-        },
+        knowxDrafts: [...byKey.values(), ...untitled],
+        ...(docHash ? { docHash } : {}),
+        kind: "ai-services",
+        live: true,
+        chunkCount: parts.length,
     };
 }
+async function mapPool(items, concurrency, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(concurrency, Math.max(1, items.length)) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i], i);
+        }
+    });
+    await Promise.all(workers);
+    return out;
+}
+function isAbortError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const e = err;
+    return (e.name === "AbortError" ||
+        e.code === "ABORT_ERR" ||
+        /aborted|AbortError/i.test(String(e.message ?? "")));
+}
+async function invokeKnowxExtractChunked(req, args) {
+    const sources = collectExtractSources(args.inputs);
+    if (!sources.length) {
+        // No markdown bag — fall through to a single invoke with the prepared bag
+        // (activity-log / knowledgeSource fixtures).
+        return invokeAiServiceOnce(req, {
+            ...args,
+            invokeInput: prepareKnowxSkillInvoke(args.itemId, args.serviceId, args.inputs),
+            correlationSuffix: "extract",
+        });
+    }
+    const maxDocTokens = envInt("KNOWX_AI_MAX_DOC_TOKENS", DEFAULT_MAX_DOC_TOKENS);
+    const targetTokens = envInt("KNOWX_AI_CHUNK_TOKENS", DEFAULT_CHUNK_TARGET_TOKENS);
+    const concurrency = envInt("KNOWX_AI_CHUNK_CONCURRENCY", DEFAULT_CHUNK_CONCURRENCY);
+    const work = [];
+    for (const source of sources) {
+        const tokens = markdownApproxTokens(source.markdown);
+        if (tokens > maxDocTokens) {
+            return {
+                status: "failed",
+                retryable: false,
+                error: {
+                    code: "AI_DOC_TOO_LARGE",
+                    message: `Document ~${tokens} tokens exceeds KNOWX_AI_MAX_DOC_TOKENS=${maxDocTokens}${source.contentId ? ` (contentId=${source.contentId})` : ""}`,
+                },
+            };
+        }
+        const chunks = chunkMarkdown(source.markdown, {
+            targetTokens,
+            overlapRatio: 0.1,
+        });
+        if (!chunks.length)
+            continue;
+        for (const chunk of chunks) {
+            work.push({ source, chunk });
+        }
+    }
+    if (!work.length) {
+        return {
+            status: "failed",
+            retryable: false,
+            error: {
+                code: "AI_EXTRACT_EMPTY",
+                message: "knowx.extract found no extractable markdown chunks",
+            },
+        };
+    }
+    // Short single-chunk docs: one invoke (preserve fixture behaviour).
+    if (work.length === 1 && work[0].chunk.count === 1) {
+        const w = work[0];
+        const bag = {
+            text: w.chunk.text,
+            contentId: w.source.contentId ?? args.inputs.contentId,
+            contentIds: w.source.contentId
+                ? [w.source.contentId]
+                : args.inputs.contentIds,
+            contentHash: w.source.contentHash,
+            contentRevision: w.source.contentRevision,
+            chunkText: w.chunk.text,
+            chunkIndex: 0,
+            chunkCount: 1,
+            pageStart: w.chunk.pageStart,
+            pageEnd: w.chunk.pageEnd,
+            knowledgeSource: args.inputs.knowledgeSource,
+        };
+        return invokeAiServiceOnce(req, {
+            ...args,
+            invokeInput: prepareKnowxSkillInvoke(args.itemId, args.serviceId, bag),
+            correlationSuffix: "c0",
+        });
+    }
+    const retries = envInt("KNOWX_AI_CHUNK_RETRIES", DEFAULT_CHUNK_RETRIES);
+    let draftsSoFar = 0;
+    let chunksDone = 0;
+    await reportStepProgress(req, {
+        chunkIndex: 0,
+        chunkCount: work.length,
+        draftsSoFar: 0,
+        message: `Extracting chunk 0/${work.length}`,
+    });
+    const results = await mapPool(work, concurrency, async (w, i) => {
+        const bag = {
+            chunkText: w.chunk.text,
+            chunkIndex: w.chunk.index,
+            chunkCount: w.chunk.count,
+            contentId: w.source.contentId,
+            contentHash: w.source.contentHash,
+            contentRevision: w.source.contentRevision,
+            pageStart: w.chunk.pageStart,
+            pageEnd: w.chunk.pageEnd,
+            title: w.source.title,
+            // Prefer chunkText in the prompt; keep text as the chunk for {{input}} templates.
+            text: w.chunk.text,
+        };
+        let last;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            last = await invokeAiServiceOnce(req, {
+                ...args,
+                invokeInput: prepareKnowxSkillInvoke(args.itemId, args.serviceId, bag),
+                correlationSuffix: `c${w.chunk.index}-${i}:a${attempt}`,
+                timeoutMs: 180_000,
+            });
+            if (last.status === "succeeded") {
+                const part = (last.output ?? {});
+                const drafts = Array.isArray(part.knowxDrafts) ? part.knowxDrafts.length : 0;
+                chunksDone += 1;
+                draftsSoFar += drafts;
+                await reportStepProgress(req, {
+                    chunkIndex: chunksDone,
+                    chunkCount: work.length,
+                    draftsSoFar,
+                    message: `Extracting chunk ${chunksDone}/${work.length}`,
+                });
+                return last;
+            }
+            const msg = `${last.error?.code ?? ""} ${last.error?.message ?? ""}`;
+            const retryable = last.retryable || /timeout|408|429|REMOTE_UNREACHABLE|INVOKE_FAILED/i.test(msg);
+            if (!retryable || attempt >= retries)
+                return last;
+            await new Promise((r) => setTimeout(r, 1500 * (attempt + 1)));
+        }
+        return last;
+    });
+    const succeeded = [];
+    for (const r of results) {
+        if (r.status !== "succeeded" || !r.output) {
+            return {
+                status: "failed",
+                retryable: r.retryable ?? false,
+                error: r.error ?? {
+                    code: "AI_EXTRACT_CHUNK_FAILED",
+                    message: "knowx.extract chunk invoke failed",
+                },
+            };
+        }
+        succeeded.push(r.output);
+    }
+    const merged = mergeKnowxExtractChunkOutputs(succeeded);
+    if (!Array.isArray(merged.knowxDrafts) || merged.knowxDrafts.length === 0) {
+        return {
+            status: "failed",
+            retryable: false,
+            error: {
+                code: "AI_OUTPUT_MISSING_DRAFTS",
+                message: "knowx.extract chunk fan-out produced no knowxDrafts after merge",
+            },
+        };
+    }
+    await reportStepProgress(req, {
+        chunkIndex: work.length,
+        chunkCount: work.length,
+        draftsSoFar: Array.isArray(merged.knowxDrafts)
+            ? merged.knowxDrafts.length
+            : draftsSoFar,
+        message: "Extract complete",
+    });
+    return { status: "succeeded", output: merged };
+}
+async function invokeAiServiceOnce(req, args) {
+    const correlationId = `${req.runId}:${req.stepId}:${req.attempt}:${args.correlationSuffix}`;
+    try {
+        const { status, body } = await aiClient.invoke(args.endpoint, {
+            itemId: args.itemId,
+            input: args.invokeInput,
+            execution: Object.keys(args.execution).length
+                ? args.execution
+                : undefined,
+            correlationId,
+        }, correlationId, args.timeoutMs);
+        if (status < 200 || status >= 300 || body.ok === false) {
+            return {
+                status: "failed",
+                retryable: Boolean(body.error?.retryable),
+                error: {
+                    code: body.error?.code ?? "AI_SERVICE_INVOKE_FAILED",
+                    message: body.error?.message ?? `HTTP ${status}`,
+                },
+            };
+        }
+        const normalized = normalizeAiServiceStepOutput(body, {
+            itemId: args.itemId,
+            serviceId: args.serviceId,
+        });
+        if (!normalized.ok) {
+            try {
+                const dumpPath = `/tmp/knowx-ai-unparseable-${args.correlationSuffix}-${Date.now()}.json`;
+                const { writeFileSync } = await import("node:fs");
+                writeFileSync(dumpPath, JSON.stringify({
+                    itemId: args.itemId,
+                    serviceId: args.serviceId,
+                    correlationSuffix: args.correlationSuffix,
+                    code: normalized.code,
+                    message: normalized.message,
+                    body,
+                }, null, 2));
+                console.error(`[ai-services] unparseable dump ${dumpPath}`);
+            }
+            catch {
+                /* ignore dump errors */
+            }
+            return {
+                status: "failed",
+                retryable: normalized.code === "AI_OUTPUT_EMPTY",
+                error: { code: normalized.code, message: normalized.message },
+            };
+        }
+        return { status: "succeeded", output: normalized.output };
+    }
+    catch (err) {
+        if (isAbortError(err)) {
+            return {
+                status: "failed",
+                retryable: true,
+                error: {
+                    code: "AI_EXTRACT_TIMEOUT",
+                    message: err instanceof Error ? err.message : "AI extract timed out",
+                },
+            };
+        }
+        return {
+            status: "failed",
+            retryable: true,
+            error: {
+                code: "REMOTE_UNREACHABLE",
+                message: err instanceof Error ? err.message : String(err),
+            },
+        };
+    }
+}
 async function invokeAiServiceRemote(req, memorix) {
     const c = (req.config ?? {});
     const endpoint = String(c.endpoint ?? "").replace(/\/+$/, "");
@@ -155,7 +575,6 @@ async function invokeAiServiceRemote(req, memorix) {
             error: { code: "AI_ITEM_MISSING", message: "itemId required" },
         };
     }
-    const correlationId = `${req.runId}:${req.stepId}:${req.attempt}`;
     const inputs = {
         ...(req.inputs && typeof req.inputs === "object"
             ? req.inputs
@@ -165,7 +584,8 @@ async function invokeAiServiceRemote(req, memorix) {
     if ((serviceId === "knowx-associate-knowledge" ||
         itemId === "knowx.associate-knowledge") &&
         memorix &&
-        inputs.existingKnowx === undefined) {
+        (inputs.existingKnowx === undefined ||
+            (Array.isArray(inputs.existingKnowx) && inputs.existingKnowx.length === 0))) {
         const existing = await fetchExistingKnowxForAssociate(memorix);
         if (existing.length)
             inputs.existingKnowx = existing;
@@ -179,57 +599,156 @@ async function invokeAiServiceRemote(req, memorix) {
             stepId: req.stepId,
         })
         : undefined;
-    let execution = {
+    const execution = {
         ...skillDefaults,
         ...configExec,
     };
-    let invokeInput = inputs;
+    const isKnowxExtract = serviceId === "knowx-extract" || itemId === "knowx.extract";
+    const isKnowxAssociate = serviceId === "knowx-associate-knowledge" ||
+        itemId === "knowx.associate-knowledge";
     if (aiServiceType === "skill" &&
+        isKnowxExtract &&
         (itemId.startsWith("knowx.") || serviceId.startsWith("knowx-"))) {
-        const prepared = prepareKnowxSkillInvoke(itemId, serviceId, inputs, execution);
-        invokeInput = prepared.input;
-        execution = prepared.execution;
+        return invokeKnowxExtractChunked(req, {
+            endpoint,
+            itemId,
+            serviceId,
+            execution,
+            inputs,
+        });
     }
-    try {
-        const { status, body } = await aiClient.invoke(endpoint, {
+    if (aiServiceType === "skill" &&
+        isKnowxAssociate &&
+        (itemId.startsWith("knowx.") || serviceId.startsWith("knowx-"))) {
+        return invokeKnowxAssociateChunked(req, {
+            endpoint,
             itemId,
-            input: invokeInput,
-            execution: Object.keys(execution).length ? execution : undefined,
-            correlationId,
-        }, correlationId);
-        if (status < 200 || status >= 300 || body.ok === false) {
-            return {
-                status: "failed",
-                retryable: Boolean(body.error?.retryable),
-                error: {
-                    code: body.error?.code ?? "AI_SERVICE_INVOKE_FAILED",
-                    message: body.error?.message ?? `HTTP ${status}`,
+            serviceId,
+            execution,
+            inputs,
+        });
+    }
+    let invokeInput = inputs;
+    if (aiServiceType === "skill" &&
+        (itemId.startsWith("knowx.") || serviceId.startsWith("knowx-"))) {
+        invokeInput = prepareKnowxSkillInvoke(itemId, serviceId, inputs);
+    }
+    return invokeAiServiceOnce(req, {
+        endpoint,
+        itemId,
+        serviceId,
+        execution,
+        invokeInput,
+        correlationSuffix: "once",
+    });
+}
+/**
+ * Fan-out knowx.associate-knowledge when draft count exceeds chunk size.
+ * Mirrors memorix-knowx-pack associate-ai draft chunking.
+ */
+async function invokeKnowxAssociateChunked(req, args) {
+    const prepared = prepareKnowxSkillInvoke(args.itemId, args.serviceId, args.inputs);
+    const drafts = Array.isArray(prepared.knowxDrafts)
+        ? prepared.knowxDrafts
+        : [];
+    const existingKnowx = Array.isArray(prepared.existingKnowx)
+        ? prepared.existingKnowx
+        : [];
+    const chunks = chunkArray(drafts, associateDraftChunkSize());
+    const outputs = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const chunkDrafts = chunks[i];
+        await reportStepProgress(req, {
+            chunkIndex: i + 1,
+            chunkCount: chunks.length,
+            message: `Associate chunk ${i + 1}/${chunks.length}`,
+        });
+        let once = await invokeAiServiceOnce(req, {
+            endpoint: args.endpoint,
+            itemId: args.itemId,
+            serviceId: args.serviceId,
+            execution: args.execution,
+            invokeInput: {
+                knowxDrafts: chunkDrafts,
+                existingKnowx,
+            },
+            correlationSuffix: `assoc-${i + 1}-of-${chunks.length}`,
+        });
+        // Retries: empty companion responses are flaky on deepseek-v4-flash.
+        const retriable = (code) => code === "AI_OUTPUT_UNPARSEABLE" ||
+            code === "AI_OUTPUT_MISSING_ASSOCIATE" ||
+            code === "AI_OUTPUT_EMPTY";
+        for (let attempt = 0; attempt < 2 && once.status !== "succeeded"; attempt++) {
+            if (!retriable(once.error?.code))
+                break;
+            once = await invokeAiServiceOnce(req, {
+                endpoint: args.endpoint,
+                itemId: args.itemId,
+                serviceId: args.serviceId,
+                execution: args.execution,
+                invokeInput: {
+                    knowxDrafts: chunkDrafts,
+                    existingKnowx,
                 },
-            };
+                correlationSuffix: `assoc-${i + 1}-of-${chunks.length}-retry${attempt + 1}`,
+            });
         }
-        const normalized = normalizeAiServiceStepOutput(body, { itemId, serviceId });
-        if (!normalized.ok) {
-            return {
-                status: "failed",
-                retryable: false,
-                error: { code: normalized.code, message: normalized.message },
-            };
+        if (once.status !== "succeeded" && retriable(once.error?.code)) {
+            const shrunk = existingKnowx.length > 4
+                ? existingKnowx.slice(0, Math.max(4, Math.floor(existingKnowx.length / 2)))
+                : existingKnowx;
+            once = await invokeAiServiceOnce(req, {
+                endpoint: args.endpoint,
+                itemId: args.itemId,
+                serviceId: args.serviceId,
+                execution: args.execution,
+                invokeInput: {
+                    knowxDrafts: chunkDrafts,
+                    existingKnowx: shrunk,
+                },
+                correlationSuffix: `assoc-${i + 1}-of-${chunks.length}-shrink`,
+            });
         }
-        return {
-            status: "succeeded",
-            output: normalized.output,
-        };
+        // Extra retries with full catalog — empty responses are intermittent.
+        for (let attempt = 0; attempt < 3 && once.status !== "succeeded" && retriable(once.error?.code); attempt++) {
+            once = await invokeAiServiceOnce(req, {
+                endpoint: args.endpoint,
+                itemId: args.itemId,
+                serviceId: args.serviceId,
+                execution: args.execution,
+                invokeInput: {
+                    knowxDrafts: chunkDrafts,
+                    existingKnowx,
+                },
+                correlationSuffix: `assoc-${i + 1}-of-${chunks.length}-persist${attempt + 1}`,
+            });
+        }
+        if (once.status !== "succeeded") {
+            return once;
+        }
+        const out = once.output && typeof once.output === "object"
+            ? once.output
+            : {};
+        outputs.push(out);
     }
-    catch (err) {
+    const merged = mergeAssociateOutputs(outputs);
+    if (!asRecord(merged.classification) &&
+        !Array.isArray(merged.relationshipPlans)) {
         return {
             status: "failed",
-            retryable: true,
+            retryable: false,
             error: {
-                code: "REMOTE_UNREACHABLE",
-                message: err instanceof Error ? err.message : String(err),
+                code: "AI_OUTPUT_MISSING_ASSOCIATE",
+                message: "knowx.associate-knowledge output missing classification / relationshipPlans",
             },
         };
     }
+    await reportStepProgress(req, {
+        chunkIndex: chunks.length,
+        chunkCount: chunks.length,
+        message: "Associate complete",
+    });
+    return { status: "succeeded", output: merged };
 }
 const baseServiceInvokePorts = createServiceInvokePorts({
     remoteFetch: pipelineWorkerFetch,
@@ -262,6 +781,9 @@ export const serviceInvokePorts = {
     invokeInProcess: baseServiceInvokePorts.invokeInProcess,
     invokeRemote: async (req) => {
         const c = (req.config ?? {});
+        if (c.invokeProtocol === "memorix-destination/1") {
+            return invokeDestinationDeliver(req);
+        }
         if (c.invokeProtocol === "ai-services/1" ||
             (typeof c.aiServiceType === "string" &&
                 c.aiServiceType &&
@@ -292,4 +814,109 @@ export const serviceInvokePorts = {
         return baseServiceInvokePorts.invokeRemote(req);
     },
 };
+function inventDeliverItems(inputs) {
+    if (!inputs || typeof inputs !== "object")
+        return [];
+    const o = inputs;
+    if (Array.isArray(o.items)) {
+        return o.items.filter((x) => Boolean(x) && typeof x === "object");
+    }
+    if (Array.isArray(o.records)) {
+        return o.records
+            .filter((x) => Boolean(x) && typeof x === "object")
+            .map((r) => ({
+            recordId: typeof r.recordId === "string" ? r.recordId : typeof r.id === "string" ? r.id : undefined,
+            objectType: typeof r.objectType === "string" ? r.objectType : undefined,
+            contentType: typeof r.contentType === "string" ? r.contentType : undefined,
+            payload: (r.payload && typeof r.payload === "object"
+                ? r.payload
+                : r),
+            identity: typeof r.identity === "string" ? r.identity : undefined,
+        }));
+    }
+    // Single-item envelope from work selector.
+    if (typeof o.recordId === "string" || typeof o.id === "string" || o.payload) {
+        return [
+            {
+                recordId: typeof o.recordId === "string"
+                    ? o.recordId
+                    : typeof o.id === "string"
+                        ? o.id
+                        : undefined,
+                objectType: typeof o.objectType === "string" ? o.objectType : undefined,
+                contentType: typeof o.contentType === "string" ? o.contentType : undefined,
+                payload: o.payload && typeof o.payload === "object"
+                    ? o.payload
+                    : o,
+                identity: typeof o.identity === "string" ? o.identity : undefined,
+            },
+        ];
+    }
+    return [];
+}
+async function invokeDestinationDeliver(req) {
+    const c = (req.config ?? {});
+    const destinationId = String(c.destinationId ?? "").trim();
+    if (!destinationId) {
+        return {
+            status: "failed",
+            retryable: false,
+            error: {
+                code: "DESTINATION_ID_MISSING",
+                message: "destinationId required for memorix-destination/1",
+            },
+        };
+    }
+    const items = inventDeliverItems(req.inputs);
+    if (!items.length) {
+        return {
+            status: "failed",
+            retryable: false,
+            error: {
+                code: "DELIVER_ITEMS_MISSING",
+                message: "items, records, or a single item payload required for destination deliver",
+            },
+        };
+    }
+    try {
+        const receipt = await deliverViaPlatform({
+            orgId: req.scope.orgId,
+            destinationId,
+            items,
+            workRef: `${req.runId}:${req.stepId}`,
+            mode: c.mode === "context" || c.mode === "knowledge"
+                ? c.mode
+                : undefined,
+        });
+        if (receipt.status === "failed") {
+            return {
+                status: "failed",
+                retryable: false,
+                error: {
+                    code: receipt.failureSummary?.code ?? "MEMORY_DELIVER_FAILED",
+                    message: receipt.failureSummary?.message ??
+                        `deliver to ${destinationId} failed`,
+                },
+                output: receipt,
+            };
+        }
+        return {
+            status: "succeeded",
+            output: receipt,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status: "failed",
+            retryable: false,
+            error: {
+                code: message.includes("MEMORY_DELIVERER_UNAVAILABLE")
+                    ? "MEMORY_DELIVERER_UNAVAILABLE"
+                    : "MEMORY_DELIVER_ERROR",
+                message,
+            },
+        };
+    }
+}
 //# sourceMappingURL=live.js.map