forge-openclaw-plugin 0.2.114 → 0.2.116

package/dist/openclaw/local-runtime.js

@@ -3,7 +3,7 @@ import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import net from "node:net";
 import { homedir } from "node:os";
 import path from "node:path";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 const LOCAL_HOSTNAMES = new Set(["127.0.0.1", "localhost", "::1"]);
 const STARTUP_TIMEOUT_MS = 15_000;
@@ -37,6 +37,12 @@ function getRuntimeStatePath(config) {
     const origin = new URL(config.origin).hostname.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
     return path.join(homedir(), ".openclaw", "run", FORGE_PLUGIN_ID, `${origin}-${config.port}.json`);
 }
+function getRuntimeStateDir() {
+    return path.join(homedir(), ".openclaw", "run", FORGE_PLUGIN_ID);
+}
+function getRuntimeStateOrigin(config) {
+    return new URL(config.origin).hostname.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+}
 function getPreferredPortStatePath(origin) {
     const hostname = new URL(origin).hostname.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
     return path.join(homedir(), ".openclaw", "run", FORGE_PLUGIN_ID, `${hostname}-preferred-port.json`);
@@ -118,6 +124,10 @@ async function writeRuntimeState(config, pid) {
 async function clearRuntimeState(config) {
     await rm(getRuntimeStatePath(config), { force: true });
 }
+async function clearRuntimeStateForState(state) {
+    const origin = new URL(state.origin).hostname.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+    await rm(path.join(getRuntimeStateDir(), `${origin}-${state.port}.json`), { force: true });
+}
 async function readRuntimeState(config) {
     try {
         const payload = await readFile(getRuntimeStatePath(config), "utf8");
@@ -138,6 +148,52 @@ async function readRuntimeState(config) {
         return null;
     }
 }
+async function readRuntimeStateFile(filePath) {
+    try {
+        const payload = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(payload);
+        if (typeof parsed.pid !== "number" ||
+            !Number.isFinite(parsed.pid) ||
+            typeof parsed.origin !== "string" ||
+            typeof parsed.port !== "number" ||
+            !Number.isFinite(parsed.port)) {
+            return null;
+        }
+        return {
+            pid: Math.trunc(parsed.pid),
+            origin: parsed.origin,
+            port: Math.trunc(parsed.port),
+            baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : buildForgeBaseUrl(parsed.origin, parsed.port),
+            startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : new Date(0).toISOString(),
+            logPath: typeof parsed.logPath === "string" ? parsed.logPath : null
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function readRuntimeStatesForOrigin(config) {
+    const stateDir = getRuntimeStateDir();
+    const origin = getRuntimeStateOrigin(config);
+    let entries;
+    try {
+        entries = await readdir(stateDir);
+    }
+    catch {
+        return [];
+    }
+    const states = [];
+    for (const entry of entries) {
+        if (!entry.startsWith(`${origin}-`) || !entry.endsWith(".json") || entry.endsWith("-preferred-port.json")) {
+            continue;
+        }
+        const state = await readRuntimeStateFile(path.join(stateDir, entry));
+        if (state) {
+            states.push(state);
+        }
+    }
+    return states;
+}
 function processExists(pid) {
     try {
         process.kill(pid, 0);
@@ -147,6 +203,34 @@ function processExists(pid) {
         return !(error instanceof Error) || !("code" in error) || error.code !== "ESRCH";
     }
 }
+async function cleanupSupersededManagedRuntimes(config, expectedDataRoot) {
+    const states = await readRuntimeStatesForOrigin(config);
+    for (const state of states) {
+        if (state.port === config.port) {
+            continue;
+        }
+        if (!processExists(state.pid)) {
+            await clearRuntimeStateForState(state);
+            continue;
+        }
+        const alternateConfig = {
+            ...config,
+            port: state.port,
+            baseUrl: buildForgeBaseUrl(state.origin, state.port),
+            webAppUrl: buildForgeWebAppUrl(state.origin, state.port)
+        };
+        const alternateProbe = await probeForgeRuntime(alternateConfig, HEALTHCHECK_TIMEOUT_MS);
+        if (!alternateProbe.healthy || !isExpectedDataRoot(expectedDataRoot, alternateProbe.storageRoot)) {
+            continue;
+        }
+        process.kill(state.pid, "SIGTERM");
+        if (!(await waitForProcessExit(state.pid, 5_000))) {
+            process.kill(state.pid, "SIGKILL");
+            await waitForProcessExit(state.pid, 2_000);
+        }
+        await clearRuntimeStateForState(state);
+    }
+}
 async function waitForProcessExit(pid, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -490,6 +574,7 @@ export async function ensureForgeRuntimeReady(config) {
     const expectedDataRoot = getExpectedDataRoot(config);
     const initialProbe = await probeForgeRuntime(config, HEALTHCHECK_TIMEOUT_MS);
     if (initialProbe.healthy && isExpectedDataRoot(expectedDataRoot, initialProbe.storageRoot)) {
+        await cleanupSupersededManagedRuntimes(config, expectedDataRoot);
         const existingState = await readRuntimeState(config);
         if (!existingState) {
             await adoptManagedRuntimeState(config, initialProbe);

package/dist/server/server/migrations/068_remove_generated_movement_wiki_logs.sql

@@ -0,0 +1,12 @@
+UPDATE movement_stays
+SET published_note_id = NULL
+WHERE published_note_id IS NOT NULL;
+
+UPDATE movement_trips
+SET published_note_id = NULL
+WHERE published_note_id IS NOT NULL;
+
+DELETE FROM notes
+WHERE source = 'system'
+  AND kind = 'evidence'
+  AND json_extract(frontmatter_json, '$.movement.kind') IN ('stay', 'trip');

package/dist/server/server/src/app.js

@@ -9179,7 +9179,8 @@ export async function buildServer(options = {}) {
             pages: listWikiPages({
                 spaceId: query.spaceId,
                 kind: query.kind,
-                limit: query.limit ? Number(query.limit) : undefined
+                limit: query.limit ? Number(query.limit) : undefined,
+                includeHidden: query.includeHidden === "true"
             })
         };
     });

package/dist/server/server/src/discovery-advertiser.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import { promisify } from "node:util";
 import bonjourService from "bonjour-service";
 import { logForgeDebug } from "./debug.js";
-import { companionIrohApiBaseUrlFromNodeId, companionIrohUiBaseUrlFromNodeId, getCompanionIrohStatus } from "./services/companion-iroh.js";
+import { getCompanionIrohStatus } from "./services/companion-iroh.js";
 const execFileAsync = promisify(execFile);
 const BonjourConstructor = bonjourService.Bonjour ??
     bonjourService.default ??
@@ -37,12 +37,8 @@ export async function startForgeDiscoveryAdvertiser(options) {
                 tsApiBaseUrl: tailscaleTargets.apiBaseUrl ?? "",
                 tsUiBaseUrl: tailscaleTargets.uiBaseUrl ?? "",
                 tsDnsName: tailscaleTargets.dnsName ?? "",
-                irohApiBaseUrl: irohNodeId
-                    ? companionIrohApiBaseUrlFromNodeId(irohNodeId)
-                    : "",
-                irohUiBaseUrl: irohNodeId
-                    ? companionIrohUiBaseUrlFromNodeId(irohNodeId)
-                    : "",
+                irohApiBaseUrl: irohNodeId ? tailscaleTargets.apiBaseUrl ?? "" : "",
+                irohUiBaseUrl: irohNodeId ? tailscaleTargets.uiBaseUrl ?? "" : "",
                 irohProvider: irohNodeId ? "forge-companion-iroh" : "",
                 irohNodeId: irohNodeId ?? "",
                 irohRelay: irohTransport.pairPayload?.relay ?? "",

package/dist/server/server/src/managers/platform/openai-responses-provider.js

@@ -20,8 +20,11 @@ const MODEL_CONTEXT_WINDOWS = {
 };
 const DEFAULT_CONTEXT_WINDOW = 400_000;
 const RESERVED_RESPONSE_TOKENS = 140_000;
+const CODEX_WIKI_COMPILE_CONTEXT_WINDOW = 120_000;
+const CODEX_WIKI_COMPILE_RESERVED_RESPONSE_TOKENS = 60_000;
 const APPROX_CHARS_PER_TOKEN = 4;
 const REQUEST_TIMEOUT_MS = 90_000;
+const CODEX_FOREGROUND_COMPILE_TIMEOUT_MS = 10 * 60_000;
 const BACKGROUND_POLL_INTERVAL_MS = 2_000;
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const CODEX_JWT_CLAIM_PATH = "https://api.openai.com/auth";
@@ -164,6 +167,106 @@ function parseOutputText(payload) {
     }
     return null;
 }
+function buildOutputTextPayload(text) {
+    return {
+        status: "completed",
+        output: [
+            {
+                content: [{ type: "output_text", text }]
+            }
+        ]
+    };
+}
+function parseCodexEventStreamPayload(streamText) {
+    const chunks = [];
+    let latestResponse = null;
+    let failedError = null;
+    let dataLines = [];
+    const flushEvent = () => {
+        if (dataLines.length === 0) {
+            return;
+        }
+        const raw = dataLines.join("\n");
+        dataLines = [];
+        if (raw.trim() === "[DONE]") {
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const payloadType = typeof payload.type === "string" ? payload.type : null;
+        if (payloadType === "response.output_text.delta") {
+            if (typeof payload.delta === "string") {
+                chunks.push(payload.delta);
+            }
+            return;
+        }
+        if (payloadType === "response.output_text.done") {
+            if (typeof payload.text === "string" && chunks.length === 0) {
+                chunks.push(payload.text);
+            }
+            return;
+        }
+        if (payloadType === "response.completed" ||
+            payloadType === "response.failed") {
+            const response = payload.response;
+            if (response && typeof response === "object") {
+                latestResponse = response;
+                const text = parseOutputText(latestResponse);
+                if (text && chunks.length === 0) {
+                    chunks.push(text);
+                }
+            }
+            if (payloadType === "response.failed") {
+                failedError =
+                    payload.error ??
+                        latestResponse?.error ??
+                        "Codex response failed.";
+            }
+        }
+    };
+    for (const line of streamText.split(/\r?\n/)) {
+        if (line === "") {
+            flushEvent();
+            continue;
+        }
+        if (line.startsWith(":")) {
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            dataLines.push(line.slice("data:".length).trimStart());
+        }
+    }
+    flushEvent();
+    if (failedError) {
+        throw new Error(`Codex response failed: ${JSON.stringify(failedError)}`);
+    }
+    const text = chunks.join("");
+    if (latestResponse) {
+        if (!parseOutputText(latestResponse) && text) {
+            return buildOutputTextPayload(text);
+        }
+        return latestResponse;
+    }
+    if (text) {
+        return buildOutputTextPayload(text);
+    }
+    try {
+        return JSON.parse(streamText);
+    }
+    catch {
+        return buildOutputTextPayload("");
+    }
+}
+async function readProviderPayload(response, profile) {
+    return isCodexProfile(profile)
+        ? parseCodexEventStreamPayload(await response.text())
+        : readJsonPayload(response);
+}
 function readReasoningEffort(profile) {
     return typeof profile.metadata.reasoningEffort === "string"
         ? profile.metadata.reasoningEffort
@@ -233,6 +336,7 @@ function buildRequestHeaders(profile, apiKey, options = {}) {
     headers["OpenAI-Beta"] = "responses=experimental";
     headers.originator = "pi";
     headers["chatgpt-account-id"] = extractCodexAccountId(apiKey);
+    headers.accept = "text/event-stream";
     return headers;
 }
 function buildReasoningConfiguration(profile) {
@@ -250,12 +354,21 @@ function buildTextConfiguration(options) {
     }
     return Object.keys(text).length > 0 ? text : undefined;
 }
+function buildInstructionsPayload(profile, instructions) {
+    return isCodexProfile(profile) ? { instructions } : {};
+}
 function estimateTokens(text) {
     return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
 }
 function computeSourceExcerpt(profile, sourceText) {
-    const contextWindow = MODEL_CONTEXT_WINDOWS[profile.model] ?? DEFAULT_CONTEXT_WINDOW;
-    const inputBudget = Math.max(16_000, contextWindow - RESERVED_RESPONSE_TOKENS);
+    const configuredContextWindow = MODEL_CONTEXT_WINDOWS[profile.model] ?? DEFAULT_CONTEXT_WINDOW;
+    const contextWindow = isCodexProfile(profile)
+        ? Math.min(configuredContextWindow, CODEX_WIKI_COMPILE_CONTEXT_WINDOW)
+        : configuredContextWindow;
+    const reservedResponseTokens = isCodexProfile(profile)
+        ? CODEX_WIKI_COMPILE_RESERVED_RESPONSE_TOKENS
+        : RESERVED_RESPONSE_TOKENS;
+    const inputBudget = Math.max(16_000, contextWindow - reservedResponseTokens);
     const estimatedTokens = estimateTokens(sourceText);
     if (estimatedTokens <= inputBudget) {
         return {
@@ -359,7 +472,11 @@ export class OpenAiResponsesProvider {
                 }),
                 body: JSON.stringify({
                     model: profile.model,
-                    input: "Reply with the single word ok.",
+                    ...buildInstructionsPayload(profile, "Reply with the single word ok."),
+                    input: isCodexProfile(profile)
+                        ? "Connection test."
+                        : "Reply with the single word ok.",
+                    ...(isCodexProfile(profile) ? { stream: true, store: false } : {}),
                     max_output_tokens: 24,
                     reasoning: buildReasoningConfiguration(profile),
                     text: buildTextConfiguration({ profile })
@@ -404,7 +521,7 @@ export class OpenAiResponsesProvider {
             });
             throw new Error(`OpenAI connection test failed (${response.status})${message ? `: ${message}` : ""}`);
         }
-        const payload = await readJsonPayload(response);
+        const payload = await readProviderPayload(response, profile);
         emitDiagnostic(logger, {
             level: "info",
             message: "OpenAI connection test completed.",
@@ -440,20 +557,31 @@ export class OpenAiResponsesProvider {
             }),
             body: JSON.stringify({
                 model: profile.model,
-                input: [
-                    ...(systemPrompt?.trim()
-                        ? [
-                            {
-                                role: "system",
-                                content: [{ type: "input_text", text: systemPrompt.trim() }]
-                            }
-                        ]
-                        : []),
-                    {
-                        role: "user",
-                        content: [{ type: "input_text", text: prompt }]
-                    }
-                ],
+                ...buildInstructionsPayload(profile, systemPrompt?.trim() || "Follow the user's request."),
+                input: isCodexProfile(profile)
+                    ? [
+                        {
+                            role: "user",
+                            content: [{ type: "input_text", text: prompt }]
+                        }
+                    ]
+                    : [
+                        ...(systemPrompt?.trim()
+                            ? [
+                                {
+                                    role: "system",
+                                    content: [
+                                        { type: "input_text", text: systemPrompt.trim() }
+                                    ]
+                                }
+                            ]
+                            : []),
+                        {
+                            role: "user",
+                            content: [{ type: "input_text", text: prompt }]
+                        }
+                    ],
+                ...(isCodexProfile(profile) ? { stream: true, store: false } : {}),
                 reasoning: buildReasoningConfiguration(profile),
                 text: buildTextConfiguration({ profile }),
                 max_output_tokens: 1200
@@ -463,7 +591,7 @@ export class OpenAiResponsesProvider {
             const message = await response.text();
             throw new Error(`OpenAI text prompt failed (${response.status})${message ? `: ${message}` : ""}`);
         }
-        const payload = await readJsonPayload(response);
+        const payload = await readProviderPayload(response, profile);
         return {
             outputText: parseOutputText(payload)?.trim() || ""
         };
@@ -477,16 +605,16 @@ export class OpenAiResponsesProvider {
             "Goal:",
             "- Produce one main overview page in markdown.",
             "- Split durable subtopics into articleCandidates with full draft markdown.",
-            "- Propose Forge entities only when the source clearly supports a durable record.",
+            "- Propose structured operational entities only when the source clearly supports a durable record.",
             "- Suggest page updates only when the source clearly belongs in an existing page instead of a new page.",
             "What Forge expects:",
             "- The main markdown should be a readable overview or anchor page, not a raw source dump.",
             "- articleCandidates should contain real draft wiki pages with their own markdown, not just titles.",
             "- entityProposals must use one of these entityType values only: goal, project, task, habit, strategy, psyche_value, note.",
             "- Use suggestedFields only for fields that truly fit the entity type. Use null for unknown scalar fields and [] for unknown list fields.",
-            "- Keep entity proposals conservative. Prefer wiki pages when the source is informative but not actionable enough for a Forge entity.",
+            "- Keep structured operational entity proposals conservative. Prefer wiki page entities when the source is informative but not actionable enough for goals, projects, tasks, habits, strategies, values, or evidence notes.",
             "Forge ontology:",
-            "- Forge has two durable knowledge surfaces: wiki pages and structured entities.",
+            "- Forge has two durable entity families: wiki page entities and structured operational entities.",
             "- Use wiki pages for rich context, summaries, explanations, relationships, timelines, source synthesis, and themes that are broader than one action item.",
             "- Use entities for operational objects that Forge can track directly: goals, projects, tasks, habits, strategies, psyche values, and durable notes.",
             "- When the same topic needs both explanation and operations, create both: a wiki page for context and an entity proposal for the operational record.",
@@ -498,11 +626,25 @@ export class OpenAiResponsesProvider {
             "- For chats and transcripts, extract the durable parts: people, relationships, ongoing projects, commitments, habits, values, decisions, questions, sources, and evidence.",
             "- Merge repetitive back-and-forth into concise summaries.",
             "- Use short quotes only when the exact phrase matters.",
+            "Sensitive information rules:",
+            "- Never store or reproduce secrets, passwords, passphrases, recovery codes, API keys, access tokens, refresh tokens, session cookies, private keys, seed phrases, one-time codes, full payment card numbers, or equivalent credentials.",
+            "- If the source contains a secret or credential, replace the value with [REDACTED SECRET] and keep only the minimum non-secret context needed to explain why it appeared.",
+            "- Do not create wiki pages, notes, entity proposals, aliases, tags, titles, or page update suggestions that preserve secret values.",
             "How to split pages:",
             "- Keep markdown as the overview page for this source.",
             "- If one topic deserves its own page, put it in articleCandidates with title, slug, summary, rationale, markdown, tags, aliases, and parentSlug.",
             "- Use parentSlug when the draft page clearly belongs under an existing Forge wiki branch such as people, projects, concepts, sources, or chronicle.",
+            "- For chats and message logs, create articleCandidates for durable people, family members, partners, collaborators, sources, places, projects, important dated events, recurring themes, and concepts when the source contains enough reusable context to make a useful page.",
+            "- Do not leave durable people only as [[links]] when the source gives relationship, role, timeline, or follow-up context; create a lightweight person page candidate instead.",
+            "- Do not leave important or specific events only as bullets in the overview when they have their own timeline, decision, consequence, open loop, or later follow-up value; create a chronicle page candidate instead.",
+            "- Do not leave recurring concepts only as inline observations when the source gives definitions, examples, tradeoffs, or repeated behavior patterns; create a concept page candidate instead.",
             "- Do not create articleCandidates for every minor mention; only create pages that would be useful to reopen later.",
+            "Coverage audit before output:",
+            "- Before final JSON, scan the source for page-worthy entities in these categories: people, family/partners, organizations, places, sources/files/links, dated events, decisions, recurring concepts, health/care episodes, projects/plans, and relationship contexts.",
+            "- For each category with enough durable context, either create an articleCandidate or make the reason for not splitting clear inside the overview page.",
+            "- For a close relationship chat, it is normal to create several page candidates: the source/export page, the main person page, close family/partner pages when named with context, and major event pages such as meetups, care crises, travel episodes, or important decisions.",
+            "- Prefer fewer high-quality pages over many stubs, but do not collapse distinct durable people or major events into one page merely because they came from the same file.",
+            "- If the source has a named spouse/partner, family member, collaborator, or recurring person with role/context/follow-up value, create a person page candidate even if the page is short.",
             "Useful high-level wiki themes:",
             "- people: people, collaborators, family, teams, roles, relationship context.",
             "- projects: bounded initiatives, active efforts, plans, milestones, workstreams.",
@@ -528,7 +670,7 @@ export class OpenAiResponsesProvider {
             "Entity proposal rules:",
             "- Never invent IDs.",
             "- Do not propose an entity just because it is mentioned once without durable importance.",
-            "- People, concepts, sources, places, and broad life areas are usually wiki pages, not Forge entities.",
+            "- People, concepts, sources, places, and broad life areas are usually wiki page entities, not structured operational entity proposals.",
             "- Goals should be outcomes, not chores.",
             "- Projects should group multiple steps or phases, not a single errand.",
             "- Tasks should be concrete and actionable enough to do soon.",
@@ -617,6 +759,8 @@ export class OpenAiResponsesProvider {
             role: "user",
             content: userContent
         });
+        const requestInputs = isCodexProfile(profile) ? inputs.slice(1) : inputs;
+        const useStoredBackgroundResponse = !isCodexProfile(profile);
         let payload;
         let responseId = resumeResponseId?.trim() || null;
         if (responseId) {
@@ -667,11 +811,17 @@ export class OpenAiResponsesProvider {
                     }),
                     body: JSON.stringify({
                         model: profile.model,
-                        input: inputs,
-                        store: true,
-                        background: true,
-                        prompt_cache_retention: profile.model === "gpt-5.4" ? "24h" : "in_memory",
-                        prompt_cache_key: `forge-wiki-ingest:${profile.model}:${input.parseStrategy}:${input.mimeType}`,
+                        ...buildInstructionsPayload(profile, prompt),
+                        input: requestInputs,
+                        store: useStoredBackgroundResponse,
+                        ...(isCodexProfile(profile) ? { stream: true } : {}),
+                        ...(useStoredBackgroundResponse
+                            ? {
+                                background: true,
+                                prompt_cache_retention: profile.model === "gpt-5.4" ? "24h" : "in_memory",
+                                prompt_cache_key: `forge-wiki-ingest:${profile.model}:${input.parseStrategy}:${input.mimeType}`
+                            }
+                            : {}),
                         reasoning: buildReasoningConfiguration(profile),
                         text: buildTextConfiguration({
                             profile,
@@ -683,7 +833,9 @@ export class OpenAiResponsesProvider {
                             }
                         })
                     }),
-                    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+                    signal: AbortSignal.timeout(isCodexProfile(profile)
+                        ? CODEX_FOREGROUND_COMPILE_TIMEOUT_MS
+                        : REQUEST_TIMEOUT_MS)
                 });
             }
             catch (error) {
@@ -733,17 +885,21 @@ export class OpenAiResponsesProvider {
                 });
                 throw new Error(`LLM compilation failed: ${createResponse.status}${message ? `: ${message}` : ""}`);
             }
-            payload = await readJsonPayload(createResponse);
+            payload = await readProviderPayload(createResponse, profile);
             responseId = readResponseId(payload);
-            if (!responseId) {
+            if (useStoredBackgroundResponse && !responseId) {
                 throw new Error("OpenAI background response did not include an id for polling.");
             }
             emitDiagnostic(logger, {
                 level: "info",
-                message: "OpenAI accepted the wiki compilation job for background processing.",
+                message: useStoredBackgroundResponse
+                    ? "OpenAI accepted the wiki compilation job for background processing."
+                    : "OpenAI Codex returned a foreground wiki compilation response.",
                 details: {
                     scope: "wiki_llm",
-                    eventKey: "llm_compile_background_started",
+                    eventKey: useStoredBackgroundResponse
+                        ? "llm_compile_background_started"
+                        : "llm_compile_foreground_completed",
                     provider: profile.provider,
                     baseUrl: profile.baseUrl,
                     model: profile.model,
@@ -755,7 +911,8 @@ export class OpenAiResponsesProvider {
         }
         let pollCount = 0;
         let consecutivePollFailures = 0;
-        while (!isTerminalBackgroundStatus(readResponseStatus(payload))) {
+        while (useStoredBackgroundResponse &&
+            !isTerminalBackgroundStatus(readResponseStatus(payload))) {
             await new Promise((resolve) => setTimeout(resolve, BACKGROUND_POLL_INTERVAL_MS));
             try {
                 const pollResponse = await fetch(buildResponsesUrl(profile, responseId), {
@@ -838,7 +995,7 @@ export class OpenAiResponsesProvider {
             }
         }
         const finalStatus = readResponseStatus(payload);
-        if (finalStatus !== "completed") {
+        if (finalStatus && finalStatus !== "completed") {
             const errorMessage = readResponseError(payload) ??
                 `OpenAI background wiki compilation ended with status ${finalStatus}.`;
             emitDiagnostic(logger, {

package/dist/server/server/src/movement.js

@@ -3,11 +3,10 @@ import { z } from "zod";
 import { getDatabase } from "./db.js";
 import { HttpError } from "./errors.js";
 import { recordActivityEvent } from "./repositories/activity-events.js";
-import { createNote, getNoteById, updateNote } from "./repositories/notes.js";
+import { getNoteById, updateNote } from "./repositories/notes.js";
 import { createManualRewardGrant } from "./repositories/rewards.js";
 import { listTaskRuns } from "./repositories/task-runs.js";
 import { getDefaultUser } from "./repositories/users.js";
-import { listWikiSpaces } from "./repositories/wiki-memory.js";
 import { getScreenTimeOverlapSummary } from "./screen-time.js";
 const movementPublishModeSchema = z.enum([
     "auto_publish",
@@ -206,7 +205,7 @@ const movementTripInputSchema = z.object({
 });
 export const movementSettingsInputSchema = z.object({
     trackingEnabled: z.boolean().default(false),
-    publishMode: movementPublishModeSchema.default("auto_publish"),
+    publishMode: movementPublishModeSchema.default("draft_review"),
     retentionMode: movementRetentionModeSchema.default("aggregates_only"),
     locationPermissionStatus: z.string().trim().default("not_determined"),
     motionPermissionStatus: z.string().trim().default("unknown"),
@@ -1030,7 +1029,7 @@ function defaultMovementSettings(userId) {
     return {
         userId,
         trackingEnabled: false,
-        publishMode: "auto_publish",
+        publishMode: "draft_review",
         retentionMode: "aggregates_only",
         locationPermissionStatus: "not_determined",
         motionPermissionStatus: "unknown",
@@ -1278,7 +1277,7 @@ function ensureMovementSettings(userId) {
          background_tracking_ready, last_companion_sync_at, metadata_json,
          created_at, updated_at
        )
-       VALUES (?, 0, 'auto_publish', 'aggregates_only', 'not_determined', 'unknown', 0, NULL, '{}', ?, ?)`)
+       VALUES (?, 0, 'draft_review', 'aggregates_only', 'not_determined', 'unknown', 0, NULL, '{}', ?, ?)`)
         .run(userId, now, now);
     return getMovementSettingsRow(userId);
 }
@@ -1363,9 +1362,6 @@ function listTripStops(tripIds) {
        ORDER BY trip_id ASC, sequence_index ASC`)
         .all(...tripIds);
 }
-function defaultSpaceId() {
-    return listWikiSpaces()[0]?.id;
-}
 function syncPlaceWikiMetadata(placeId) {
     const row = getDatabase()
         .prepare(`SELECT *
@@ -1561,176 +1557,6 @@ function resolvePlaceForPatch(input) {
     }
     return undefined;
 }
-function createMovementNote(input) {
-    const spaceId = defaultSpaceId();
-    if (!spaceId) {
-        return null;
-    }
-    return createNote({
-        kind: "evidence",
-        title: input.title,
-        slug: "",
-        summary: "",
-        contentMarkdown: input.contentMarkdown,
-        spaceId,
-        parentSlug: null,
-        indexOrder: 0,
-        showInIndex: false,
-        aliases: [],
-        userId: input.userId,
-        author: null,
-        links: [],
-        tags: input.tags,
-        destroyAt: null,
-        sourcePath: "",
-        frontmatter: input.frontmatter,
-        revisionHash: ""
-    }, { actor: "Movement sync", source: "system" });
-}
-function formatMovementDurationForNote(valueSeconds) {
-    if (valueSeconds >= 86_400) {
-        return `${round(valueSeconds / 86_400, 1)} days`;
-    }
-    if (valueSeconds >= 3_600) {
-        return `${round(valueSeconds / 3_600, 1)} hours`;
-    }
-    return `${Math.max(1, Math.round(valueSeconds / 60))} minutes`;
-}
-function mergeMovementNoteTags(existingTags, existingFrontmatter, generatedTags) {
-    const movement = existingFrontmatter.movement &&
-        typeof existingFrontmatter.movement === "object" &&
-        !Array.isArray(existingFrontmatter.movement)
-        ? existingFrontmatter.movement
-        : null;
-    const previousGeneratedTags = Array.isArray(movement?.generatedTags)
-        ? movement.generatedTags.filter((value) => typeof value === "string")
-        : [];
-    const previousGeneratedTagSet = new Set(previousGeneratedTags.map((tag) => tag.toLowerCase()));
-    const preservedTags = existingTags.filter((tag) => !previousGeneratedTagSet.has(tag.toLowerCase()));
-    return uniqStrings([...preservedTags, ...generatedTags]);
-}
-function syncMovementNote(input) {
-    const existingNote = input.publishedNoteId
-        ? getNoteById(input.publishedNoteId)
-        : null;
-    if (existingNote && !Array.isArray(existingNote)) {
-        const updated = updateNote(existingNote.id, {
-            title: input.title,
-            contentMarkdown: input.contentMarkdown,
-            tags: mergeMovementNoteTags(existingNote.tags ?? [], existingNote.frontmatter, input.generatedTags),
-            frontmatter: {
-                ...existingNote.frontmatter,
-                ...input.frontmatter
-            }
-        }, { actor: "Movement sync", source: "system" });
-        return updated?.id ?? existingNote.id;
-    }
-    const created = createMovementNote({
-        userId: input.userId,
-        title: input.title,
-        contentMarkdown: input.contentMarkdown,
-        tags: input.generatedTags,
-        frontmatter: input.frontmatter
-    });
-    return created?.id ?? null;
-}
-function syncStayNote(settings, stay, place) {
-    if (!settings || settings.publishMode === "no_publish") {
-        return null;
-    }
-    const label = place?.label || stay.label || "Unlabeled stay";
-    const durationSecondsValue = durationSeconds(stay.started_at, stay.ended_at);
-    const live = stay.status.trim().toLowerCase() !== "completed" &&
-        stay.status.trim().toLowerCase() !== "closed";
-    const generatedTags = uniqStrings([
-        "movement",
-        "stay",
-        ...(place ? safeJsonParse(place.category_tags_json, []) : [])
-    ]);
-    const content = [
-        live ? `Currently staying at **${label}**.` : `Stayed at **${label}**.`,
-        "",
-        `- Started: ${stay.started_at}`,
-        `- ${live ? "Current end" : "Ended"}: ${stay.ended_at}`,
-        `- Duration: ${formatMovementDurationForNote(durationSecondsValue)}`,
-        `- Radius: ${Math.round(stay.radius_meters)} m`,
-        `- Classification: ${stay.classification || "stationary"}`
-    ].join("\n");
-    return syncMovementNote({
-        userId: stay.user_id,
-        publishedNoteId: stay.published_note_id,
-        title: `Stay · ${label}`,
-        contentMarkdown: content,
-        generatedTags,
-        frontmatter: {
-            observedAt: stay.started_at,
-            movement: {
-                kind: "stay",
-                state: live ? "live" : "closed",
-                stayId: stay.id,
-                publishMode: settings.publishMode,
-                placeId: place?.id ?? null,
-                placeLabel: label,
-                startedAt: stay.started_at,
-                endedAt: stay.ended_at,
-                durationSeconds: durationSecondsValue,
-                generatedTags
-            }
-        }
-    });
-}
-function syncTripNote(settings, trip, startPlace, endPlace) {
-    if (!settings || settings.publishMode === "no_publish") {
-        return null;
-    }
-    const startLabel = startPlace?.label || "Unknown start";
-    const endLabel = endPlace?.label || "Unknown end";
-    const durationSecondsValue = durationSeconds(trip.started_at, trip.ended_at);
-    const distanceKm = round(trip.distance_meters / 1000, 2);
-    const live = trip.status.trim().toLowerCase() !== "completed" &&
-        trip.status.trim().toLowerCase() !== "closed";
-    const generatedTags = uniqStrings([
-        "movement",
-        "trip",
-        ...safeJsonParse(trip.tags_json, [])
-    ]);
-    const content = [
-        live
-            ? `Currently moving from **${startLabel}** to **${endLabel}**.`
-            : `Travelled from **${startLabel}** to **${endLabel}**.`,
-        "",
-        `- Started: ${trip.started_at}`,
-        `- ${live ? "Current end" : "Ended"}: ${trip.ended_at}`,
-        `- Duration: ${formatMovementDurationForNote(durationSecondsValue)}`,
-        `- Distance: ${distanceKm} km`,
-        `- Activity: ${trip.activity_type || trip.travel_mode}`
-    ].join("\n");
-    return syncMovementNote({
-        userId: trip.user_id,
-        publishedNoteId: trip.published_note_id,
-        title: `Trip · ${startLabel} → ${endLabel}`,
-        contentMarkdown: content,
-        generatedTags,
-        frontmatter: {
-            observedAt: trip.started_at,
-            movement: {
-                kind: "trip",
-                state: live ? "live" : "closed",
-                tripId: trip.id,
-                publishMode: settings.publishMode,
-                startPlaceId: startPlace?.id ?? null,
-                endPlaceId: endPlace?.id ?? null,
-                startPlaceLabel: startLabel,
-                endPlaceLabel: endLabel,
-                startedAt: trip.started_at,
-                endedAt: trip.ended_at,
-                durationSeconds: durationSecondsValue,
-                distanceMeters: trip.distance_meters,
-                generatedTags
-            }
-        }
-    });
-}
 function awardMovementXp(input) {
     const deltaXp = estimateMovementXp(input.categoryTags, input.distanceMeters);
     if (deltaXp <= 0) {
@@ -1905,16 +1731,6 @@ function upsertMovementStay(pairing, settings, input) {
         .prepare(`SELECT * FROM movement_stays WHERE user_id = ? AND external_uid = ?`)
         .get(pairing.user_id, parsed.externalUid);
     const freshMetadata = safeJsonParse(fresh.metadata_json, {});
-    if (settings?.publishMode === "auto_publish" && !hasInvalidMovementRecord(freshMetadata)) {
-        const publishedNoteId = syncStayNote(settings, fresh, matchedPlace);
-        if (publishedNoteId && publishedNoteId !== fresh.published_note_id) {
-            getDatabase()
-                .prepare(`UPDATE movement_stays
-           SET published_note_id = ?, updated_at = ?
-           WHERE id = ?`)
-                .run(publishedNoteId, nowIso(), fresh.id);
-        }
-    }
     return {
         mode: existing ? "updated" : "created",
         stayId: fresh.id
@@ -2040,16 +1856,6 @@ function upsertMovementTrip(pairing, settings, input) {
         .prepare(`SELECT * FROM movement_trips WHERE id = ?`)
         .get(fresh.id);
     const freshMetadata = safeJsonParse(refreshed.metadata_json, {});
-    if (settings?.publishMode === "auto_publish" && !hasInvalidMovementRecord(freshMetadata)) {
-        const publishedNoteId = syncTripNote(settings, refreshed, startPlace, endPlace);
-        if (publishedNoteId && publishedNoteId !== refreshed.published_note_id) {
-            getDatabase()
-                .prepare(`UPDATE movement_trips
-           SET published_note_id = ?, updated_at = ?
-           WHERE id = ?`)
-                .run(publishedNoteId, nowIso(), refreshed.id);
-        }
-    }
     if (!existing && settings?.publishMode === "auto_publish" && !hasInvalidMovementRecord(freshMetadata)) {
         awardMovementXp({
             userId: pairing.user_id,

package/dist/server/server/src/repositories/wiki-memory.js

@@ -10,6 +10,8 @@ import { createNoteLinkSchema, crudEntityTypeSchema, noteKindSchema, noteSchema
 import { deleteEncryptedSecret, readEncryptedSecret, storeEncryptedSecret } from "./calendar.js";
 import { isEntityDeleted } from "./deleted-entities.js";
 import { recordDiagnosticLog } from "./diagnostic-logs.js";
+const MAX_WIKI_INGEST_TEXT_CHUNK_CHARS = 220_000;
+const WIKI_INGEST_TEXT_CHUNK_OVERLAP_CHARS = 2_000;
 const wikiSpaceSchema = z.object({
     id: z.string(),
     slug: z.string(),
@@ -1515,6 +1517,7 @@ export function listWikiPages(query) {
     ensureWikiSpaceSeedPages(spaceId);
     return listAllNotes()
         .filter((note) => note.spaceId === spaceId)
+        .filter((note) => (query.includeHidden ? true : note.showInIndex))
         .filter((note) => (query.kind ? note.kind === query.kind : true))
         .sort(compareWikiPageOrder)
         .slice(0, query.limit ?? 100);
@@ -1638,6 +1641,7 @@ export async function searchWikiPages(input, secrets) {
     const parsed = wikiSearchQuerySchema.parse(input);
     const pages = listAllNotes()
         .filter((page) => (parsed.spaceId ? page.spaceId === parsed.spaceId : true))
+        .filter((page) => page.showInIndex)
         .filter((page) => (parsed.kind ? page.kind === parsed.kind : true));
     const scores = new Map();
     const addScore = (noteId, value) => {
@@ -2015,6 +2019,115 @@ export async function reindexWikiEmbeddings(input, secrets) {
         chunkCount
     };
 }
+function isChunkableWikiIngestTextAsset(asset) {
+    const mimeType = asset.mime_type.toLowerCase();
+    const fileName = asset.file_name.toLowerCase();
+    if (!existsSync(asset.file_path)) {
+        return false;
+    }
+    if (asset.size_bytes <= MAX_WIKI_INGEST_TEXT_CHUNK_CHARS) {
+        return false;
+    }
+    const metadata = parseJsonRecord(asset.metadata_json);
+    if (metadata?.chunkParentAssetId || metadata?.textChunked) {
+        return false;
+    }
+    return (mimeType.startsWith("text/") ||
+        fileName.endsWith(".txt") ||
+        fileName.endsWith(".md") ||
+        fileName.endsWith(".markdown") ||
+        fileName.endsWith(".csv") ||
+        fileName.endsWith(".json"));
+}
+function splitWikiIngestTextIntoChunks(sourceText, maxChars) {
+    const text = sourceText.trim();
+    if (text.length <= maxChars) {
+        return [text];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        const hardEnd = Math.min(text.length, start + maxChars);
+        let end = hardEnd;
+        if (hardEnd < text.length) {
+            const newline = text.lastIndexOf("\n", hardEnd);
+            if (newline > start + Math.floor(maxChars * 0.65)) {
+                end = newline + 1;
+            }
+        }
+        const chunk = text.slice(start, end).trim();
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        if (end >= text.length) {
+            break;
+        }
+        start = Math.max(0, end - WIKI_INGEST_TEXT_CHUNK_OVERLAP_CHARS);
+    }
+    return chunks;
+}
+async function splitLargeWikiIngestTextAsset(options) {
+    if (!isChunkableWikiIngestTextAsset(options.asset)) {
+        return 0;
+    }
+    const sourceText = await readFile(options.asset.file_path, "utf8");
+    const chunks = splitWikiIngestTextIntoChunks(sourceText, MAX_WIKI_INGEST_TEXT_CHUNK_CHARS);
+    if (chunks.length <= 1) {
+        return 0;
+    }
+    const extension = path.extname(options.asset.file_name) || ".txt";
+    const baseName = path.basename(options.asset.file_name, extension) ||
+        options.asset.file_name ||
+        "source";
+    const width = String(chunks.length).length;
+    for (const [index, chunk] of chunks.entries()) {
+        const chunkNumber = index + 1;
+        const chunkFileName = `${baseName}-part-${String(chunkNumber).padStart(width, "0")}-of-${String(chunks.length).padStart(width, "0")}${extension}`;
+        const chunkHeader = [
+            `Source file: ${options.asset.file_name}`,
+            `Source locator: ${options.asset.source_locator || options.asset.file_name}`,
+            `Chunk: ${chunkNumber}/${chunks.length}`,
+            `Parent checksum: ${options.asset.checksum}`,
+            "",
+            chunk
+        ].join("\n");
+        const persisted = await persistIngestUpload({
+            jobId: options.jobId,
+            fileName: chunkFileName,
+            mimeType: options.asset.mime_type || "text/plain",
+            payload: Buffer.from(chunkHeader, "utf8")
+        });
+        createWikiIngestAssetRecord({
+            jobId: options.jobId,
+            sourceKind: "upload",
+            sourceLocator: `${options.asset.source_locator || options.asset.file_name}#chunk-${chunkNumber}`,
+            fileName: chunkFileName,
+            mimeType: options.asset.mime_type || "text/plain",
+            filePath: persisted.filePath,
+            sizeBytes: persisted.sizeBytes,
+            checksum: persisted.checksum,
+            metadata: {
+                chunkParentAssetId: options.asset.id,
+                chunkParentChecksum: options.asset.checksum,
+                chunkIndex: chunkNumber,
+                chunkCount: chunks.length,
+                chunkOverlapChars: WIKI_INGEST_TEXT_CHUNK_OVERLAP_CHARS,
+                chunkMaxChars: MAX_WIKI_INGEST_TEXT_CHUNK_CHARS
+            }
+        });
+    }
+    updateWikiIngestAsset(options.asset.id, {
+        status: "completed",
+        metadata: {
+            ...parseJsonRecord(options.asset.metadata_json),
+            textChunked: true,
+            textChunkCount: chunks.length,
+            textChunkMaxChars: MAX_WIKI_INGEST_TEXT_CHUNK_CHARS,
+            textChunkOverlapChars: WIKI_INGEST_TEXT_CHUNK_OVERLAP_CHARS
+        }
+    });
+    return chunks.length;
+}
 function getWikiIngestJobDir(jobId) {
     return path.join(resolveDataDir(), "wiki-ingest", jobId);
 }
@@ -2613,7 +2726,10 @@ export async function processWikiIngestJob(jobId, options) {
     const initialAssets = listWikiIngestJobAssetsInternal(jobId);
     let processedFiles = initialAssets.filter((asset) => asset.status === "completed").length;
     let totalFiles = Math.max(job.total_files, initialAssets.length);
-    let hadSuccess = false;
+    let hadSuccess = (() => {
+        const counts = refreshCounts();
+        return counts.pageCount + counts.entityCount > 0;
+    })();
     while (assetQueue().length > 0) {
         const nextAsset = assetQueue().find((asset) => ["processing", "queued"].includes(asset.status));
         if (!nextAsset) {
@@ -2675,6 +2791,27 @@ export async function processWikiIngestJob(jobId, options) {
             }
             continue;
         }
+        const derivedChunkCount = await splitLargeWikiIngestTextAsset({
+            jobId,
+            asset: nextAsset
+        });
+        if (derivedChunkCount > 0) {
+            totalFiles = Math.max(derivedChunkCount, totalFiles - 1 + derivedChunkCount);
+            updateWikiIngestJob(jobId, {
+                totalFiles,
+                latestMessage: `Split ${nextAsset.file_name || "large text source"} into ${derivedChunkCount} chunks.`
+            });
+            createWikiIngestLog(jobId, `Split ${nextAsset.file_name || "large text source"} into ${derivedChunkCount} chunks.`, "info", {
+                sourceAssetId: nextAsset.id,
+                fileName: nextAsset.file_name,
+                sourceLocator: nextAsset.source_locator,
+                checksum: nextAsset.checksum,
+                chunkCount: derivedChunkCount,
+                chunkMaxChars: MAX_WIKI_INGEST_TEXT_CHUNK_CHARS,
+                chunkOverlapChars: WIKI_INGEST_TEXT_CHUNK_OVERLAP_CHARS
+            });
+            continue;
+        }
         updateWikiIngestAsset(nextAsset.id, { status: "processing" });
         currentAssetContext = {
             assetId: nextAsset.id,

package/dist/server/server/src/services/companion-iroh.js

@@ -30,10 +30,13 @@ export async function buildCompanionPairingTransport(input) {
             pairPayload: snapshot.pairPayload,
             alpn: snapshot.alpn ?? COMPANION_IROH_ALPN,
             localBaseUrl: snapshot.localBaseUrl,
+            fallbackApiBaseUrl: requestApiBaseUrl,
+            fallbackUiBaseUrl: requestUiBaseUrl,
             recreateCommand: snapshot.recreateCommand ?? undefined,
             startedAt: snapshot.startedAt ?? undefined,
             notes: [
-                "Default pairing uses Forge's Rust Iroh transport over QUIC.",
+                "Default pairing uses Forge's Rust Iroh transport over QUIC first.",
+                "The QR keeps the request API/UI URL as a direct fallback when Iroh cannot complete a request.",
                 "The QR payload carries the Iroh node id, host token, optional relay, and ALPN forge-companion/1.",
                 "Manual HTTP/TCP pairing remains available with --manual-http for advanced local setups."
             ]
@@ -200,12 +203,13 @@ function irohTransport(input) {
     const nodeId = input.pairPayload.node_id;
     return {
         transportMode: "iroh",
-        apiBaseUrl: companionIrohApiBaseUrlFromNodeId(nodeId),
-        uiBaseUrl: companionIrohUiBaseUrlFromNodeId(nodeId),
+        apiBaseUrl: input.fallbackApiBaseUrl,
+        uiBaseUrl: input.fallbackUiBaseUrl,
         transport: {
             protocol: "iroh",
             provider: "forge-companion-iroh",
             status: "ready",
+            publicBaseUrl: input.fallbackApiBaseUrl,
             localBaseUrl: input.localBaseUrl,
             nodeId,
             relay: input.pairPayload.relay,
@@ -297,6 +301,10 @@ function candidateIrohBinaries() {
     return candidateIrohAssetRoots().flatMap((root) => [
         path.join(root, "companion-iroh", "target", "release", binaryName),
         path.join(root, "companion-iroh", "target", "debug", binaryName),
+        path.join(root, "companion-iroh-src", "target", "release", binaryName),
+        path.join(root, "companion-iroh-src", "target", "debug", binaryName),
+        path.join(root, "dist", "companion-iroh-src", "target", "release", binaryName),
+        path.join(root, "dist", "companion-iroh-src", "target", "debug", binaryName),
         path.join(root, "openclaw-plugin", "dist", "companion-iroh", platformKey, binaryName),
         path.join(root, "companion-iroh", platformKey, binaryName),
         path.join(root, "companion-iroh", binaryName)
@@ -305,7 +313,8 @@ function candidateIrohBinaries() {
 function resolveCompanionIrohManifestPath() {
     const candidates = candidateIrohAssetRoots().flatMap((root) => [
         path.join(root, "companion-iroh", "Cargo.toml"),
-        path.join(root, "companion-iroh-src", "Cargo.toml")
+        path.join(root, "companion-iroh-src", "Cargo.toml"),
+        path.join(root, "dist", "companion-iroh-src", "Cargo.toml")
     ]);
     return candidates.find((candidate) => existsSync(candidate)) ?? null;
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.114",
+  "version": "0.2.116",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.114",
+  "version": "0.2.116",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "Apache-2.0",

package/server/migrations/068_remove_generated_movement_wiki_logs.sql

@@ -0,0 +1,12 @@
+UPDATE movement_stays
+SET published_note_id = NULL
+WHERE published_note_id IS NOT NULL;
+
+UPDATE movement_trips
+SET published_note_id = NULL
+WHERE published_note_id IS NOT NULL;
+
+DELETE FROM notes
+WHERE source = 'system'
+  AND kind = 'evidence'
+  AND json_extract(frontmatter_json, '$.movement.kind') IN ('stay', 'trip');