Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

fix(open-knowledge): auto-install project skill on managed open (PRD-7104) (#1993)

mike-inkeepbe3ff35f11e9
diff --git a/.changeset/auto-install-project-skill-on-managed-open.md b/.changeset/auto-install-project-skill-on-managed-open.md
new file mode 100644
index 000000000..ea2056db3
--- /dev/null
+++ b/.changeset/auto-install-project-skill-on-managed-open.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+Opening an existing Open Knowledge project now guarantees the project-local Open Knowledge skill is installed — not just on fresh project setup. Previously, projects onboarded before the project-skill installer existed had Open Knowledge MCP wiring but no skill, and reopening them never healed the gap (the project-open reclaim was refresh-only). Now, when a managed project is opened (OK Desktop) or `ok start` runs, any editor whose project MCP config carries the Open Knowledge marker (`# ok-mcp-v1`) gets its `SKILL.md` created if missing — so a restored session loads the skill, with no manual folder moves. Non–Open Knowledge folders and editors that aren't wired for this project are left untouched, and the project-skill write now runs behind the same symlink-escape guard as `ok init`.
diff --git a/packages/cli/src/commands/repair-skills.test.ts b/packages/cli/src/commands/repair-skills.test.ts
index 0b736645c..8eecbd56c 100644
--- a/packages/cli/src/commands/repair-skills.test.ts
+++ b/packages/cli/src/commands/repair-skills.test.ts
@@ -209,6 +209,215 @@ describe('repairSkills — project sweep (AC-A1, AC-A2, AC-A3)', () => {
});
});
+describe('repairSkills — project sweep create-if-wired gate', () => {
+ let scratch: ReturnType<typeof mkScratch>;
+ let projectBundleDir: string;
+ let discoveryBundleDir: string;
+ let logEvents: RepairSkillsLogEvent[];
+
+ const OK_WIRED_MCP_JSON = JSON.stringify({
+ mcpServers: {
+ 'open-knowledge': { command: '/bin/sh', args: ['-l', '-c', '# ok-mcp-v1\nexec ok mcp'] },
+ },
+ });
+ const UNWIRED_MCP_JSON = JSON.stringify({ mcpServers: { other: { command: 'node' } } });
+
+ beforeEach(() => {
+ scratch = mkScratch('create-wired');
+ projectBundleDir = join(scratch.bundles, 'project');
+ discoveryBundleDir = join(scratch.bundles, 'discovery');
+ writeBundledSkill(projectBundleDir, '9.9.9');
+ writeBundledSkill(discoveryBundleDir, '9.9.9');
+ logEvents = [];
+ });
+ afterEach(() => {
+ rmSync(scratch.root, { recursive: true, force: true });
+ });
+
+ it('creates a project SKILL.md for a host wired for OK MCP but missing the skill', async () => {
+ writeFileSync(join(scratch.project, '.mcp.json'), OK_WIRED_MCP_JSON);
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9', // user sweep version-skips for isolation
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ const claude = result.project.entries.find((e) => e.editorId === 'claude');
+ expect(claude?.outcome).toBe('created');
+ expect(result.project.entries.find((e) => e.editorId === 'cursor')?.outcome).toBe('no-token');
+ expect(result.project.entries.find((e) => e.editorId === 'codex')?.outcome).toBe('no-token');
+
+ const skillFile = join(
+ scratch.project,
+ '.claude',
+ 'skills',
+ PROJECT_SKILL_DIR_NAME,
+ 'SKILL.md',
+ );
+ expect(existsSync(skillFile)).toBe(true);
+ expect(readFileSync(skillFile, 'utf-8')).toContain('bundled-9.9.9-content');
+ expect(
+ logEvents.some((e) => e.event === 'project-skill-reclaim-created' && e.editorId === 'claude'),
+ ).toBe(true);
+ });
+
+ it('creates a project SKILL.md for cursor wired via .cursor/mcp.json', async () => {
+ mkdirSync(join(scratch.project, '.cursor'), { recursive: true });
+ writeFileSync(join(scratch.project, '.cursor', 'mcp.json'), OK_WIRED_MCP_JSON);
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9',
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ expect(result.project.entries.find((e) => e.editorId === 'cursor')?.outcome).toBe('created');
+ expect(
+ existsSync(join(scratch.project, '.cursor', 'skills', PROJECT_SKILL_DIR_NAME, 'SKILL.md')),
+ ).toBe(true);
+ });
+
+ it('creates a project SKILL.md for codex wired via .codex/config.toml (TOML, marker substring)', async () => {
+ mkdirSync(join(scratch.project, '.codex'), { recursive: true });
+ writeFileSync(
+ join(scratch.project, '.codex', 'config.toml'),
+ '[mcp_servers.open-knowledge]\ncommand = "/bin/sh"\nargs = ["-l", "-c", "# ok-mcp-v1\\nexec ok mcp"]\n',
+ );
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9',
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ expect(result.project.entries.find((e) => e.editorId === 'codex')?.outcome).toBe('created');
+ expect(
+ existsSync(join(scratch.project, '.agents', 'skills', PROJECT_SKILL_DIR_NAME, 'SKILL.md')),
+ ).toBe(true);
+ });
+
+ it('does NOT create when a host config exists but has no OK marker', async () => {
+ writeFileSync(join(scratch.project, '.mcp.json'), UNWIRED_MCP_JSON);
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9',
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ for (const entry of result.project.entries) {
+ expect(entry.outcome).toBe('no-token');
+ expect(existsSync(entry.path)).toBe(false);
+ }
+ });
+
+ it('refreshes (reclaimed) rather than re-creating when SKILL.md already exists and is wired', async () => {
+ const claudeDest = join(scratch.project, '.claude', 'skills', PROJECT_SKILL_DIR_NAME);
+ writeStaleSkillFiles(claudeDest, 'wired-refresh');
+ writeFileSync(join(scratch.project, '.mcp.json'), OK_WIRED_MCP_JSON);
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9',
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ expect(result.project.entries.find((e) => e.editorId === 'claude')?.outcome).toBe('reclaimed');
+ expect(readFileSync(join(claudeDest, 'SKILL.md'), 'utf-8')).toContain('bundled-9.9.9-content');
+ expect(existsSync(join(claudeDest, 'leftover.md'))).toBe(false);
+ });
+
+ it('refuses to create through a host dir symlink escaping the project (create path)', async () => {
+ const realFs = await import('node:fs');
+ const escapeRoot = resolve(
+ tmpdir(),
+ `repair-skills-create-escape-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+ );
+ const escapeTarget = join(escapeRoot, 'evil-claude');
+ mkdirSync(escapeTarget, { recursive: true });
+ const witness = join(escapeTarget, 'witness.txt');
+ writeFileSync(witness, 'do-not-touch');
+ try {
+ realFs.symlinkSync(escapeTarget, join(scratch.project, '.claude'));
+ writeFileSync(join(scratch.project, '.mcp.json'), OK_WIRED_MCP_JSON);
+
+ const written: Array<{ home: string; version: string }> = [];
+ const result = await repairSkills({
+ projectDir: scratch.project,
+ home: scratch.home,
+ logger: (event) => logEvents.push(event),
+ deps: depsBuilder({
+ projectBundleDir,
+ discoveryBundleDir,
+ bundledVersion: '9.9.9',
+ recordedVersion: '9.9.9',
+ writtenVersions: written,
+ }),
+ });
+
+ if (result.status !== 'done' || result.project.outcome !== 'done')
+ throw new Error('unreachable');
+ const claude = result.project.entries.find((e) => e.editorId === 'claude');
+ expect(claude?.outcome).toBe('failed');
+ expect(claude?.error).toMatch(/outside the project directory/i);
+ expect(readFileSync(witness, 'utf-8')).toBe('do-not-touch');
+ } finally {
+ rmSync(escapeRoot, { recursive: true, force: true });
+ }
+ });
+});
+
describe('repairSkills — user sweep version gate (AC-B1, AC-B2, AC-B3, AC-B4)', () => {
let scratch: ReturnType<typeof mkScratch>;
let projectBundleDir: string;
@@ -906,7 +1115,7 @@ describe('formatRepairSkillsResult — done-branch stdout formatting', () => {
},
});
expect(out).toContain('Skill reclaim complete.');
- expect(out).toContain('Project: 1 reclaimed, 1 no-token, 1 failed.');
+ expect(out).toContain('Project: 1 reclaimed, 0 created, 1 no-token, 1 failed.');
expect(out).toContain('User (9.9.9): 2 written, 2 skipped, 0 failed.');
});
diff --git a/packages/cli/src/commands/repair-skills.ts b/packages/cli/src/commands/repair-skills.ts
index bf51cbf36..c15c5fc97 100644
--- a/packages/cli/src/commands/repair-skills.ts
+++ b/packages/cli/src/commands/repair-skills.ts
@@ -19,6 +19,7 @@ import {
} from '@inkeep/open-knowledge-server';
import { Command } from 'commander';
import { assertProjectPathSafe } from '../integrations/write-project-skill.ts';
+import { CHAIN_VERSION_SENTINEL, EDITOR_TARGETS, type EditorId } from './editors.ts';
const HOSTS_WITH_USER_SKILL_DIR: ReadonlyArray<{
readonly hostDir: string;
@@ -107,7 +108,7 @@ export interface RepairSkillsContext {
fs?: RepairSkillsFsOps;
}
-export type ProjectSkillOutcome = 'no-token' | 'reclaimed' | 'failed';
+export type ProjectSkillOutcome = 'no-token' | 'reclaimed' | 'created' | 'failed';
export type UserSkillCentralOutcome = 'written' | 'overwritten' | 'failed';
export type UserSkillHostOutcome =
| 'written'
@@ -179,6 +180,16 @@ function copyDirContents(sourceDir: string, destDir: string, fs: RepairSkillsFsO
}
}
+function editorWiredForOk(configPath: string | undefined, fs: RepairSkillsFsOps): boolean {
+ if (!configPath) return false;
+ try {
+ if (!fs.existsSync(configPath)) return false;
+ return fs.readFileSync(configPath).toString('utf8').includes(CHAIN_VERSION_SENTINEL);
+ } catch {
+ return false;
+ }
+}
+
function runProjectSweep(
projectDir: string,
deps: Required<RepairSkillsDeps>,
@@ -198,7 +209,11 @@ function runProjectSweep(
for (const host of HOSTS_WITH_USER_SKILL_DIR) {
const dest = join(projectDir, host.hostDir, 'skills', PROJECT_SKILL_DIR_NAME);
const skillFile = join(dest, 'SKILL.md');
- if (!fs.existsSync(skillFile)) {
+ const skillExists = fs.existsSync(skillFile);
+ const projectConfigPath =
+ EDITOR_TARGETS[host.editorId as EditorId]?.projectConfigPath?.(projectDir);
+ const wired = !skillExists && editorWiredForOk(projectConfigPath, fs);
+ if (!skillExists && !wired) {
entries.push({
editorId: host.editorId,
hostDir: host.hostDir,
@@ -216,14 +231,15 @@ function runProjectSweep(
try {
assertProjectPathSafe(dest, projectDir);
replaceDir(sourceDir, dest, fs);
+ const outcome: ProjectSkillOutcome = skillExists ? 'reclaimed' : 'created';
entries.push({
editorId: host.editorId,
hostDir: host.hostDir,
path: dest,
- outcome: 'reclaimed',
+ outcome,
});
logger({
- event: 'project-skill-reclaim-reclaimed',
+ event: skillExists ? 'project-skill-reclaim-reclaimed' : 'project-skill-reclaim-created',
scope: 'project',
editorId: host.editorId,
path: dest,
@@ -490,9 +506,12 @@ function formatRepairSkillsResult(result: RepairSkillsResult): string {
const lines: string[] = ['Skill reclaim complete.'];
if (result.project.outcome === 'done') {
const reclaimed = result.project.entries.filter((e) => e.outcome === 'reclaimed').length;
+ const created = result.project.entries.filter((e) => e.outcome === 'created').length;
const noToken = result.project.entries.filter((e) => e.outcome === 'no-token').length;
const failed = result.project.entries.filter((e) => e.outcome === 'failed').length;
- lines.push(` Project: ${reclaimed} reclaimed, ${noToken} no-token, ${failed} failed.`);
+ lines.push(
+ ` Project: ${reclaimed} reclaimed, ${created} created, ${noToken} no-token, ${failed} failed.`,
+ );
} else {
lines.push(` Project: skipped (${result.project.reason}).`);
}
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index 74699c05b..007041edd 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -62,6 +62,7 @@ export {
type ProjectAiIntegrationsResult,
writeProjectAiIntegrations,
} from './integrations/write-project-ai-integrations.ts';
+export { assertProjectPathSafe } from './integrations/write-project-skill.ts';
export {
addOkPathsToGitExclude,
type ExcludeWriteResult,
diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts
index 00d083494..17fa8ba6a 100644
--- a/packages/desktop/src/main/index.ts
+++ b/packages/desktop/src/main/index.ts
@@ -824,21 +824,6 @@ async function openProject(
err: err instanceof Error ? err.message : String(err),
});
});
- void reclaimProjectSkillsOnProjectOpen({
- projectDir: resolvedProjectDir,
- executablePath: app.getPath('exe'),
- isPackaged: app.isPackaged,
- platform: process.platform,
- forceEnv: process.env.OK_M6B_FORCE ?? null,
- reclaimDisableEnv: process.env.OK_RECLAIM_DISABLE ?? null,
- deps: {
- resolveBundledSkillDir: () => resolveBundledSkillDir('project', { checkDesktop: false }),
- },
- }).catch((err) => {
- console.warn('[main] project-skill reclaim failed', {
- err: err instanceof Error ? err.message : String(err),
- });
- });
let didEnsureGit = false;
let flowKind: OnboardingFlowKind;
let contentDirChanged = false;
@@ -995,6 +980,25 @@ async function openProject(
}
}
+ if (discovery.kind === 'managed' || discovery.kind === 'managed-requires-confirmation') {
+ void reclaimProjectSkillsOnProjectOpen({
+ projectDir: resolvedProjectDir,
+ executablePath: app.getPath('exe'),
+ isPackaged: app.isPackaged,
+ platform: process.platform,
+ forceEnv: process.env.OK_M6B_FORCE ?? null,
+ reclaimDisableEnv: process.env.OK_RECLAIM_DISABLE ?? null,
+ createIfWired: true,
+ deps: {
+ resolveBundledSkillDir: () => resolveBundledSkillDir('project', { checkDesktop: false }),
+ },
+ }).catch((err) => {
+ console.warn('[main] project-skill reclaim failed', {
+ err: err instanceof Error ? err.message : String(err),
+ });
+ });
+ }
+
recordOnboardingFlow({
flowKind,
entryPoint,
diff --git a/packages/desktop/src/main/skill-reclaim.test.ts b/packages/desktop/src/main/skill-reclaim.test.ts
index 9f496b77e..2b195cf2d 100644
--- a/packages/desktop/src/main/skill-reclaim.test.ts
+++ b/packages/desktop/src/main/skill-reclaim.test.ts
@@ -1,11 +1,28 @@
import { afterEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import {
+ existsSync,
+ mkdirSync,
+ mkdtempSync,
+ readFileSync,
+ rmSync,
+ symlinkSync,
+ writeFileSync,
+} from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { reclaimProjectSkillsOnProjectOpen, reclaimUserSkillsOnLaunch } from './skill-reclaim.ts';
const EXE = '/Applications/Open Knowledge.app/Contents/MacOS/Open Knowledge';
+/** A `.mcp.json` body carrying the `# ok-mcp-v1` chain sentinel — the
+ * `createIfWired` signal the project sweep keys off. */
+const OK_WIRED_MCP_JSON = JSON.stringify({
+ mcpServers: {
+ 'open-knowledge': { command: '/bin/sh', args: ['-l', '-c', '# ok-mcp-v1\nexec ok mcp'] },
+ },
+});
+const UNWIRED_MCP_JSON = JSON.stringify({ mcpServers: { other: { command: 'node' } } });
+
const cleanupPaths: string[] = [];
afterEach(() => {
@@ -480,3 +497,168 @@ describe('reclaimProjectSkillsOnProjectOpen', () => {
if (r.status === 'skipped') expect(r.reason).toBe('reclaim-disabled');
});
});
+
+describe('reclaimProjectSkillsOnProjectOpen — createIfWired (managed heal path)', () => {
+ test('creates SKILL.md for a host wired for OK MCP but missing the skill', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ writeFileSync(join(projectDir, '.mcp.json'), OK_WIRED_MCP_JSON);
+ const bundle = setupBundle();
+ const events: Array<Record<string, unknown>> = [];
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => bundle },
+ logger: { event: (e) => events.push(e), warn: () => {} },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.find((e) => e.editorId === 'claude')?.status).toBe('created');
+ expect(r.entries.find((e) => e.editorId === 'cursor')?.status).toBe('no-token');
+ expect(r.entries.find((e) => e.editorId === 'codex')?.status).toBe('no-token');
+ }
+ const skillFile = join(projectDir, '.claude', 'skills', 'open-knowledge', 'SKILL.md');
+ expect(existsSync(skillFile)).toBe(true);
+ expect(readFileSync(skillFile, 'utf8')).toContain('v-new');
+ expect(
+ events.some((e) => e.event === 'project-skill-reclaim-created' && e.editorId === 'claude'),
+ ).toBe(true);
+ });
+
+ test('creates SKILL.md for cursor host wired via .cursor/mcp.json', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ mkdirSync(join(projectDir, '.cursor'), { recursive: true });
+ writeFileSync(join(projectDir, '.cursor', 'mcp.json'), OK_WIRED_MCP_JSON);
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.find((e) => e.editorId === 'cursor')?.status).toBe('created');
+ expect(r.entries.find((e) => e.editorId === 'claude')?.status).toBe('no-token');
+ }
+ expect(existsSync(join(projectDir, '.cursor', 'skills', 'open-knowledge', 'SKILL.md'))).toBe(
+ true,
+ );
+ });
+
+ test('creates SKILL.md for codex host wired via .codex/config.toml (TOML, marker substring)', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ mkdirSync(join(projectDir, '.codex'), { recursive: true });
+ writeFileSync(
+ join(projectDir, '.codex', 'config.toml'),
+ '[mcp_servers.open-knowledge]\ncommand = "/bin/sh"\nargs = ["-l", "-c", "# ok-mcp-v1\\nexec ok mcp"]\n',
+ );
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.find((e) => e.editorId === 'codex')?.status).toBe('created');
+ expect(r.entries.find((e) => e.editorId === 'claude')?.status).toBe('no-token');
+ }
+ expect(existsSync(join(projectDir, '.agents', 'skills', 'open-knowledge', 'SKILL.md'))).toBe(
+ true,
+ );
+ });
+
+ test('does NOT create when a host config exists but has no OK marker', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ writeFileSync(join(projectDir, '.mcp.json'), UNWIRED_MCP_JSON);
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.every((e) => e.status === 'no-token')).toBe(true);
+ }
+ expect(existsSync(join(projectDir, '.claude', 'skills'))).toBe(false);
+ });
+
+ test('without createIfWired, a wired host stays no-token (default no-create preserved)', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ writeFileSync(join(projectDir, '.mcp.json'), OK_WIRED_MCP_JSON);
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.every((e) => e.status === 'no-token')).toBe(true);
+ }
+ expect(existsSync(join(projectDir, '.claude'))).toBe(false);
+ });
+
+ test('existing SKILL.md is refreshed (reclaimed), not re-created, even when wired', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ const claudeSkill = join(projectDir, '.claude', 'skills', 'open-knowledge');
+ mkdirSync(claudeSkill, { recursive: true });
+ writeFileSync(join(claudeSkill, 'SKILL.md'), '---\nname: open-knowledge\n---\n# v-old\n');
+ writeFileSync(join(projectDir, '.mcp.json'), OK_WIRED_MCP_JSON);
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ expect(r.entries.find((e) => e.editorId === 'claude')?.status).toBe('reclaimed');
+ }
+ expect(readFileSync(join(claudeSkill, 'SKILL.md'), 'utf8')).toContain('v-new');
+ });
+
+ test('refuses to create through a host-dir symlink escaping the project', async () => {
+ const projectDir = mkdtempSync(join(tmpdir(), 'ok-proj-'));
+ cleanupPaths.push(projectDir);
+ const escapeTarget = mkdtempSync(join(tmpdir(), 'ok-escape-'));
+ cleanupPaths.push(escapeTarget);
+ const witness = join(escapeTarget, 'witness.txt');
+ writeFileSync(witness, 'do-not-touch');
+ symlinkSync(escapeTarget, join(projectDir, '.claude'));
+ writeFileSync(join(projectDir, '.mcp.json'), OK_WIRED_MCP_JSON);
+ const r = await reclaimProjectSkillsOnProjectOpen({
+ projectDir,
+ executablePath: EXE,
+ isPackaged: true,
+ platform: 'darwin',
+ createIfWired: true,
+ deps: { resolveBundledSkillDir: () => setupBundle() },
+ });
+ expect(r.status).toBe('done');
+ if (r.status === 'done') {
+ const claude = r.entries.find((e) => e.editorId === 'claude');
+ expect(claude?.status).toBe('failed');
+ expect(claude?.error ?? '').toMatch(/outside the project directory|symbolic link/i);
+ }
+ expect(readFileSync(witness, 'utf8')).toBe('do-not-touch');
+ });
+});
diff --git a/packages/desktop/src/main/skill-reclaim.ts b/packages/desktop/src/main/skill-reclaim.ts
index 3d5a2b4e4..fd71e8a45 100644
--- a/packages/desktop/src/main/skill-reclaim.ts
+++ b/packages/desktop/src/main/skill-reclaim.ts
@@ -8,6 +8,7 @@ import {
writeFileSync as fsWriteFileSync,
} from 'node:fs';
import { dirname, join } from 'node:path';
+import { assertProjectPathSafe, EDITOR_TARGETS, type EditorId } from '@inkeep/open-knowledge';
interface SkillReclaimLogger {
event(payload: { event: string; [key: string]: unknown }): void;
@@ -21,13 +22,15 @@ const DEFAULT_LOGGER: SkillReclaimLogger = {
const HOSTS_WITH_USER_SKILL_DIR: ReadonlyArray<{
readonly hostDir: string;
- readonly editorId: string;
+ readonly editorId: EditorId;
}> = [
{ hostDir: '.claude', editorId: 'claude' },
{ hostDir: '.cursor', editorId: 'cursor' },
{ hostDir: '.agents', editorId: 'codex' },
];
+const OK_MCP_MARKER = '# ok-mcp-v1';
+
const USER_SKILL_DIR_NAME = 'open-knowledge-discovery';
const PROJECT_SKILL_DIR_NAME = 'open-knowledge';
const LEGACY_SKILL_DIR_NAME = 'open-knowledge';
@@ -329,7 +332,7 @@ type ProjectSkillReclaimEntry = {
editorId: string;
hostDir: string;
path: string;
- status: 'no-token' | 'reclaimed' | 'failed';
+ status: 'no-token' | 'reclaimed' | 'created' | 'failed';
error?: string;
};
@@ -344,6 +347,7 @@ interface ReclaimProjectSkillsOpts {
platform: 'darwin' | 'win32' | 'linux' | string;
forceEnv?: string | null | undefined;
reclaimDisableEnv?: string | null | undefined;
+ createIfWired?: boolean;
deps: {
resolveBundledSkillDir(): string;
};
@@ -351,6 +355,16 @@ interface ReclaimProjectSkillsOpts {
logger?: SkillReclaimLogger;
}
+function editorWiredForOk(configPath: string | undefined, fs: SkillFsOps): boolean {
+ if (!configPath) return false;
+ try {
+ if (!fs.existsSync(configPath)) return false;
+ return fs.readFileSync(configPath).toString('utf8').includes(OK_MCP_MARKER);
+ } catch {
+ return false;
+ }
+}
+
export async function reclaimProjectSkillsOnProjectOpen(
opts: ReclaimProjectSkillsOpts,
): Promise<ProjectSkillReclaimResult> {
@@ -361,6 +375,7 @@ export async function reclaimProjectSkillsOnProjectOpen(
platform,
forceEnv,
reclaimDisableEnv,
+ createIfWired = false,
deps,
fs = defaultFsOps,
logger = DEFAULT_LOGGER,
@@ -386,7 +401,10 @@ export async function reclaimProjectSkillsOnProjectOpen(
for (const host of HOSTS_WITH_USER_SKILL_DIR) {
const dest = join(projectDir, host.hostDir, 'skills', PROJECT_SKILL_DIR_NAME);
const skillFile = join(dest, 'SKILL.md');
- if (!fs.existsSync(skillFile)) {
+ const skillExists = fs.existsSync(skillFile);
+ const projectConfigPath = EDITOR_TARGETS[host.editorId]?.projectConfigPath?.(projectDir);
+ const wired = !skillExists && createIfWired && editorWiredForOk(projectConfigPath, fs);
+ if (!skillExists && !wired) {
entries.push({
editorId: host.editorId,
hostDir: host.hostDir,
@@ -401,15 +419,17 @@ export async function reclaimProjectSkillsOnProjectOpen(
continue;
}
try {
+ assertProjectPathSafe(dest, projectDir);
replaceDir(sourceDir, dest, fs);
+ const status = skillExists ? 'reclaimed' : 'created';
entries.push({
editorId: host.editorId,
hostDir: host.hostDir,
path: dest,
- status: 'reclaimed',
+ status,
});
logger.event({
- event: 'project-skill-reclaim-reclaimed',
+ event: skillExists ? 'project-skill-reclaim-reclaimed' : 'project-skill-reclaim-created',
editorId: host.editorId,
path: dest,
});