@oldboydev/sheldon-darwin-arm64 0.2.0 → 0.2.2

package/node_modules/@sheldon/cli/dist/help/styles.css

@@ -0,0 +1,368 @@
+@font-face {
+  font-family: 'Nunito Sans';
+  font-weight: 100 900;
+  font-style: normal;
+  font-stretch: 75% 125%;
+  src: url('fonts/NunitoSans-VariableFont_YTLC_opsz_wdth_wght.ttf') format('truetype');
+  font-display: swap;
+}
+
+:root {
+  --brand-navy: #001663;
+  --brand-navy-700: #001152;
+  --brand-navy-300: #5572b3;
+  --brand-magenta: #e74092;
+  --brand-magenta-600: #c2306e;
+  --brand-magenta-800: #96234f;
+  --brand-blue: #1383eb;
+  --brand-purple: #9d45e8;
+  --brand-yellow: #ff7f00;
+  --eq-1: #e74092;
+  --eq-2: #00a433;
+  --eq-3: #9d45e8;
+  --eq-4: #1383eb;
+  --eq-5: #ff7f00;
+  --ink: #1b1b1c;
+  --ink-soft: #636367;
+  --ink-faint: #8e8e93;
+  --line: #e5e5ea;
+  --line-strong: #c7c7cc;
+  --bg: #f7f7f9;
+  --bg-sunken: #efeff3;
+  --card: #ffffff;
+  --ok: #00a31a;
+  --ok-bg: #e7f9e9;
+  --ok-line: #b6ebbe;
+  --erro: #d61a5e;
+  --erro-bg: #fdeaf2;
+  --erro-line: #f6c2d6;
+  --alerta: #a87900;
+  --alerta-bg: #fff6dd;
+  --alerta-line: #f2e0a8;
+  --info: #0974b3;
+  --info-bg: #e8f6ff;
+  --info-line: #bfe4f7;
+  --r-card: 12px;
+  --r-control: 8px;
+  --r-sm: 6px;
+  --shadow-card: 0 1px 2px rgba(0, 22, 99, 0.05), 0 4px 14px rgba(0, 22, 99, 0.07);
+  --sp-4: 4px;
+  --sp-6: 6px;
+  --sp-8: 8px;
+  --sp-10: 10px;
+  --sp-12: 12px;
+  --sp-16: 16px;
+  --sp-20: 20px;
+  --sp-24: 24px;
+  --sp-32: 32px;
+  --font-sans: 'Nunito Sans', system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
+  --font-mono: 'Consolas', ui-monospace, 'SFMono-Regular', monospace;
+  --t-2xs: 11px;
+  --t-xs: 12px;
+  --t-sm: 13px;
+  --t-base: 14px;
+  --t-md: 15px;
+  --t-xl: 20px;
+  --t-2xl: 26px;
+  --lh-tight: 1.2;
+  --lh-normal: 1.5;
+  --fw-600: 600;
+  --fw-700: 700;
+  --fw-800: 800;
+  --ease: cubic-bezier(0.2, 0.7, 0.3, 1);
+  --dur-1: 0.12s;
+  --titlebar-h: 48px;
+  --sidebar-w: 232px;
+  --focus-ring: 0 0 0 2px var(--card), 0 0 0 4px var(--brand-blue);
+  color-scheme: light;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --ink: #ecebf2;
+    --ink-soft: #a6a1ba;
+    --ink-faint: #76718c;
+    --line: #2c2740;
+    --line-strong: #3d3756;
+    --bg: #131022;
+    --bg-sunken: #0e0b1c;
+    --card: #1c1830;
+    --ok: #4bd663;
+    --ok-bg: #122a18;
+    --ok-line: #234e2c;
+    --erro: #ff5c8f;
+    --erro-bg: #2c1320;
+    --erro-line: #5a2540;
+    --alerta: #f2c14e;
+    --alerta-bg: #2a230f;
+    --alerta-line: #534420;
+    --info: #4cb8ec;
+    --info-bg: #102634;
+    --info-line: #244a61;
+    --shadow-card: 0 1px 2px rgba(0, 0, 0, 0.4), 0 4px 14px rgba(0, 0, 0, 0.35);
+    --focus-ring: 0 0 0 2px var(--card), 0 0 0 4px var(--brand-blue);
+    color-scheme: dark;
+  }
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  height: 100%;
+}
+
+body {
+  font-family: var(--font-sans);
+  font-size: var(--t-base);
+  line-height: var(--lh-normal);
+  color: var(--ink);
+  background: var(--bg);
+  -webkit-font-smoothing: antialiased;
+  text-rendering: optimizeLegibility;
+}
+
+:focus {
+  outline: none;
+}
+
+:focus-visible {
+  box-shadow: var(--focus-ring);
+  border-radius: var(--r-sm);
+}
+
+::selection {
+  background: color-mix(in srgb, var(--brand-magenta) 26%, transparent);
+}
+
+.win {
+  min-height: 100vh;
+  display: grid;
+  grid-template-rows: var(--titlebar-h) 1fr;
+  background: var(--bg);
+}
+
+.titlebar {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-12);
+  padding: 0 var(--sp-16);
+  background: var(--brand-navy);
+  color: #fff;
+  user-select: none;
+}
+
+.titlebar__brand {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-10);
+}
+
+.titlebar__title {
+  font-size: var(--t-sm);
+  font-weight: var(--fw-700);
+  letter-spacing: 0.005em;
+}
+
+.titlebar__sep {
+  width: 1px;
+  height: 18px;
+  background: rgba(255, 255, 255, 0.16);
+}
+
+.titlebar__meta {
+  font-size: var(--t-xs);
+  color: rgba(255, 255, 255, 0.66);
+}
+
+.eq-logo {
+  display: block;
+}
+
+.appbody {
+  display: grid;
+  grid-template-columns: var(--sidebar-w) 1fr;
+  min-height: 0;
+}
+
+.sidebar {
+  background: var(--card);
+  border-right: 1px solid var(--line);
+  overflow: auto;
+  padding: var(--sp-12) 0 var(--sp-24);
+}
+
+.sidebar__label {
+  padding: var(--sp-8) var(--sp-16) var(--sp-4);
+  font-size: var(--t-2xs);
+  font-weight: var(--fw-700);
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--ink-faint);
+  margin: var(--sp-8) 0 0;
+}
+
+.sidebar__nav {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 0 var(--sp-12);
+}
+
+.navitem {
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: var(--sp-10);
+  padding: var(--sp-10);
+  border-radius: var(--r-control);
+  color: var(--ink-soft);
+  font-weight: var(--fw-600);
+  font-size: var(--t-base);
+  text-decoration: none;
+  transition:
+    background var(--dur-1) var(--ease),
+    color var(--dur-1) var(--ease);
+}
+
+.navitem:hover {
+  background: var(--bg-sunken);
+  color: var(--ink);
+}
+
+.navitem.is-active {
+  background: color-mix(in srgb, var(--brand-navy) 8%, transparent);
+  color: var(--brand-navy);
+}
+
+@media (prefers-color-scheme: dark) {
+  .navitem.is-active {
+    background: color-mix(in srgb, var(--brand-magenta) 16%, transparent);
+    color: #fff;
+  }
+}
+
+.navitem.is-active::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  width: 3px;
+  height: 22px;
+  border-radius: 999px;
+  background: var(--brand-magenta);
+}
+
+.content {
+  min-width: 0;
+  overflow: auto;
+  background: var(--bg);
+}
+
+.content__inner {
+  padding: var(--sp-24);
+  max-width: 52rem;
+}
+
+.card {
+  background: var(--card);
+  border: 1px solid var(--line);
+  border-radius: var(--r-card);
+  box-shadow: var(--shadow-card);
+}
+
+.card__pad {
+  padding: var(--sp-24);
+}
+
+.prose h1,
+.prose h2,
+.prose h3 {
+  line-height: var(--lh-tight);
+  letter-spacing: -0.01em;
+  font-weight: var(--fw-800);
+  margin: 0 0 var(--sp-12);
+}
+
+.prose h1 {
+  font-size: var(--t-2xl);
+}
+
+.prose h2 {
+  font-size: var(--t-xl);
+  margin-top: var(--sp-32);
+}
+
+.prose h3 {
+  font-size: var(--t-md);
+  margin-top: var(--sp-24);
+}
+
+.prose p,
+.prose ul,
+.prose ol {
+  margin: 0.75rem 0;
+}
+
+.prose ul,
+.prose ol {
+  padding-left: 1.35rem;
+}
+
+.prose a {
+  color: var(--brand-magenta);
+  font-weight: var(--fw-600);
+}
+
+.prose a:hover {
+  color: var(--brand-magenta-600);
+}
+
+.prose code {
+  font-family: var(--font-mono);
+  font-size: 0.92em;
+  font-variant-numeric: tabular-nums;
+  background: var(--bg-sunken);
+  padding: 0.1em 0.35em;
+  border-radius: var(--r-sm);
+}
+
+.prose pre {
+  overflow: auto;
+  background: var(--bg-sunken);
+  border: 1px solid var(--line);
+  border-radius: var(--r-control);
+  padding: 0.85rem 1rem;
+}
+
+.prose pre code {
+  padding: 0;
+  background: transparent;
+}
+
+.prose .muted,
+.prose .note {
+  color: var(--ink-soft);
+}
+
+@media (max-width: 800px) {
+  .appbody {
+    grid-template-columns: 1fr;
+  }
+
+  .sidebar {
+    border-right: none;
+    border-bottom: 1px solid var(--line);
+    max-height: 40vh;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .navitem {
+    transition: none;
+  }
+}

package/node_modules/@sheldon/cli/dist/help.js

@@ -0,0 +1,84 @@
+import { spawn } from 'node:child_process';
+import { access, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const helpTopicId = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function defaultHelpRoot(moduleUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(moduleUrl)), 'help');
+}
+export function resolveHelpRoot(root) {
+    return root ?? defaultHelpRoot();
+}
+export function resolveHelpPage(topic, root, pageIds) {
+    const id = !topic || topic === 'index' ? 'index' : topic;
+    if (!helpTopicId.test(id) || pageIds !== undefined && !pageIds.has(id)) {
+        throw new Error(`HELP_PAGE_MISSING: Offline help page not found for topic '${id}'.`);
+    }
+    return id === 'index' ? join(root, 'index.html') : join(root, 'pages', `${id}.html`);
+}
+export async function readHelpPageIds(root) {
+    try {
+        const manifest = JSON.parse(await readFile(join(root, 'manifest.json'), 'utf8'));
+        const ids = new Set();
+        for (const page of manifest.pages ?? []){
+            if (typeof page.id === 'string' && helpTopicId.test(page.id)) ids.add(page.id);
+        }
+        return ids;
+    } catch  {
+        throw new Error(`HELP_PAGE_MISSING: Offline help manifest not found at ${join(root, 'manifest.json')}.`);
+    }
+}
+export async function assertHelpPageExists(path) {
+    try {
+        await access(path);
+    } catch  {
+        throw new Error(`HELP_PAGE_MISSING: Offline help page not found at ${path}.`);
+    }
+}
+export async function openHelpPage(path, open = openWithSystemBrowser) {
+    await assertHelpPageExists(path);
+    await open(path);
+}
+async function openWithSystemBrowser(path) {
+    const fileUrl = pathToFileURL(path).href;
+    if (process.platform === 'win32') {
+        await spawnDetached('cmd', [
+            '/c',
+            'start',
+            '',
+            fileUrl
+        ]);
+        return;
+    }
+    if (process.platform === 'darwin') {
+        await spawnDetached('open', [
+            fileUrl
+        ]);
+        return;
+    }
+    await spawnDetached('xdg-open', [
+        fileUrl
+    ]);
+}
+function spawnDetached(command, args) {
+    return new Promise((resolve, reject)=>{
+        let child;
+        try {
+            child = spawn(command, [
+                ...args
+            ], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true
+            });
+        } catch (error) {
+            reject(error);
+            return;
+        }
+        child.once('error', reject);
+        child.once('spawn', ()=>{
+            child.unref();
+            resolve();
+        });
+    });
+}

package/node_modules/@sheldon/cli/dist/main.js

@@ -21,6 +21,7 @@ import { configureMcpConsumer, doctorMcp, installSheldonSkill, serveMcp } from '
 import { buildBundle, createBundle, diffBundles, validateBundle } from './commands/bundle.js';
 import { startWebServer } from '@sheldon/web';
 import { createWebApplication } from './web-api.js';
+import { openHelpPage, readHelpPageIds, resolveHelpPage, resolveHelpRoot } from './help.js';
 import { createOfficialCatalogClient, currentPlatform } from './official-catalog.js';
 export async function runCli(args, dependencies = {}) {
     const stdout = [];
@@ -83,6 +84,14 @@ export async function runCli(args, dependencies = {}) {
             };
         }
         const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith('HELP_PAGE_MISSING:')) {
+            stderr.push(`Error: ${message}\nTarget: offline help\nRecovery: run sheldon help --path and confirm the help files are installed.\n`);
+            return {
+                exitCode: 1,
+                stdout: stdout.join(''),
+                stderr: stderr.join('')
+            };
+        }
         stderr.push(`Error: ${message}\nTarget: command execution\nRecovery: review the command and retry.\n`);
         return {
             exitCode: 1,
@@ -101,6 +110,14 @@ function configureCommander(command, stdout, stderr) {
 }
 function createProgram(context, dependencies) {
     const program = new Command('sheldon').description('Build and use a local, reviewable knowledge vault.');
+    program.helpCommand(false);
+    program.command('help [topic]').description('Show CLI help, or open offline HTML help.').option('--html', 'open offline HTML help in the default browser').option('--path', 'print the offline HTML help directory').action(async (topic, options, command)=>{
+        const parent = command.parent;
+        if (!parent) {
+            throw new Error('Help command is missing its parent program.');
+        }
+        await executeHelp(topic, options, parent, context, dependencies);
+    });
     program.command('init [path]').description('Create a Sheldon vault and save it as the local default.').addOption(new Option('--yes', 'accept the proposed default path')).action((path, options)=>executeInit(path, options, context));
     program.command('doctor').description('Check the vault, local databases, plugins, and agent tools.').option('--vault <path>', 'explicit vault path').action((options)=>executeDoctor(options, context));
     program.command('migrate-state').description('Copy legacy plugin state to this platform state directory after hash verification.').requiredOption('--from <directory>', 'legacy Sheldon application-state directory').action(async (options)=>{
@@ -157,6 +174,27 @@ function createProgram(context, dependencies) {
     language.command('remove <code>').description('Remove installed OCR language data.').action((code)=>removeImageLanguageCommand(code, context));
     return program;
 }
+async function executeHelp(topic, options, program, context, dependencies) {
+    const helpRoot = resolveHelpRoot(dependencies.helpRoot);
+    if (options.path) {
+        context.write(helpRoot);
+        return;
+    }
+    if (options.html) {
+        const page = resolveHelpPage(topic, helpRoot, await readHelpPageIds(helpRoot));
+        await openHelpPage(page, dependencies.openHelp);
+        return;
+    }
+    if (!topic) {
+        program.outputHelp();
+        return;
+    }
+    const command = program.commands.find((candidate)=>candidate.name() === topic || candidate.aliases().includes(topic));
+    if (!command || command.name() === 'help') {
+        throw new Error(`Unknown help topic '${topic}'.`);
+    }
+    command.outputHelp();
+}
 function agentKind(value) {
     if (isAgentKind(value)) return value;
     throw new InvalidArgumentError(`Agent must be ${formatAgentKindList()}.`);

package/node_modules/@sheldon/cli/dist/web-api.js

@@ -1,7 +1,7 @@
 /** Public application-facing adapters shared by the local web server and the CLI. */ import { PluginSelector } from '@sheldon/plugin-host';
 import { archiveEntity, listEntities, showEntity } from './commands/entities.js';
 import { buildBundle, createBundle, validateBundle } from './commands/bundle.js';
-import { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, lintWiki, previewProposal, approveProposal } from './commands/memory.js';
+import { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, lintWiki, listPendingReviews, previewProposal, approveProposal } from './commands/memory.js';
 import { doctorPlugin } from './commands/plugins.js';
 import { queryVault } from './commands/query.js';
 import { searchVault } from './commands/search.js';
@@ -12,7 +12,7 @@ export { buildBundle, createBundle, validateBundle } from './commands/bundle.js'
 export { doctorPlugin } from './commands/plugins.js';
 export { queryVault } from './commands/query.js';
 export { searchVault } from './commands/search.js';
-export { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, previewProposal, approveProposal, lintWiki } from './commands/memory.js';
+export { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, listPendingReviews, previewProposal, approveProposal, lintWiki } from './commands/memory.js';
 export { rejectProposal } from './commands/workflow.js';
 export { withPluginServices } from './plugin-services.js';
 /** Builds the only domain-facing surface consumed by the Fastify server. */ export function createWebApplication(context, vault) {
@@ -32,6 +32,9 @@ export { withPluginServices } from './plugin-services.js';
                     project: query.project,
                     tag: query.tag
                 }, output)),
+        listPendingReviews: ()=>capture(context, (output)=>listPendingReviews({
+                    vault
+                }, output)),
         previewProposal: (kind, slug, proposalId)=>capture(context, (output)=>previewProposal(kind, slug, proposalId, {
                     vault
                 }, output)),

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/adapters.js

@@ -59,6 +59,9 @@ function renderPrompt(task) {
         'You may read only these raw source files, and must cite only these paths in the response:',
         ...task.rawSources.map((source)=>`- ${source}`),
         'Do not modify files. Propose changes only under wiki/.',
+        'Each created or modified wiki file must be Markdown that starts with YAML frontmatter containing id, type, title, description, aliases, tags, created_at, updated_at, status, and sources.',
+        'created_at and updated_at must be ISO-8601 timestamps. sources must list the cited raw paths for that file.',
+        'Write a real concept body after the frontmatter; do not use placeholder text.',
         'Return the structured proposal only; do not wrap it in Markdown or add commentary.',
         'User request:',
         task.prompt

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/command-executor.js

@@ -253,7 +253,7 @@ async function readTextIfPresent(path) {
 function terminate(child) {
     if (!child.killed) child.kill('SIGKILL');
 }
-function buildChildEnvironment(source, allowlist) {
+export function buildChildEnvironment(source, allowlist) {
     const environment = sanitizedEnvironment(source);
     for (const key of [
         'HOME',

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/index.js

@@ -1,6 +1,6 @@
 export { createClaudeCommandAdapter, createClaudeQueryAdapter, createCodexCommandAdapter, createCodexQueryAdapter, createCommandAdapter, createGrokCommandAdapter, createGrokQueryAdapter, createQueryCommandAdapter } from './adapters.js';
 export { ProposalPromotionError, ProposalValidationError } from './errors.js';
-export { JsonCommandExecutor } from './command-executor.js';
+export { JsonCommandExecutor, buildChildEnvironment } from './command-executor.js';
 export { isProposalId, PROPOSAL_SCHEMA_VERSION, summarizeProposal, validateProposal } from './proposal.js';
 export { ProposalStore } from './proposal-store.js';
 export { AGENT_PROFILE_IDS, formatAgentKindList, isAgentKind, listAgentProfiles, requireAgentProfile } from './profiles.js';

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/profiles.js

@@ -1,8 +1,3 @@
-export const AGENT_PROFILE_IDS = [
-    'codex',
-    'claude',
-    'grok'
-];
 const profiles = [
     {
         id: 'codex',
@@ -102,6 +97,7 @@ const profiles = [
         }
     }
 ];
+export const AGENT_PROFILE_IDS = profiles.map((profile)=>profile.id);
 export function isAgentKind(value) {
     return AGENT_PROFILE_IDS.includes(value);
 }

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal-schema.js

@@ -1,5 +1,5 @@
 import { PROPOSAL_SCHEMA_VERSION } from './proposal.js';
-export const STRUCTURED_PROPOSAL_SCHEMA_ID = 'sheldon-proposal/v1';
+export const STRUCTURED_PROPOSAL_SCHEMA_ID = 'urn:sheldon:proposal:v1';
 export const AGENT_PROMPT_VERSION = 'm2/v1';
 /**
  * The wire schema passed directly to agent CLIs. Keep this independent of the
@@ -48,7 +48,8 @@ export const AGENT_PROMPT_VERSION = 'm2/v1';
                         ]
                     },
                     content: {
-                        type: 'string'
+                        type: 'string',
+                        description: 'Markdown starting with YAML frontmatter (id, type, title, description, aliases, tags, created_at, updated_at, status, sources) then the concept body.'
                     },
                     citations: {
                         type: 'array',

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal-store.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { atomicWriteFile } from '@sheldon/vault';
 import { ProposalPromotionError } from './errors.js';
@@ -40,6 +40,25 @@ export class ProposalStore {
             diffs: []
         };
     }
+    async list() {
+        const root = join(resolve(this.entityDirectory), 'outputs', 'proposals');
+        let entries;
+        try {
+            entries = await readdir(root, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if (isMissing(error)) return [];
+            throw error;
+        }
+        const listed = [];
+        for (const entry of entries){
+            if (!entry.isDirectory() || !isProposalId(entry.name)) continue;
+            const metadata = await readJsonIfPresent(join(root, entry.name, 'metadata.json'));
+            if (metadata?.id === entry.name) listed.push(metadata);
+        }
+        return listed.sort((left, right)=>right.createdAt.localeCompare(left.createdAt) || left.id.localeCompare(right.id));
+    }
     async load(id) {
         this.assertId(id);
         const directory = this.directory(id);

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal.js

@@ -1,3 +1,4 @@
+import { parseWikiFrontmatter, wikiConceptFrontmatterIssues } from '@sheldon/core';
 import { ProposalValidationError } from './errors.js';
 export const PROPOSAL_SCHEMA_VERSION = 1;
 const maximumDiffLines = 2_000;
@@ -54,6 +55,23 @@ export function validateProposal(candidate) {
                 issues.push(`File ${file.path} cites an undeclared raw source ${citation}.`);
             }
         }
+        if (file.operation !== 'delete' && typeof file.content === 'string') {
+            const frontmatter = parseWikiFrontmatter(file.content);
+            const schemaIssues = wikiConceptFrontmatterIssues(frontmatter);
+            if (schemaIssues.length > 0) {
+                issues.push(`File ${file.path} wiki concept frontmatter is invalid: ${schemaIssues.join(' ')}`);
+            } else {
+                const conceptSources = frontmatter.sources;
+                for (const citation of file.citations ?? []){
+                    if (!conceptSources.includes(citation)) {
+                        issues.push(`File ${file.path} frontmatter must list every cited raw source.`);
+                    }
+                }
+            }
+            if (wikiBody(file.content).length === 0) {
+                issues.push(`File ${file.path} must include a concept body.`);
+            }
+        }
     }
     if (issues.length > 0) throw new ProposalValidationError(issues);
     return {
@@ -75,6 +93,9 @@ export function summarizeProposal(proposal, currentFiles = {}) {
         };
     });
 }
+function wikiBody(content) {
+    return content.replace(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/, '').trim();
+}
 export function isProposalId(value) {
     return /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value);
 }

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/query-answer-schema.js

@@ -1,6 +1,6 @@
 import { AGENT_PROFILE_IDS } from './profiles.js';
 import { QUERY_ANSWER_SCHEMA_VERSION } from './query-answer.js';
-export const QUERY_ANSWER_SCHEMA_ID = 'sheldon-query-answer/v1';
+export const QUERY_ANSWER_SCHEMA_ID = 'urn:sheldon:query-answer:v1';
 /** JSON Schema supplied to query adapters that need structured answer output. */ export const queryAnswerJsonSchema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
     $id: QUERY_ANSWER_SCHEMA_ID,

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/node_modules/@sheldon/core/dist/index.js

@@ -2,3 +2,4 @@ export { archiveEntityMetadata, createEntityMetadata, renameEntityMetadata } fro
 export { slugify } from './slug.js';
 export { markdownBody } from './markdown.js';
 export { isoTimestampEpoch } from './timestamp.js';
+export { parseWikiFrontmatter, wikiConceptFrontmatterIssues, WIKI_CONCEPT_FRONTMATTER_FIELDS } from './wiki-concept.js';