@swarmvaultai/engine 0.1.10 → 0.1.12

package/README.md

@@ -117,9 +117,10 @@ This matters because many "OpenAI-compatible" backends only implement part of th
 
 ### Ingest
 
-- `ingestInput(rootDir, input)` ingests a local path or URL
+- `ingestInput(rootDir, input, { includeAssets, maxAssetSize })` ingests a local path or URL
 - `importInbox(rootDir, inputDir?)` recursively imports supported inbox files and browser-clipper style bundles
 - `.js`, `.jsx`, `.ts`, and `.tsx` inputs are treated as code sources and compiled into both source pages and `wiki/code/` module pages
+- HTML and markdown URL ingests localize remote image references into `raw/assets/<sourceId>/` by default and rewrite the stored markdown to local relative paths
 
 ### Compile + Query
 
@@ -160,8 +161,8 @@ Running the engine produces a local workspace with these main areas:
 - `swarmvault.schema.md`: vault-specific compile and query instructions
 - `inbox/`: capture staging area for markdown bundles and imported files
 - `raw/sources/`: immutable source copies
-- `raw/assets/`: copied attachments referenced by ingested markdown bundles
-- `wiki/`: generated markdown pages, staged candidates, saved query outputs, exploration hub pages, and a human-only `insights/` area
+- `raw/assets/`: copied attachments referenced by ingested markdown bundles and remote URL ingests
+- `wiki/`: generated markdown pages, the append-only `log.md` activity trail, staged candidates, saved query outputs, exploration hub pages, and a human-only `insights/` area
 - `wiki/outputs/assets/`: local chart/image artifacts and JSON manifests for saved visual outputs
 - `wiki/code/`: generated module pages for ingested JS/TS sources
 - `wiki/projects/`: generated project rollups over canonical pages
@@ -178,6 +179,7 @@ Running the engine produces a local workspace with these main areas:
 
 Saved outputs are indexed immediately into the graph page registry and search index, then linked back into compiled source, concept, and entity pages immediately through the lightweight artifact sync path. New concept and entity pages stage into `wiki/candidates/` first and promote to active pages on the next matching compile. Insight pages are indexed into search and page reads, but compile does not mutate them. Project-scoped pages receive `project_ids`, project tags, and layered root-plus-project schema hashes when all contributing sources resolve to the same configured project.
 JS/TS code sources also emit module and symbol nodes into `state/graph.json`, so local imports, exports, inheritance, and same-module call edges are queryable through the same viewer and search pipeline.
+Ingest, inbox import, compile, query, lint, review, and candidate operations also append human-readable entries to `wiki/log.md`.
 
 ## Notes
 

package/dist/index.d.ts

@@ -189,6 +189,10 @@ interface SourceAttachment {
     mimeType: string;
     originalPath?: string;
 }
+interface IngestOptions {
+    includeAssets?: boolean;
+    maxAssetSize?: number;
+}
 interface SourceManifest {
     sourceId: string;
     title: string;
@@ -674,7 +678,7 @@ declare function initWorkspace(rootDir: string): Promise<{
     paths: ResolvedPaths;
 }>;
 
-declare function ingestInput(rootDir: string, input: string): Promise<SourceManifest>;
+declare function ingestInput(rootDir: string, input: string, options?: IngestOptions): Promise<SourceManifest>;
 declare function importInbox(rootDir: string, inputDir?: string): Promise<InboxImportResult>;
 declare function listManifests(rootDir: string): Promise<SourceManifest[]>;
 declare function readExtractedText(rootDir: string, manifest: SourceManifest): Promise<string | undefined>;
@@ -756,4 +760,4 @@ declare function watchVault(rootDir: string, options?: WatchOptions): Promise<Wa
 declare function createWebSearchAdapter(id: string, config: WebSearchProviderConfig, rootDir: string): Promise<WebSearchAdapter>;
 declare function getWebSearchAdapterForTask(rootDir: string, task: "deepLintProvider"): Promise<WebSearchAdapter>;
 
-export { type AnalyzedTerm, type ApprovalChangeType, type ApprovalDetail, type ApprovalEntry, type ApprovalEntryDetail, type ApprovalEntryStatus, type ApprovalManifest, type ApprovalSummary, type CandidateRecord, type ChartDatum, type ChartSpec, type ClaimStatus, type CodeAnalysis, type CodeDiagnostic, type CodeImport, type CodeLanguage, type CodeSymbol, type CodeSymbolKind, type CommandRoleExecutorConfig, type CompileOptions, type CompileResult, type CompileState, type ExploreOptions, type ExploreResult, type ExploreStepResult, type Freshness, type GenerationAttachment, type GenerationRequest, type GenerationResponse, type GraphArtifact, type GraphEdge, type GraphNode, type GraphPage, type ImageGenerationRequest, type ImageGenerationResponse, type InboxImportResult, type InboxImportSkip, type InitOptions, type LintFinding, type LintOptions, type OrchestrationConfig, type OrchestrationFinding, type OrchestrationProposal, type OrchestrationRole, type OrchestrationRoleConfig, type OrchestrationRoleResult, type OutputAsset, type OutputAssetRole, type OutputFormat, type OutputOrigin, type PageKind, type PageManager, type PageStatus, type Polarity, type ProviderAdapter, type ProviderCapability, type ProviderConfig, type ProviderRoleExecutorConfig, type ProviderType, type QueryOptions, type QueryResult, type ResolvedPaths, type ReviewActionResult, type RoleExecutorConfig, type SceneElement, type SceneSpec, type ScheduleController, type ScheduleJobConfig, type ScheduleStateRecord, type ScheduleTriggerConfig, type ScheduledCompileTask, type ScheduledExploreTask, type ScheduledLintTask, type ScheduledQueryTask, type ScheduledRunResult, type ScheduledTaskConfig, type SearchResult, type SourceAnalysis, type SourceAttachment, type SourceClaim, type SourceKind, type SourceManifest, type VaultConfig, type WatchController, type WatchOptions, type WatchRunRecord, type WebSearchAdapter, type WebSearchProviderConfig, type WebSearchProviderType, type WebSearchResult, acceptApproval, archiveCandidate, assertProviderCapability, bootstrapDemo, compileVault, createMcpServer, createProvider, createWebSearchAdapter, defaultVaultConfig, defaultVaultSchema, exploreVault, exportGraphHtml, getProviderForTask, getWebSearchAdapterForTask, getWorkspaceInfo, importInbox, ingestInput, initVault, initWorkspace, installAgent, installConfiguredAgents, lintVault, listApprovals, listCandidates, listManifests, listPages, listSchedules, loadVaultConfig, loadVaultSchema, loadVaultSchemas, promoteCandidate, providerCapabilitySchema, providerTypeSchema, queryVault, readApproval, readExtractedText, readPage, rejectApproval, resolvePaths, runSchedule, searchVault, serveSchedules, startGraphServer, startMcpServer, watchVault, webSearchProviderTypeSchema };
+export { type AnalyzedTerm, type ApprovalChangeType, type ApprovalDetail, type ApprovalEntry, type ApprovalEntryDetail, type ApprovalEntryStatus, type ApprovalManifest, type ApprovalSummary, type CandidateRecord, type ChartDatum, type ChartSpec, type ClaimStatus, type CodeAnalysis, type CodeDiagnostic, type CodeImport, type CodeLanguage, type CodeSymbol, type CodeSymbolKind, type CommandRoleExecutorConfig, type CompileOptions, type CompileResult, type CompileState, type ExploreOptions, type ExploreResult, type ExploreStepResult, type Freshness, type GenerationAttachment, type GenerationRequest, type GenerationResponse, type GraphArtifact, type GraphEdge, type GraphNode, type GraphPage, type ImageGenerationRequest, type ImageGenerationResponse, type InboxImportResult, type InboxImportSkip, type IngestOptions, type InitOptions, type LintFinding, type LintOptions, type OrchestrationConfig, type OrchestrationFinding, type OrchestrationProposal, type OrchestrationRole, type OrchestrationRoleConfig, type OrchestrationRoleResult, type OutputAsset, type OutputAssetRole, type OutputFormat, type OutputOrigin, type PageKind, type PageManager, type PageStatus, type Polarity, type ProviderAdapter, type ProviderCapability, type ProviderConfig, type ProviderRoleExecutorConfig, type ProviderType, type QueryOptions, type QueryResult, type ResolvedPaths, type ReviewActionResult, type RoleExecutorConfig, type SceneElement, type SceneSpec, type ScheduleController, type ScheduleJobConfig, type ScheduleStateRecord, type ScheduleTriggerConfig, type ScheduledCompileTask, type ScheduledExploreTask, type ScheduledLintTask, type ScheduledQueryTask, type ScheduledRunResult, type ScheduledTaskConfig, type SearchResult, type SourceAnalysis, type SourceAttachment, type SourceClaim, type SourceKind, type SourceManifest, type VaultConfig, type WatchController, type WatchOptions, type WatchRunRecord, type WebSearchAdapter, type WebSearchProviderConfig, type WebSearchProviderType, type WebSearchResult, acceptApproval, archiveCandidate, assertProviderCapability, bootstrapDemo, compileVault, createMcpServer, createProvider, createWebSearchAdapter, defaultVaultConfig, defaultVaultSchema, exploreVault, exportGraphHtml, getProviderForTask, getWebSearchAdapterForTask, getWorkspaceInfo, importInbox, ingestInput, initVault, initWorkspace, installAgent, installConfiguredAgents, lintVault, listApprovals, listCandidates, listManifests, listPages, listSchedules, loadVaultConfig, loadVaultSchema, loadVaultSchemas, promoteCandidate, providerCapabilitySchema, providerTypeSchema, queryVault, readApproval, readExtractedText, readPage, rejectApproval, resolvePaths, runSchedule, searchVault, serveSchedules, startGraphServer, startMcpServer, watchVault, webSearchProviderTypeSchema };

package/dist/index.js

@@ -670,6 +670,7 @@ async function appendWatchRun(rootDir, run) {
 }
 
 // src/ingest.ts
+var DEFAULT_MAX_ASSET_SIZE = 10 * 1024 * 1024;
 function inferKind(mimeType, filePath) {
   if (inferCodeLanguage(filePath, mimeType)) {
     return "code";
@@ -698,6 +699,12 @@ function titleFromText(fallback, content) {
 function guessMimeType(target) {
   return mime.lookup(target) || "application/octet-stream";
 }
+function normalizeIngestOptions(options) {
+  return {
+    includeAssets: options?.includeAssets ?? true,
+    maxAssetSize: Math.max(0, Math.floor(options?.maxAssetSize ?? DEFAULT_MAX_ASSET_SIZE))
+  };
+}
 function buildCompositeHash(payloadBytes, attachments = []) {
   if (!attachments.length) {
     return sha256(payloadBytes);
@@ -742,6 +749,40 @@ function extractMarkdownReferences(content) {
   }
   return references;
 }
+function normalizeRemoteReference(value, baseUrl) {
+  const trimmed = value.trim().replace(/^<|>$/g, "");
+  const [withoutTitle] = trimmed.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/, 1);
+  const candidate = withoutTitle.split("#")[0]?.trim();
+  if (!candidate) {
+    return null;
+  }
+  const lowered = candidate.toLowerCase();
+  if (lowered.startsWith("data:") || lowered.startsWith("mailto:") || lowered.startsWith("#")) {
+    return null;
+  }
+  let resolved;
+  try {
+    resolved = new URL(candidate, baseUrl);
+  } catch {
+    return null;
+  }
+  if (!/^https?:$/i.test(resolved.protocol)) {
+    return null;
+  }
+  resolved.hash = "";
+  return resolved.toString();
+}
+function extractMarkdownImageReferences(content, baseUrl) {
+  const references = [];
+  const imagePattern = /!\[[^\]]*]\(([^)]+)\)/g;
+  for (const match of content.matchAll(imagePattern)) {
+    const normalized = normalizeRemoteReference(match[1] ?? "", baseUrl);
+    if (normalized) {
+      references.push(normalized);
+    }
+  }
+  return references;
+}
 async function convertHtmlToMarkdown(html, url) {
   const dom = new JSDOM(html, { url });
   const article = new Readability(dom.window.document).parse();
@@ -766,6 +807,142 @@ async function readManifestByHash(manifestsDir, contentHash) {
   }
   return null;
 }
+function resolveUrlMimeType(input, response) {
+  const headerMimeType = response.headers.get("content-type")?.split(";")[0]?.trim();
+  const guessedMimeType = guessMimeType(new URL(input).pathname);
+  if (!headerMimeType) {
+    return guessedMimeType;
+  }
+  if ((headerMimeType === "text/plain" || headerMimeType === "application/octet-stream") && guessedMimeType !== "application/octet-stream") {
+    return guessedMimeType;
+  }
+  return headerMimeType;
+}
+function buildRemoteAssetRelativePath(assetUrl, mimeType) {
+  const url = new URL(assetUrl);
+  const normalized = sanitizeAssetRelativePath(`${url.hostname}${url.pathname || "/asset"}`);
+  const extension = path4.posix.extname(normalized);
+  const directory = path4.posix.dirname(normalized);
+  const basename = extension ? path4.posix.basename(normalized, extension) : path4.posix.basename(normalized);
+  const resolvedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
+  const hashedName = `${basename || "asset"}-${sha256(assetUrl).slice(0, 8)}${resolvedExtension}`;
+  return directory === "." ? hashedName : path4.posix.join(directory, hashedName);
+}
+async function readResponseBytesWithinLimit(response, maxBytes) {
+  const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new Error(`asset exceeds max size (${contentLength} > ${maxBytes})`);
+  }
+  if (!response.body) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > maxBytes) {
+      throw new Error(`asset exceeds max size (${bytes.length} > ${maxBytes})`);
+    }
+    return bytes;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel("asset exceeds configured size limit");
+      throw new Error(`asset exceeds max size (${total} > ${maxBytes})`);
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return Buffer.concat(chunks);
+}
+async function fetchRemoteImageAttachment(assetUrl, maxAssetSize) {
+  const response = await fetch(assetUrl);
+  if (!response.ok) {
+    throw new Error(`failed with ${response.status} ${response.statusText}`);
+  }
+  const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || guessMimeType(new URL(assetUrl).pathname);
+  if (!mimeType.startsWith("image/")) {
+    throw new Error(`unsupported mime type ${mimeType}`);
+  }
+  const bytes = await readResponseBytesWithinLimit(response, maxAssetSize);
+  return {
+    relativePath: buildRemoteAssetRelativePath(assetUrl, mimeType),
+    mimeType,
+    originalPath: assetUrl,
+    bytes
+  };
+}
+async function collectRemoteImageAttachments(assetUrls, options) {
+  if (!options.includeAssets || options.maxAssetSize === 0 || !assetUrls.length) {
+    return { attachments: [], skippedCount: 0 };
+  }
+  const attachments = [];
+  let skippedCount = 0;
+  for (const assetUrl of [...new Set(assetUrls)]) {
+    try {
+      attachments.push(await fetchRemoteImageAttachment(assetUrl, options.maxAssetSize));
+    } catch {
+      skippedCount += 1;
+    }
+  }
+  return { attachments, skippedCount };
+}
+function extractHtmlImageReferences(html, baseUrl) {
+  const dom = new JSDOM(html, { url: baseUrl });
+  const document = dom.window.document;
+  const references = [];
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeRemoteReference(src, baseUrl);
+    if (normalized) {
+      references.push(normalized);
+    }
+  }
+  return references;
+}
+function rewriteHtmlImageReferences(html, baseUrl, replacements) {
+  const dom = new JSDOM(html, { url: baseUrl });
+  const document = dom.window.document;
+  for (const image of [...document.querySelectorAll("img[src]")]) {
+    const src = image.getAttribute("src");
+    if (!src) {
+      continue;
+    }
+    const normalized = normalizeRemoteReference(src, baseUrl);
+    const replacement = normalized ? replacements.get(normalized) : void 0;
+    if (replacement) {
+      image.setAttribute("src", replacement);
+    }
+  }
+  return dom.serialize();
+}
+function rewriteMarkdownImageReferences(content, baseUrl, replacements) {
+  return content.replace(/(!\[[^\]]*]\()([^)]+)(\))/g, (fullMatch, prefix, target, suffix) => {
+    const normalized = normalizeRemoteReference(target, baseUrl);
+    const replacement = normalized ? replacements.get(normalized) : void 0;
+    if (!replacement) {
+      return fullMatch;
+    }
+    return `${prefix}${replacement}${suffix}`;
+  });
+}
+function rewriteMarkdownImageTargets(content, replacements) {
+  return content.replace(/(!\[[^\]]*]\()([^)]+)(\))/g, (fullMatch, prefix, target, suffix) => {
+    const trimmed = target.trim().replace(/^<|>$/g, "");
+    const [withoutTitle] = trimmed.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/, 1);
+    const candidate = withoutTitle.trim();
+    const replacement = replacements.get(candidate);
+    if (!replacement) {
+      return fullMatch;
+    }
+    return `${prefix}${replacement}${suffix}`;
+  });
+}
 async function persistPreparedInput(rootDir, prepared, paths) {
   await ensureDir(paths.rawSourcesDir);
   await ensureDir(paths.rawAssetsDir);
@@ -817,7 +994,8 @@ async function persistPreparedInput(rootDir, prepared, paths) {
   await appendLogEntry(rootDir, "ingest", prepared.title, [
     `source_id=${sourceId}`,
     `kind=${prepared.sourceKind}`,
-    `attachments=${manifestAttachments.length}`
+    `attachments=${manifestAttachments.length}`,
+    ...prepared.logDetails ?? []
   ]);
   return { manifest, isNew: true };
 }
@@ -847,33 +1025,86 @@ async function prepareFileInput(_rootDir, absoluteInput) {
     extractedText
   };
 }
-async function prepareUrlInput(input) {
+async function prepareUrlInput(input, options) {
   const response = await fetch(input);
   if (!response.ok) {
     throw new Error(`Failed to fetch ${input}: ${response.status} ${response.statusText}`);
   }
-  let payloadBytes = Buffer.from(await response.arrayBuffer());
-  let mimeType = response.headers.get("content-type")?.split(";")[0]?.trim() || guessMimeType(input);
-  let sourceKind = inferKind(mimeType, input);
-  const language = inferCodeLanguage(input, mimeType);
+  const inputUrl = new URL(input);
+  const originalPayloadBytes = Buffer.from(await response.arrayBuffer());
+  let payloadBytes = originalPayloadBytes;
+  let mimeType = resolveUrlMimeType(input, response);
+  let sourceKind = inferKind(mimeType, inputUrl.pathname);
+  const language = inferCodeLanguage(inputUrl.pathname, mimeType);
   let storedExtension = ".bin";
-  let title = new URL(input).hostname + new URL(input).pathname;
+  let title = inputUrl.hostname + inputUrl.pathname;
   let extractedText;
+  let attachments;
+  let contentHash;
+  const logDetails = [];
   if (sourceKind === "html" || mimeType.startsWith("text/html")) {
-    const html = payloadBytes.toString("utf8");
-    const converted = await convertHtmlToMarkdown(html, input);
-    title = converted.title;
+    const html = originalPayloadBytes.toString("utf8");
+    const initialConversion = await convertHtmlToMarkdown(html, input);
+    title = initialConversion.title;
+    let localizedHtml = html;
+    let localAssetReplacements;
+    if (options.includeAssets) {
+      const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
+        extractHtmlImageReferences(html, input),
+        options
+      );
+      if (remoteAttachments.length) {
+        attachments = remoteAttachments;
+        contentHash = buildCompositeHash(originalPayloadBytes, remoteAttachments);
+        const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
+        localAssetReplacements = new Map(
+          remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
+        );
+        localizedHtml = rewriteHtmlImageReferences(html, input, localAssetReplacements);
+        logDetails.push(`remote_assets=${remoteAttachments.length}`);
+      }
+      if (skippedCount) {
+        logDetails.push(`remote_asset_skips=${skippedCount}`);
+      }
+    }
+    const converted = localizedHtml === html && !attachments?.length ? initialConversion : await convertHtmlToMarkdown(localizedHtml, input);
     extractedText = converted.markdown;
-    payloadBytes = Buffer.from(converted.markdown, "utf8");
+    if (localAssetReplacements?.size) {
+      const absoluteLocalAssetReplacements = new Map(
+        [...localAssetReplacements.values()].map((replacement) => [new URL(replacement, input).toString(), replacement])
+      );
+      extractedText = rewriteMarkdownImageTargets(extractedText, absoluteLocalAssetReplacements);
+    }
+    payloadBytes = Buffer.from(extractedText, "utf8");
     mimeType = "text/markdown";
     sourceKind = "markdown";
     storedExtension = ".md";
   } else {
-    const extension = path4.extname(new URL(input).pathname);
+    const extension = path4.extname(inputUrl.pathname);
     storedExtension = extension || `.${mime.extension(mimeType) || "bin"}`;
     if (sourceKind === "markdown" || sourceKind === "text" || sourceKind === "code") {
       extractedText = payloadBytes.toString("utf8");
-      title = titleFromText(title || new URL(input).hostname, extractedText);
+      title = titleFromText(title || inputUrl.hostname, extractedText);
+      if (sourceKind === "markdown" && options.includeAssets) {
+        const { attachments: remoteAttachments, skippedCount } = await collectRemoteImageAttachments(
+          extractMarkdownImageReferences(extractedText, input),
+          options
+        );
+        if (remoteAttachments.length) {
+          attachments = remoteAttachments;
+          contentHash = buildCompositeHash(originalPayloadBytes, remoteAttachments);
+          const sourceId = `${slugify(title)}-${contentHash.slice(0, 8)}`;
+          const replacements = new Map(
+            remoteAttachments.map((attachment) => [attachment.originalPath ?? "", `../assets/${sourceId}/${attachment.relativePath}`])
+          );
+          extractedText = rewriteMarkdownImageReferences(extractedText, input, replacements);
+          payloadBytes = Buffer.from(extractedText, "utf8");
+          logDetails.push(`remote_assets=${remoteAttachments.length}`);
+        }
+        if (skippedCount) {
+          logDetails.push(`remote_asset_skips=${skippedCount}`);
+        }
+      }
     }
   }
   return {
@@ -885,7 +1116,10 @@ async function prepareUrlInput(input) {
     mimeType,
     storedExtension,
     payloadBytes,
-    extractedText
+    extractedText,
+    attachments,
+    contentHash,
+    logDetails
   };
 }
 async function collectInboxAttachmentRefs(inputDir, files) {
@@ -975,9 +1209,10 @@ async function prepareInboxMarkdownInput(absolutePath, attachmentRefs) {
 function isSupportedInboxKind(sourceKind) {
   return ["markdown", "text", "html", "pdf", "image"].includes(sourceKind);
 }
-async function ingestInput(rootDir, input) {
+async function ingestInput(rootDir, input, options) {
   const { paths } = await initWorkspace(rootDir);
-  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
+  const normalizedOptions = normalizeIngestOptions(options);
+  const prepared = /^https?:\/\//i.test(input) ? await prepareUrlInput(input, normalizedOptions) : await prepareFileInput(rootDir, path4.resolve(rootDir, input));
   const result = await persistPreparedInput(rootDir, prepared, paths);
   return result.manifest;
 }
@@ -4605,6 +4840,7 @@ async function syncVaultArtifacts(rootDir, input) {
   const promotedPageIds = [];
   const candidateHistory = {};
   const records = [];
+  const promoteCandidates = input.promoteCandidates ?? true;
   for (const manifest of input.manifests) {
     const analysis = input.analyses.find((item) => item.sourceId === manifest.sourceId);
     if (!analysis) {
@@ -4723,7 +4959,7 @@ async function syncVaultArtifacts(rootDir, input) {
       const projectIds = scopedProjectIdsFromSources(sourceIds, input.sourceProjects);
       const schemaHash = effectiveHashForProject(input.schemas, projectIds[0] ?? null);
       const previousEntry = input.previousState?.candidateHistory?.[pageId];
-      const promoted = previousEntry?.status === "active" || shouldPromoteCandidate(previousEntry, sourceIds);
+      const promoted = previousEntry?.status === "active" || promoteCandidates && shouldPromoteCandidate(previousEntry, sourceIds);
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const fallbackPaths = [
         path13.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
@@ -5355,7 +5591,8 @@ async function refreshVaultAfterOutputSave(rootDir) {
     outputHashes: pageHashes(storedOutputs),
     insightHashes: pageHashes(storedInsights),
     previousState: await readJsonFile(paths.compileStatePath),
-    approve: false
+    approve: false,
+    promoteCandidates: false
   });
 }
 function resolveApprovalTargets(manifest, targets) {
@@ -6529,7 +6766,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.10";
+var SERVER_VERSION = "0.1.12";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmvaultai/engine",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Core engine for SwarmVault: ingest, compile, query, lint, and provider abstractions.",
   "type": "module",
   "main": "dist/index.js",