Codex/blazegraph safe rdf literals

packages/agent/src/dkg-agent-lifecycle.ts

@@ -1204,6 +1204,13 @@ export class LifecycleSyncMethods extends DKGAgentBase {
                   `keeping handler active: ${err instanceof Error ? err.message : String(err)}`,
                 );
               },
+              onDecline: (details) => {
+                this.log.warn(
+                  attemptCtx,
+                  `V10 StorageACK declined: code=${details.code} ` +
+                  `cg=${details.contextGraphId} reason=${details.message}`,
+                );
+              },
               // PR5 ACK-provenance — bind to the agent's host-mode
               // bookkeeping so every signed ACK carries which of the
               // four LU-6 Phase B discovery paths brought this CG's

packages/agent/src/dkg-agent-publish.ts

@@ -98,6 +98,7 @@ import {
   sharedMemoryReadBothFilter,
   partitionCatalogQuads,
 } from '@origintrail-official/dkg-core';
+import { normalizeLargeRdfLiteralsForBlazegraph } from '@origintrail-official/dkg-core';
 import { GraphManager, PrivateContentStore, createTripleStore, type TripleStore, type TripleStoreConfig, type Quad, type LargeLiteralStorageConfig } from '@origintrail-official/dkg-storage';
 import { EVMChainAdapter, NoChainAdapter, enrichEvmError, buildKnowledgeAssetUal, type EVMAdapterConfig, type ChainAdapter, type CreateContextGraphParams, type CreateOnChainContextGraphParams, type CreateOnChainContextGraphResult, type TxResult, type V10PublishingConvictionAccountInfo } from '@origintrail-official/dkg-chain';
 import {
@@ -1267,6 +1268,10 @@ export class PublishMethods extends DKGAgentBase {
   ): Promise<PublishResult> {
     const ctx = opts?.operationCtx ?? createOperationContext('publish');
     const onPhase = opts?.onPhase;
+    quads = normalizeLargeRdfLiteralsForBlazegraph(quads).quads as Quad[];
+    if (privateQuads) {
+      privateQuads = normalizeLargeRdfLiteralsForBlazegraph(privateQuads).quads as Quad[];
+    }
     this.log.info(ctx, `Starting publish to context graph "${contextGraphId}" with ${quads.length} triples`);
 
     const isSystem = contextGraphId === SYSTEM_CONTEXT_GRAPHS.AGENTS || contextGraphId === SYSTEM_CONTEXT_GRAPHS.ONTOLOGY;
@@ -2567,6 +2572,10 @@ export class PublishMethods extends DKGAgentBase {
       privateQuads?: Quad[];
     },
   ): Promise<PublishOptions['precomputedAttestation']> {
+    quads = normalizeLargeRdfLiteralsForBlazegraph(quads).quads as Quad[];
+    const normalizedPrivateQuads = opts?.privateQuads
+      ? normalizeLargeRdfLiteralsForBlazegraph(opts.privateQuads).quads as Quad[]
+      : undefined;
     if (
       opts?.authorAgentAddress != null &&
       opts?.preSignedAuthorAttestation != null
@@ -2595,7 +2604,7 @@ export class PublishMethods extends DKGAgentBase {
     // KC merkle. The order MUST follow the publisher's manifest
     // iteration over `kaMap`, which is the insertion order — same map
     // we built two lines up.
-    const privateQuads = opts?.privateQuads ?? [];
+    const privateQuads = normalizedPrivateQuads ?? [];
     const privateRoots: Uint8Array[] = [];
     for (const rootEntity of kaMap.keys()) {
       if (privateQuads.length === 0) break;

packages/agent/test/storage-ack-protocol-extra.test.ts

@@ -56,6 +56,15 @@ describe('A-9: storage-ack protocol id (libp2p) pin', () => {
     expect(combined).toMatch(registerRE);
   });
 
+  it('agent wires core-side StorageACK decline logging', () => {
+    const combined = walk(AGENT_SRC)
+      .map((f) => readFileSync(f, 'utf8'))
+      .join('\n');
+
+    expect(combined).toMatch(/onDecline:\s*\(details\)\s*=>/);
+    expect(combined).toContain('V10 StorageACK declined: code=');
+  });
+
   it('agent source never publishes ACKs on GossipSub', () => {
     // A false-positive here would be any call like
     // `publish('/dkg/10.0.1/storage-ack', ...)` or

packages/cli/src/daemon/http-utils.ts

@@ -67,6 +67,19 @@ export function payloadTooLargeResponseBody(err: unknown): Record<string, unknow
   return body;
 }
 
+export function isRdfLiteralSizeError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const shaped = err as { name?: unknown; code?: unknown };
+  return shaped.name === 'RdfLiteralSizeError' || shaped.code === 'RDF_LITERAL_TOO_LARGE';
+}
+
+export function rdfLiteralSizeResponseBody(err: unknown): Record<string, unknown> {
+  return {
+    error: err instanceof Error ? err.message : String(err ?? 'RDF literal exceeds size limit'),
+    code: 'RDF_LITERAL_TOO_LARGE',
+  };
+}
+
 export async function resolveNameToPeerId(
   agent: DKGAgent,
   nameOrId: string,

packages/cli/src/daemon/routes/knowledge-assets.ts

@@ -27,8 +27,10 @@
 import type { RequestContext } from "./context.js";
 import {
   isPayloadTooLargeError,
+  isRdfLiteralSizeError,
   jsonResponse,
   payloadTooLargeResponseBody,
+  rdfLiteralSizeResponseBody,
   readBody,
   safeParseJson,
   validateEntities,
@@ -650,6 +652,9 @@ export async function handleKnowledgeAssetsRoutes(ctx: RequestContext): Promise<
       if (isPayloadTooLargeError(e)) {
         return jsonResponse(res, 413, payloadTooLargeResponseBody(e));
       }
+      if (isRdfLiteralSizeError(e)) {
+        return jsonResponse(res, 400, rdfLiteralSizeResponseBody(e));
+      }
       return jsonResponse(res, 500, { error: e?.message ?? String(e) });
     }
   }

packages/cli/src/daemon/routes/memory.ts

@@ -226,6 +226,8 @@ import {
   shortId,
   sleep,
   deriveBlockExplorerUrl,
+  isRdfLiteralSizeError,
+  rdfLiteralSizeResponseBody,
 } from '../http-utils.js';
 import {
   normalizeRepo,
@@ -1695,6 +1697,9 @@ WHERE {
       ) {
         return jsonResponse(res, 400, { error: err.message });
       }
+      if (isRdfLiteralSizeError(err)) {
+        return jsonResponse(res, 400, rdfLiteralSizeResponseBody(err));
+      }
       // Strict curator-ack gate (OT-RFC-49 curator-leader): the write was NOT
       // persisted because the curator (the authoritative replica) did not
       // confirm it. Surface a distinct, actionable status instead of a generic
@@ -2256,6 +2261,9 @@ WHERE {
       });
     } catch (err: any) {
       tracker.fail(ctx, err);
+      if (isRdfLiteralSizeError(err)) {
+        return jsonResponse(res, 400, rdfLiteralSizeResponseBody(err));
+      }
       if (
         err.name === "StaleWriteError" ||
         err.message?.includes("stale") ||

packages/core/src/index.ts

@@ -5,6 +5,7 @@ export { parseDotenvValue } from './dotenv.js';
 export * from './memory-model.js';
 export * from './trust.js';
 export * from './publisher-extension.js';
+export * from './rdf-literal-limits.js';
 export * from './imported-artifact-bytes.js';
 export * from './imported-artifact-metadata.js';
 export * from './event-bus.js';