@askdkc/kiokuko 0.1.16 → 0.1.19

package/dist/web/server.js

@@ -1,8 +1,9 @@
 import { randomBytes } from 'node:crypto';
 import { KiokukoError } from '../errors.js';
+import { rollbackFailedTransaction } from '../db/transaction.js';
 import { readEntry, updateCandidateEntry } from '../memory/entries.js';
 import { searchEntries } from '../memory/retrieval.js';
-import { ENTRY_KINDS, ENTRY_STATUSES, requireWorkspace } from '../serialization/validate.js';
+import { compareCanonicalStrings, ENTRY_KINDS, ENTRY_STATUSES, requireWorkspace } from '../serialization/validate.js';
 import { AgentGatewayService } from '../gateway/agent-service.js';
 import { ContextBroker } from '../context/broker.js';
 import { listContextFeedback, listIntakeFeedback, listRunFeedback } from '../context/feedback.js';
@@ -11,11 +12,28 @@ import { readAkinatorSession, readRunIntakeLink } from '../akinator/store.js';
 import { startHttpServer } from '../server/http.js';
 import { createAgentV1Handler } from '../server/agent-application.js';
 import { WEB_HTML } from './ui.js';
-import { curateMemoryCandidates, globalizeCuratorCandidate } from '../memory/curator.js';
+import { curateMemoryCandidates, curatorFacets, globalizeCuratorCandidate } from '../memory/curator.js';
+import { MEMORY_CLASSES } from '../memory/structured-memory.js';
+import { GLOBAL_WORKSPACE } from '../memory/workspaces.js';
+import { recallScopedMemory } from '../memory/scoped-memory.js';
+import { documentsFromSkillSnapshot } from '../skills/import-preparation.js';
+import { readSkillDiscoveryConfig } from '../skills/config.js';
+import { GitHubSkillSourceFetcher } from '../skills/source/github-fetcher.js';
+import { SkillSourceError } from '../skills/source/errors.js';
+import { externalSkillRequirement, externalSkillSourceFetchRequest, listExternalSkills, listExternalSkillsPage, markExternalSkillRefreshFailure, readExternalSkill, refreshExternalSkillSnapshot, setExternalSkillState } from '../skills/store.js';
+import { createSkillRegistryProvider } from '../skills/find.js';
+import { parseStrictJson } from '../setup/strict-json.js';
+import { fetchMaterializableSkillSnapshot } from '../skills/materialization-service.js';
 const DEFAULT_HOST = '127.0.0.1';
 const DEFAULT_PORT = 4173;
 const MAX_BODY_BYTES = 2 * 1024 * 1024;
 const MAX_WEB_ENTRIES = 200;
+function hasUtf8Bom(bytes) {
+    return bytes.byteLength >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf;
+}
+function isInvalidUtf8EncodingError(error) {
+    return error instanceof TypeError && 'code' in error && error.code === 'ERR_ENCODING_INVALID_ENCODED_DATA';
+}
 function jsonResponse(response, status, value) {
     const body = JSON.stringify(value);
     response.writeHead(status, {
@@ -48,20 +66,22 @@ function cookieValue(request, name) {
     }
     return undefined;
 }
-function requireUiSession(request, sessionToken) {
-    if (cookieValue(request, UI_SESSION_COOKIE) !== sessionToken) {
-        throw new KiokukoError('AUTHENTICATION_ERROR', 'Authorization is invalid');
+function requireTrustedWebOrigin(request, trustedOrigin) {
+    if (trustedOrigin === undefined) {
+        throw new KiokukoError('AUTHENTICATION_ERROR', 'Origin is invalid');
+    }
+    const expectedHost = new URL(trustedOrigin).host;
+    if (request.headers.host !== expectedHost) {
+        throw new KiokukoError('AUTHENTICATION_ERROR', 'Origin is invalid');
     }
     const origin = request.headers.origin;
-    const host = request.headers.host;
-    const expectedOrigin = host === undefined ? undefined : `http://${host}`;
-    if (origin !== undefined && (expectedOrigin === undefined || origin !== expectedOrigin)) {
+    if (origin !== undefined && origin !== trustedOrigin) {
         throw new KiokukoError('AUTHENTICATION_ERROR', 'Origin is invalid');
     }
     const referer = request.headers.referer;
     if (referer !== undefined) {
         try {
-            if (expectedOrigin === undefined || new URL(referer).origin !== expectedOrigin)
+            if (new URL(referer).origin !== trustedOrigin)
                 throw new Error('origin');
         }
         catch {
@@ -69,6 +89,11 @@ function requireUiSession(request, sessionToken) {
         }
     }
 }
+function requireUiSession(request, sessionToken) {
+    if (cookieValue(request, UI_SESSION_COOKIE) !== sessionToken) {
+        throw new KiokukoError('AUTHENTICATION_ERROR', 'Authorization is invalid');
+    }
+}
 function errorStatus(error) {
     if (!(error instanceof KiokukoError))
         return 500;
@@ -80,17 +105,48 @@ function errorStatus(error) {
         return 404;
     if (error.code === 'CONFLICT')
         return 409;
+    if (error.code === 'BACKPRESSURE')
+        return 429;
     if (error.code === 'SECURITY_REJECTION')
         return 422;
+    if (error.code === 'SERVICE_UNAVAILABLE' || error.code === 'DATABASE_ERROR')
+        return 503;
+    if (error.code === 'NOT_IMPLEMENTED')
+        return 501;
     return 500;
 }
+function boundedRetryAfterSeconds(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 1;
+    return Math.min(60, Math.max(1, Math.trunc(value)));
+}
 function errorBody(error) {
-    if (error instanceof KiokukoError) {
-        if (error.code === 'AUTHENTICATION_ERROR')
-            return { error: { code: error.code, message: 'Authorization is invalid', details: {} } };
-        return { error: { code: error.code, message: error.message, details: error.details } };
+    if (!(error instanceof KiokukoError)) {
+        return { error: { code: 'INTEGRITY_ERROR', message: 'Unexpected server error', details: {} } };
     }
-    return { error: { code: 'DATABASE_ERROR', message: 'Unexpected server error', details: {} } };
+    if (error.code === 'AUTHENTICATION_ERROR')
+        return { error: { code: error.code, message: 'Authorization is invalid', details: {} } };
+    if (error.code === 'VALIDATION_ERROR' || error.code === 'USAGE_ERROR')
+        return { error: { code: error.code, message: 'Request is invalid', details: {} } };
+    if (error.code === 'NOT_FOUND')
+        return { error: { code: error.code, message: 'Resource not found', details: {} } };
+    if (error.code === 'CONFLICT')
+        return { error: { code: error.code, message: 'Request conflicts with current state', details: {} } };
+    if (error.code === 'BACKPRESSURE')
+        return { error: { code: error.code, message: 'Service is busy', details: { retryAfterSeconds: boundedRetryAfterSeconds(error.details.retryAfterSeconds) } } };
+    if (error.code === 'DATABASE_ERROR')
+        return { error: { code: error.code, message: 'Database unavailable', details: {} } };
+    if (error.code === 'SERVICE_UNAVAILABLE')
+        return { error: { code: error.code, message: 'Service unavailable', details: {} } };
+    if (error.code === 'SECURITY_REJECTION')
+        return { error: { code: error.code, message: 'Request rejected', details: {} } };
+    if (error.code === 'INTEGRITY_ERROR')
+        return { error: { code: error.code, message: 'Internal integrity error', details: {} } };
+    if (error.code === 'PARTIAL_FAILURE')
+        return { error: { code: error.code, message: 'Operation partially failed', details: {} } };
+    if (error.code === 'NOT_IMPLEMENTED')
+        return { error: { code: error.code, message: 'Operation is not implemented', details: {} } };
+    return { error: { code: 'INTEGRITY_ERROR', message: 'Unexpected server error', details: {} } };
 }
 function asRecord(value, label) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
@@ -122,10 +178,104 @@ function limitQuery(value) {
     }
     return limit;
 }
+function invalidExternalSkillCursor() {
+    throw new KiokukoError('VALIDATION_ERROR', 'cursor is invalid');
+}
+function externalSkillCursor(record, listVersion, state) {
+    const value = [
+        1,
+        listVersion,
+        state ?? null,
+        record.sourceLocator,
+        record.slug,
+        record.provider,
+        record.skillId,
+    ];
+    return Buffer.from(JSON.stringify(value), 'utf8').toString('base64url');
+}
+function externalSkillCursorQuery(url) {
+    const values = url.searchParams.getAll('cursor');
+    if (values.length === 0)
+        return undefined;
+    if (values.length !== 1 || !/^[A-Za-z0-9_-]{1,4096}$/u.test(values[0]))
+        invalidExternalSkillCursor();
+    let decoded;
+    let parsed;
+    try {
+        decoded = Buffer.from(values[0], 'base64url');
+        if (decoded.toString('base64url') !== values[0] || decoded.byteLength > 3_000 || hasUtf8Bom(decoded))
+            invalidExternalSkillCursor();
+        parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(decoded));
+    }
+    catch (error) {
+        if (error instanceof KiokukoError)
+            throw error;
+        if (error instanceof SyntaxError || isInvalidUtf8EncodingError(error))
+            invalidExternalSkillCursor();
+        throw error;
+    }
+    if (!Array.isArray(parsed) || parsed.length !== 7 || parsed[0] !== 1
+        || typeof parsed[1] !== 'number' || !Number.isSafeInteger(parsed[1]) || parsed[1] < 0
+        || parsed[2] !== null && (typeof parsed[2] !== 'string'
+            || !['discovered', 'imported', 'blocked', 'stale', 'disabled'].includes(parsed[2]))
+        || parsed.slice(3).some((value) => typeof value !== 'string' || value.length < 1 || value.length > 2_000 || /\p{Cc}/u.test(value))) {
+        invalidExternalSkillCursor();
+    }
+    return parsed;
+}
+function externalSkillListItem(record) {
+    const metadata = record.metadata;
+    const documents = record.sourceCommit === null ? 0 : metadata.documents;
+    const technology = record.sourceCommit === null ? null : metadata.technology;
+    if (typeof documents !== 'number' || !Number.isSafeInteger(documents) || documents < 0 || documents > 64
+        || technology !== null && (typeof technology !== 'string' || technology.length < 1 || technology.length > 500)) {
+        throw new KiokukoError('INTEGRITY_ERROR', 'External skill list metadata is invalid');
+    }
+    return { ...record, metadata: { documents, technology } };
+}
+function listQuery(url, name, max = 50) {
+    const values = url.searchParams.getAll(name).map((value) => value.trim()).filter(Boolean);
+    if (values.length > max || values.some((value) => value.length > 300))
+        throw new KiokukoError('VALIDATION_ERROR', `${name} contains too many or too-large values`);
+    return [...new Set(values)];
+}
+function requireExactJsonMediaType(request) {
+    const contentTypes = [];
+    for (let index = 0; index < request.rawHeaders.length; index += 2) {
+        if (request.rawHeaders[index]?.toLowerCase() === 'content-type') {
+            contentTypes.push(request.rawHeaders[index + 1] ?? '');
+        }
+    }
+    if (contentTypes.length !== 1 || contentTypes[0].trim().toLowerCase() !== 'application/json') {
+        request.resume();
+        throw new KiokukoError('VALIDATION_ERROR', 'Content-Type must be exactly application/json');
+    }
+}
+function decodeJsonBody(bytes) {
+    if (hasUtf8Bom(bytes)) {
+        throw new KiokukoError('VALIDATION_ERROR', 'Request body must not contain a byte-order mark');
+    }
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch (error) {
+        if (isInvalidUtf8EncodingError(error)) {
+            throw new KiokukoError('VALIDATION_ERROR', 'Request body must be valid UTF-8');
+        }
+        throw error;
+    }
+}
+function requireOnlyJsonFields(payload, allowed, label) {
+    const allowedFields = new Set(allowed);
+    if (Object.keys(payload).some((field) => !allowedFields.has(field))) {
+        throw new KiokukoError('VALIDATION_ERROR', `${label} contains an unknown field`);
+    }
+}
 async function readJsonBody(request) {
+    requireExactJsonMediaType(request);
     const chunks = [];
     let size = 0;
-    const text = await new Promise((resolve, reject) => {
+    const bytes = await new Promise((resolve, reject) => {
         request.on('data', (chunk) => {
             const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             size += buffer.byteLength;
@@ -136,33 +286,53 @@ async function readJsonBody(request) {
             }
             chunks.push(buffer);
         });
-        request.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        request.on('end', () => resolve(Buffer.concat(chunks)));
         request.on('error', reject);
+        request.on('aborted', () => reject(new KiokukoError('VALIDATION_ERROR', 'Request body is incomplete')));
     });
-    if (text.trim().length === 0)
-        throw new KiokukoError('VALIDATION_ERROR', 'Request body must contain JSON');
-    try {
-        return asRecord(JSON.parse(text), 'Request body');
-    }
-    catch (error) {
-        if (error instanceof KiokukoError)
-            throw error;
-        throw new KiokukoError('VALIDATION_ERROR', 'Request body is not valid JSON');
+    const parsed = parseStrictJson(decodeJsonBody(bytes), { allowTrailingComma: false, disallowComments: true, allowEmptyContent: false }, 'Request body is not valid strict JSON');
+    return asRecord(parsed, 'Request body');
+}
+function requireNoQueryParameters(url) {
+    if (url.searchParams.entries().next().done !== true) {
+        throw new KiokukoError('VALIDATION_ERROR', 'This endpoint does not accept query parameters');
     }
 }
+async function requireEmptyBody(request) {
+    await new Promise((resolve, reject) => {
+        request.once('data', () => {
+            request.resume();
+            reject(new KiokukoError('VALIDATION_ERROR', 'Request body must be empty'));
+        });
+        request.once('end', resolve);
+        request.once('error', reject);
+        request.once('aborted', () => reject(new KiokukoError('VALIDATION_ERROR', 'Request body is incomplete')));
+    });
+}
 function workspaceSummaries(database) {
-    const summaries = new Map();
-    for (const row of database.prepare('SELECT workspace, display_name FROM repositories ORDER BY workspace ASC').all()) {
-        summaries.set(row.workspace, { workspace: row.workspace, displayName: row.display_name, count: 0 });
+    database.exec('BEGIN DEFERRED');
+    try {
+        const externalWorkspaces = new Set(listExternalSkills(database).map((skill) => skill.sourceWorkspace));
+        const summaries = new Map();
+        for (const row of database.prepare('SELECT workspace, display_name FROM repositories ORDER BY workspace ASC').all()) {
+            if (!externalWorkspaces.has(row.workspace))
+                summaries.set(row.workspace, { workspace: row.workspace, displayName: row.display_name, count: 0 });
+        }
+        for (const row of database.prepare("SELECT workspace, COUNT(*) AS count FROM entries WHERE status <> 'superseded' GROUP BY workspace").all()) {
+            if (externalWorkspaces.has(row.workspace))
+                continue;
+            const existing = summaries.get(row.workspace);
+            if (existing)
+                existing.count = Number(row.count);
+            else
+                summaries.set(row.workspace, { workspace: row.workspace, displayName: '', count: Number(row.count) });
+        }
+        database.exec('COMMIT');
+        return [...summaries.values()].sort((left, right) => compareCanonicalStrings(left.workspace, right.workspace));
     }
-    for (const row of database.prepare("SELECT workspace, COUNT(*) AS count FROM entries WHERE status <> 'superseded' GROUP BY workspace").all()) {
-        const existing = summaries.get(row.workspace);
-        if (existing)
-            existing.count = Number(row.count);
-        else
-            summaries.set(row.workspace, { workspace: row.workspace, displayName: '', count: Number(row.count) });
+    catch (error) {
+        rollbackFailedTransaction(database, error);
     }
-    return [...summaries.values()].sort((left, right) => left.workspace.localeCompare(right.workspace));
 }
 function workspaceTags(database, workspace) {
     return database
@@ -170,6 +340,12 @@ function workspaceTags(database, workspace) {
         .all(workspace)
         .map((row) => ({ tag: row.tag, count: Number(row.count) }));
 }
+function workspaceProject(database, workspace) {
+    const row = database.prepare('SELECT r.repository_id, r.workspace, l.canonical_root FROM repository_locations AS l JOIN repositories AS r ON r.repository_id = l.repository_id WHERE r.workspace = ? ORDER BY l.last_seen_at DESC, l.canonical_root ASC LIMIT 1').get(workspace);
+    if (!row)
+        return undefined;
+    return { repositoryId: row.repository_id, workspace: row.workspace, repositoryRoot: row.canonical_root, source: 'location' };
+}
 function listEntries(database, workspace, query, kind, status, tag, includeSuperseded, limit) {
     if (query.trim().length > 0) {
         const searchInput = { workspace, query, limit, includeSuperseded };
@@ -215,6 +391,112 @@ function entryIdFromPath(pathname) {
         throw new KiokukoError('VALIDATION_ERROR', 'entry id is not valid URL encoding');
     }
 }
+function externalSkillIdFromPath(pathname) {
+    const prefix = '/api/skills/';
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encoded = pathname.slice(prefix.length);
+    if (encoded.length === 0 || encoded.includes('/'))
+        throw new KiokukoError('NOT_FOUND', 'Endpoint not found');
+    try {
+        const skillId = decodeURIComponent(encoded);
+        if (skillId.length === 0 || skillId.length > 500)
+            throw new Error('invalid');
+        return skillId;
+    }
+    catch {
+        throw new KiokukoError('VALIDATION_ERROR', 'skill id is not valid URL encoding');
+    }
+}
+function externalSkillSourceFailure(error, code, message) {
+    const failure = new KiokukoError(code, message, {
+        failureCode: error.code,
+        ...(error.retryAfterSeconds === null ? {} : { retryAfterSeconds: error.retryAfterSeconds }),
+    });
+    Object.defineProperty(failure, 'cause', {
+        value: error,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return failure;
+}
+function refreshExternalSkill(context, skillId, flights) {
+    if (flights.database !== context.database) {
+        throw new KiokukoError('INTEGRITY_ERROR', 'External skill refresh coordinator is bound to another database');
+    }
+    const detail = readExternalSkill(context.database, skillId);
+    if (!detail)
+        throw new KiokukoError('NOT_FOUND', 'External skill not found');
+    if (detail.skill.sourceType !== 'github')
+        throw new KiokukoError('NOT_IMPLEMENTED', 'Only GitHub external skills can be refreshed automatically');
+    const candidate = {
+        id: detail.skill.skillId,
+        provider: detail.skill.provider,
+        name: detail.skill.name,
+        slug: detail.skill.slug,
+        source: detail.skill.sourceLocator,
+        sourceType: 'github',
+        installUrl: detail.skill.installUrl,
+        installs: detail.skill.installs,
+        duplicate: detail.skill.duplicate,
+        officialStatus: detail.skill.officialStatus,
+        auditStatus: detail.skill.auditStatus,
+    };
+    const expected = { generation: detail.skill.generation, sourceCommit: detail.skill.sourceCommit, snapshotHash: detail.skill.snapshotHash, state: detail.skill.state, lastCheckedAt: detail.skill.lastCheckedAt };
+    const flightKey = JSON.stringify([
+        skillId,
+        expected.generation,
+        expected.sourceCommit,
+        expected.snapshotHash,
+        expected.state,
+        expected.lastCheckedAt,
+    ]);
+    const existing = flights.operations.get(flightKey);
+    if (existing !== undefined)
+        return existing;
+    const operation = Promise.resolve().then(async () => {
+        try {
+            const materialized = await fetchMaterializableSkillSnapshot(context.database, candidate, {
+                provider: createSkillRegistryProvider(),
+                sourceFetcher: new GitHubSkillSourceFetcher({ token: readSkillDiscoveryConfig().githubToken }),
+                sourceRequest: externalSkillSourceFetchRequest(detail),
+                cacheWrite: (operation) => context.enqueueWrite(operation),
+            });
+            const snapshot = materialized.snapshot;
+            if (!snapshot.files.some((file) => file.primary))
+                throw new KiokukoError('VALIDATION_ERROR', 'Skill snapshot has no primary document');
+            const requirement = externalSkillRequirement(context.database, skillId);
+            return await context.enqueueWrite(() => refreshExternalSkillSnapshot(context.database, skillId, snapshot, documentsFromSkillSnapshot(snapshot), requirement, expected, undefined, materialized.authorization));
+        }
+        catch (error) {
+            if (!(error instanceof SkillSourceError))
+                throw error;
+            if (error.code === 'source_missing' || error.code === 'candidate_not_found_at_source') {
+                await context.enqueueWrite(() => markExternalSkillRefreshFailure(context.database, skillId, 'stale', expected));
+                throw externalSkillSourceFailure(error, 'CONFLICT', 'External skill source is stale');
+            }
+            if (error.code === 'skill_disabled_for_model_invocation' || error.code === 'skill_secret_detected' || error.code === 'skill_blocked') {
+                await context.enqueueWrite(() => markExternalSkillRefreshFailure(context.database, skillId, 'blocked', expected));
+                throw externalSkillSourceFailure(error, 'SECURITY_REJECTION', 'External skill snapshot was blocked');
+            }
+            if (error.code === 'source_rate_limited' || error.code === 'source_unavailable') {
+                throw externalSkillSourceFailure(error, 'SERVICE_UNAVAILABLE', 'External skill source is temporarily unavailable');
+            }
+            if (error.code === 'source_tree_truncated' || error.code === 'skill_too_large' || error.code === 'skill_validation_failed') {
+                throw externalSkillSourceFailure(error, 'SECURITY_REJECTION', 'External skill source failed validation');
+            }
+            throw error;
+        }
+    });
+    flights.operations.set(flightKey, operation);
+    const cleanup = () => {
+        if (flights.operations.get(flightKey) === operation)
+            flights.operations.delete(flightKey);
+    };
+    void operation.then(cleanup, cleanup);
+    return operation;
+}
 function operatorRunIdFromPath(pathname) {
     const prefix = '/api/operator/runs/';
     if (!pathname.startsWith(prefix) || pathname.slice(prefix.length).includes('/'))
@@ -308,7 +590,7 @@ function operatorRunDetail(context, runId) {
         untrusted: true,
     };
 }
-async function handleRequest(request, response, context, sessionToken) {
+async function handleRequest(request, response, context, sessionToken, externalSkillRefreshFlights) {
     if (request.method === 'OPTIONS') {
         response.writeHead(204, { 'cache-control': 'no-store' });
         response.end();
@@ -324,6 +606,72 @@ async function handleRequest(request, response, context, sessionToken) {
         return;
     }
     requireUiSession(request, sessionToken);
+    if (request.method === 'GET' && url.pathname === '/api/skills') {
+        if ([...url.searchParams.keys()].some((key) => key !== 'state' && key !== 'limit' && key !== 'cursor')
+            || url.searchParams.getAll('state').length > 1 || url.searchParams.getAll('limit').length > 1) {
+            throw new KiokukoError('VALIDATION_ERROR', 'External skill list query is invalid');
+        }
+        const state = enumQuery(url.searchParams.get('state'), ['discovered', 'imported', 'blocked', 'stale', 'disabled'], 'state');
+        const limit = limitQuery(url.searchParams.get('limit'));
+        const cursor = externalSkillCursorQuery(url);
+        const normalizedState = state;
+        if (cursor !== undefined && cursor[2] !== (normalizedState ?? null)) {
+            throw new KiokukoError('CONFLICT', 'External skill list filter changed; restart pagination');
+        }
+        const page = listExternalSkillsPage(context.database, {
+            ...(normalizedState === undefined ? {} : { state: normalizedState }),
+            limit,
+            ...(cursor === undefined ? {} : {
+                expectedVersion: cursor[1],
+                after: { sourceLocator: cursor[3], slug: cursor[4], provider: cursor[5], skillId: cursor[6] },
+            }),
+        });
+        const skills = page.skills.map(externalSkillListItem);
+        jsonResponse(response, 200, {
+            skills,
+            count: skills.length,
+            truncated: page.truncated,
+            nextCursor: page.truncated ? externalSkillCursor(page.skills.at(-1), page.version, normalizedState) : null,
+            untrusted: true,
+        });
+        return;
+    }
+    const isExternalSkillAction = url.pathname.endsWith('/refresh') || url.pathname.endsWith('/disable') || url.pathname.endsWith('/enable');
+    const externalSkillId = isExternalSkillAction ? undefined : externalSkillIdFromPath(url.pathname);
+    if (externalSkillId !== undefined && request.method === 'GET') {
+        requireNoQueryParameters(url);
+        const detail = readExternalSkill(context.database, externalSkillId);
+        if (!detail)
+            throw new KiokukoError('NOT_FOUND', 'External skill not found');
+        jsonResponse(response, 200, {
+            skill: externalSkillListItem(detail.skill),
+            entries: detail.entries.slice(0, MAX_WEB_ENTRIES),
+            entriesTruncated: detail.entries.length > MAX_WEB_ENTRIES,
+            untrusted: true,
+        });
+        return;
+    }
+    if (request.method === 'POST' && url.pathname.startsWith('/api/skills/') && url.pathname.endsWith('/refresh')) {
+        const skillId = externalSkillIdFromPath(url.pathname.slice(0, -'/refresh'.length));
+        if (skillId === undefined)
+            throw new KiokukoError('NOT_FOUND', 'Endpoint not found');
+        requireNoQueryParameters(url);
+        await requireEmptyBody(request);
+        jsonResponse(response, 200, await refreshExternalSkill(context, skillId, externalSkillRefreshFlights));
+        return;
+    }
+    if (request.method === 'POST' && url.pathname.startsWith('/api/skills/') && (url.pathname.endsWith('/disable') || url.pathname.endsWith('/enable'))) {
+        const suffix = url.pathname.endsWith('/disable') ? '/disable' : '/enable';
+        const skillId = externalSkillIdFromPath(url.pathname.slice(0, -suffix.length));
+        if (skillId === undefined)
+            throw new KiokukoError('NOT_FOUND', 'Endpoint not found');
+        requireNoQueryParameters(url);
+        await requireEmptyBody(request);
+        const state = suffix === '/disable' ? 'disabled' : 'imported';
+        const skill = await context.enqueueWrite(() => setExternalSkillState(context.database, skillId, state));
+        jsonResponse(response, 200, { skill, untrusted: true });
+        return;
+    }
     if (request.method === 'GET' && url.pathname === '/api/operator/runs') {
         jsonResponse(response, 200, operatorRunList(context, url));
         return;
@@ -343,17 +691,71 @@ async function handleRequest(request, response, context, sessionToken) {
         jsonResponse(response, 200, { workspace, tags });
         return;
     }
+    if (request.method === 'GET' && url.pathname === '/api/memory/recall') {
+        const workspace = requireWorkspace(url.searchParams.get('workspace') ?? '');
+        const query = url.searchParams.get('q')?.trim() ?? '';
+        if (query.length === 0)
+            throw new KiokukoError('VALIDATION_ERROR', 'q must be a non-empty search query');
+        const scope = enumQuery(url.searchParams.get('scope'), ['auto', 'project', 'ecosystem', 'global'], 'scope') ?? 'auto';
+        const project = workspace === GLOBAL_WORKSPACE ? undefined : workspaceProject(context.database, workspace);
+        if (scope !== 'global' && workspace !== GLOBAL_WORKSPACE && project === undefined)
+            throw new KiokukoError('NOT_FOUND', 'The selected workspace has no repository root for scoped recall');
+        const result = await recallScopedMemory(context.database, {
+            query,
+            scope,
+            ...(project === undefined ? {} : { project }),
+            limit: Math.min(limitQuery(url.searchParams.get('limit')), 100),
+            maxChars: 50_000,
+        });
+        jsonResponse(response, 200, { workspace, ...result });
+        return;
+    }
     if (request.method === 'GET' && url.pathname === '/api/curator/candidates') {
         const workspaceParam = url.searchParams.get('workspace');
         const skillReadyOnly = booleanQuery(url.searchParams.get('skillReadyOnly'), 'skillReadyOnly') ?? false;
-        const result = workspaceParam === null || workspaceParam === 'all'
-            ? await curateMemoryCandidates(context.database, { allWorkspaces: true, limit: Math.min(limitQuery(url.searchParams.get('limit')), 50), skillReadyOnly })
-            : await curateMemoryCandidates(context.database, { workspace: requireWorkspace(workspaceParam), limit: Math.min(limitQuery(url.searchParams.get('limit')), 50), skillReadyOnly });
+        const workspaces = listQuery(url, 'project');
+        const tags = listQuery(url, 'tag');
+        const frameworks = listQuery(url, 'framework');
+        const languages = listQuery(url, 'language');
+        const memoryClasses = listQuery(url, 'memoryClass').map((value) => enumQuery(value, MEMORY_CLASSES, 'memoryClass'));
+        const tiers = listQuery(url, 'tier').map((value) => enumQuery(value, ['unobserved', 'observed', 'repeated', 'portable'], 'tier'));
+        const tagMode = enumQuery(url.searchParams.get('tagMode'), ['any', 'all'], 'tagMode');
+        const includeGlobalized = booleanQuery(url.searchParams.get('includeGlobalized'), 'includeGlobalized') ?? false;
+        const cursor = url.searchParams.get('cursor');
+        const input = {
+            ...(workspaceParam !== null && workspaceParam !== 'all' ? { workspace: requireWorkspace(workspaceParam) } : {}),
+            ...(workspaces.length > 0 ? { workspaces } : {}),
+            ...(tags.length > 0 ? { tags } : {}),
+            ...(tagMode === undefined ? {} : { tagMode }),
+            ...(frameworks.length > 0 ? { frameworks } : {}),
+            ...(languages.length > 0 ? { languages } : {}),
+            ...(memoryClasses.length > 0 ? { memoryClasses } : {}),
+            ...(tiers.length > 0 ? { tiers } : {}),
+            ...(url.searchParams.get('search') === null ? {} : { search: url.searchParams.get('search') ?? '' }),
+            ...(cursor === null ? {} : { cursor }),
+            allWorkspaces: workspaceParam === null || workspaceParam === 'all' || workspaces.length > 0,
+            skillReadyOnly,
+            includeGlobalized,
+            limit: Math.min(limitQuery(url.searchParams.get('limit')), 50),
+        };
+        const result = await curateMemoryCandidates(context.database, input);
         jsonResponse(response, 200, result);
         return;
     }
+    if (request.method === 'GET' && url.pathname === '/api/curator/facets') {
+        const workspaceParam = url.searchParams.get('workspace');
+        const projects = listQuery(url, 'project');
+        const includeGlobalized = booleanQuery(url.searchParams.get('includeGlobalized'), 'includeGlobalized') ?? false;
+        jsonResponse(response, 200, { facets: curatorFacets(context.database, {
+                ...(workspaceParam !== null && workspaceParam !== 'all' ? { workspace: requireWorkspace(workspaceParam) } : {}),
+                ...(projects.length > 0 ? { workspaces: projects } : {}),
+                includeGlobalized,
+            }) });
+        return;
+    }
     if (request.method === 'POST' && url.pathname === '/api/curator/globalize') {
         const payload = await readJsonBody(request);
+        requireOnlyJsonFields(payload, ['workspace', 'entryId', 'expectedRevision', 'actor'], 'Curator globalize request');
         const workspace = requireWorkspace(url.searchParams.get('workspace') ?? (typeof payload.workspace === 'string' ? payload.workspace : ''));
         const result = await context.enqueueWrite(() => globalizeCuratorCandidate(context.database, {
             workspace,
@@ -384,6 +786,7 @@ async function handleRequest(request, response, context, sessionToken) {
             return;
         }
         const payload = await readJsonBody(request);
+        requireOnlyJsonFields(payload, ['expectedRevision', 'kind', 'title', 'body', 'summary', 'scope', 'provenance', 'tags', 'actor'], 'Entry update request');
         const expectedRevision = payload.expectedRevision;
         const input = {
             workspace,
@@ -412,16 +815,27 @@ async function handleRequest(request, response, context, sessionToken) {
 function isSharedServerPath(pathname) {
     return pathname.startsWith('/health/') || pathname === '/api/v1' || pathname.startsWith('/api/v1/');
 }
-function createLegacyApplication(context) {
+function createLegacyApplication(context, trustedOrigin) {
     const sharedApplication = context.createAuthenticatedApp(createAgentV1Handler(context));
     const sessionToken = randomBytes(32).toString('base64url');
+    const externalSkillRefreshFlights = {
+        database: context.database,
+        operations: new Map(),
+    };
     return (request, response) => {
+        try {
+            requireTrustedWebOrigin(request, trustedOrigin());
+        }
+        catch (error) {
+            jsonResponse(response, errorStatus(error), errorBody(error));
+            return;
+        }
         const pathname = new URL(request.url ?? '/', 'http://127.0.0.1').pathname;
         if (isSharedServerPath(pathname)) {
             sharedApplication(request, response);
             return;
         }
-        void handleRequest(request, response, context, sessionToken).catch((error) => {
+        void handleRequest(request, response, context, sessionToken, externalSkillRefreshFlights).catch((error) => {
             if (!response.headersSent)
                 jsonResponse(response, errorStatus(error), errorBody(error));
             else
@@ -430,13 +844,15 @@ function createLegacyApplication(context) {
     };
 }
 export async function startWebServer(options = {}) {
+    let trustedOrigin;
     const runtime = await startHttpServer({
         ...(options.httpOptions ?? {}),
         ...(options.databasePath === undefined ? {} : { databasePath: options.databasePath }),
         host: options.host ?? DEFAULT_HOST,
         port: options.port ?? DEFAULT_PORT,
-        applicationFactory: createLegacyApplication,
+        applicationFactory: (context) => createLegacyApplication(context, () => trustedOrigin),
     });
+    trustedOrigin = new URL(runtime.url).origin;
     return {
         server: runtime.server,
         url: runtime.url,