@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/tools/pdf.js

@@ -0,0 +1,303 @@
+import { errorCode, errorMessage } from '../guards.js';
+import { checkOutputBytes, RUN_OUTPUT_BUDGET_BYTES } from './attachments/output-policy.js';
+import { build, pagesLabel, readDocs } from './pdf/build.js';
+import { placeImages } from './pdf/images.js';
+import { PAGE_SIZES, parseRequest, PDF_ACTIONS, WHERE_IDS_ARE } from './pdf/request.js';
+export { parsePages, parseRequest } from './pdf/request.js';
+const SUFFIXES = {
+    create: 'revised',
+    merge: 'merged',
+    split: 'pages',
+    rotate: 'rotated',
+    watermark: 'watermarked',
+    fill: 'filled',
+    encrypt: 'locked',
+    decrypt: 'unlocked',
+    text: 'text',
+    read: 'copy'
+};
+const attachedThisTurn = new WeakMap();
+let loaded = null;
+function loadPdfium() {
+    loaded ??= import('bare-pdfium').then((pdfium) => pdfium, () => null);
+    return loaded;
+}
+function stemOf(fileName) {
+    const base = fileName.replace(/^.*[\\/]/, '');
+    const dot = base.lastIndexOf('.');
+    return dot > 0 ? base.slice(0, dot) : base;
+}
+function slug(markdown) {
+    const heading = /^#{1,6}\s+(.+)$/m.exec(markdown)?.[1] ?? '';
+    const name = heading
+        .toLowerCase()
+        .replace(/[*_`[\]]/g, '')
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 48);
+    return name || 'document';
+}
+function extensionOf(request) {
+    return request.action === 'text' ? 'txt' : 'pdf';
+}
+function defaultName(request, first) {
+    if (!first) {
+        return `${request.action === 'create' ? slug(request.markdown) : 'document'}.pdf`;
+    }
+    if (request.action === 'text') {
+        return `${stemOf(first.fileName)}.txt`;
+    }
+    return `${stemOf(first.fileName)}_${SUFFIXES[request.action]}.pdf`;
+}
+export function outputName(request, inputs) {
+    const extension = extensionOf(request);
+    const { output } = request;
+    let wanted = defaultName(request, inputs[0]);
+    if (output && /\.[a-z0-9]{2,4}$/i.test(output)) {
+        wanted = output.replace(/\.pdf$/i, `.${extension}`);
+    }
+    else if (output) {
+        wanted = `${output}.${extension}`;
+    }
+    const taken = inputs.some((input) => input.fileName.toLowerCase() === wanted.toLowerCase());
+    return taken ? `${stemOf(wanted)}_${SUFFIXES[request.action]}.${extension}` : wanted;
+}
+async function fetchSources(ids, ctx) {
+    if (!ctx.fetchAttachment) {
+        return { error: 'this device cannot read chat attachments' };
+    }
+    const sources = [];
+    for (const attachmentId of ids) {
+        const found = await ctx.fetchAttachment({ attachmentId, signal: ctx.signal });
+        if (!found || !('bytes' in found)) {
+            return { error: `attachment ${attachmentId} not found in this chat; ${WHERE_IDS_ARE}` };
+        }
+        sources.push({ attachmentId, fileName: found.fileName, bytes: found.bytes });
+    }
+    return sources;
+}
+function openError(err, source, password) {
+    const code = errorCode(err);
+    if (code === 'PASSWORD' && password) {
+        return `the password is wrong for ${source.fileName}; ask the user for the right one, never guess`;
+    }
+    if (code === 'PASSWORD') {
+        return `${source.fileName} is locked; ask the user for its password and pass it as password`;
+    }
+    if (code === 'FORMAT' || code === 'FILE') {
+        return `${source.fileName} is not a PDF that opens`;
+    }
+    return `${source.fileName}: ${errorMessage(err)}`;
+}
+function openAll(pdfium, sources, request) {
+    const password = request.action === 'encrypt' ? undefined : request.password;
+    const opened = [];
+    for (const source of sources) {
+        try {
+            opened.push({ source, doc: pdfium.open(source.bytes, { password }) });
+        }
+        catch (err) {
+            return { opened, error: openError(err, source, password) };
+        }
+    }
+    return { opened, error: null };
+}
+async function attachOutput(fileName, bytes, ctx) {
+    if (!ctx.attach) {
+        return { error: 'this device cannot attach a file to the chat' };
+    }
+    const delivered = attachedThisTurn.get(ctx.attach) ?? new Map();
+    const earlier = delivered.get(fileName.toLowerCase());
+    if (earlier) {
+        return { attachment: earlier, repeated: true };
+    }
+    const verdict = checkOutputBytes(fileName, bytes, 0);
+    if ('error' in verdict) {
+        return verdict;
+    }
+    const budget = ctx.runBudget;
+    if (budget && budget.outputBytesUsed + bytes.byteLength > RUN_OUTPUT_BUDGET_BYTES) {
+        return { error: 'run output budget exceeded' };
+    }
+    const record = await ctx.attach({ fileName, mimeType: verdict.mimeType, bytes, raw: true });
+    if (budget) {
+        budget.outputBytesUsed += bytes.byteLength;
+    }
+    const attachment = {
+        attachmentId: record.id,
+        fileName: record.fileName,
+        byteLength: record.byteLength
+    };
+    delivered.set(fileName.toLowerCase(), attachment);
+    attachedThisTurn.set(ctx.attach, delivered);
+    return { attachment, repeated: false };
+}
+const UNDRAWABLE = /^('[^']+' \(U\+[0-9A-F]+\)(?:, '[^']+' \(U\+[0-9A-F]+\))*) cannot be drawn by the built-in fonts/;
+function buildError(err) {
+    const message = errorMessage(err);
+    const characters = UNDRAWABLE.exec(message)?.[1];
+    if (!characters) {
+        return message;
+    }
+    return (`${characters} cannot be drawn: a PDF made here takes Western European text only. ` +
+        'Leave those characters out, or tell the user this text cannot go in a PDF');
+}
+function buildSafely({ pdfium, request, opened }) {
+    try {
+        return build(pdfium, request, opened);
+    }
+    catch (err) {
+        return buildError(err);
+    }
+}
+function reply(request, { output, built, delivered }) {
+    const { attachment, repeated } = delivered;
+    const summary = request.action === 'text'
+        ? `text of ${pagesLabel(built.pageCount)}`
+        : pagesLabel(built.pageCount);
+    const renamed = request.output && output !== request.output
+        ? `Saved as ${output}, so the attached file keeps its own name. `
+        : '';
+    return {
+        attachments: [attachment],
+        pageCount: built.pageCount,
+        reply: `${attachment.fileName} — ${summary}`,
+        next: renamed +
+            `Done: ${attachment.fileName} ${repeated ? 'was already' : 'is'} attached to the chat and shown to the user. ` +
+            'Do not call pdf again for it. Your answer is the reply value alone, word for word.'
+    };
+}
+async function deliver(job, ctx) {
+    const { request, opened } = job;
+    const output = outputName(request, opened.map((one) => one.source));
+    const extension = `.${extensionOf(request)}`;
+    if (!output.toLowerCase().endsWith(extension)) {
+        return { error: `output must end in ${extension}, got "${output}"` };
+    }
+    const built = buildSafely(job);
+    if (typeof built === 'string') {
+        return { error: built };
+    }
+    const delivered = await attachOutput(output, built.bytes, ctx);
+    return 'error' in delivered ? delivered : reply(request, { output, built, delivered });
+}
+function isLocked(pdfium, source) {
+    try {
+        pdfium.open(source.bytes).close();
+        return false;
+    }
+    catch (err) {
+        return errorCode(err) === 'PASSWORD';
+    }
+}
+function lockOrUnlock(pdfium, request, sources) {
+    const [only] = sources;
+    const wantsFile = request.output?.toLowerCase().endsWith('.pdf') === true;
+    if (request.action !== 'read' || !request.password || !wantsFile || !only || sources.length > 1) {
+        return request;
+    }
+    if (isLocked(pdfium, only)) {
+        return { ...request, action: 'decrypt' };
+    }
+    return { ...request, action: 'encrypt', ownerPassword: undefined, permissions: undefined };
+}
+async function run(pdfium, asked, ctx) {
+    if (asked.action === 'create') {
+        const placed = await placeImages(asked, ctx);
+        return 'error' in placed ? placed : deliver({ pdfium, request: placed, opened: [] }, ctx);
+    }
+    const sources = asked.ids.length ? await fetchSources(asked.ids, ctx) : [];
+    if ('error' in sources) {
+        return sources;
+    }
+    const request = lockOrUnlock(pdfium, asked, sources);
+    const { opened, error } = openAll(pdfium, sources, request);
+    try {
+        if (error) {
+            return { error };
+        }
+        if (request.action === 'read') {
+            return readDocs(opened);
+        }
+        return await deliver({ pdfium, request, opened }, ctx);
+    }
+    finally {
+        for (const { doc } of opened) {
+            doc.close();
+        }
+    }
+}
+const DESCRIPTION = 'Create, read or change PDF files. With attachmentId and no action it returns the page ' +
+    'count, each page’s text and the form fields (name, type, value, options). An action saves ' +
+    'a new file named output and attaches it to the chat: create (markdown, where ' +
+    '![caption](attachmentId) on its own line places a chat image and the file name of the ' +
+    "user's upload places that upload; optional pageSize, " +
+    'landscape, pageNumbers, password), merge (attachmentIds in order), split (pages), rotate ' +
+    '(degrees 90, 180 or 270, optional pages), watermark (text, optional opacity, position, ' +
+    'pages), fill (values keyed by field name), encrypt (password, optional ownerPassword, ' +
+    'permissions), decrypt (password), text (a .txt of the text). Pages count from 1. A locked ' +
+    'PDF needs its password on every action. A failing call saves nothing and its error names ' +
+    'what exists, so fix the call from it.';
+const PARAMETERS = {
+    type: 'object',
+    properties: {
+        action: {
+            type: 'string',
+            enum: [...PDF_ACTIONS],
+            description: 'What to do; leave it out to read the PDF'
+        },
+        attachmentId: { type: 'string', description: 'The PDF in this chat' },
+        attachmentIds: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'merge: the PDFs to join, in order'
+        },
+        markdown: { type: 'string', description: 'create: the whole document as Markdown' },
+        pages: {
+            type: 'array',
+            items: { type: 'integer' },
+            description: 'Page numbers counted from 1'
+        },
+        degrees: { type: 'integer', description: 'rotate: 90, 180 or 270, clockwise' },
+        text: { type: 'string', description: 'watermark: the text to stamp' },
+        opacity: { type: 'number', description: 'watermark: 0 to 1' },
+        position: { type: 'string', enum: ['over', 'under'], description: 'watermark' },
+        values: { type: 'object', description: 'fill: { "field name": value }' },
+        password: {
+            type: 'string',
+            description: 'encrypt: the new password; otherwise the password of a locked PDF'
+        },
+        ownerPassword: { type: 'string', description: 'encrypt' },
+        permissions: { type: 'object', description: 'encrypt: { print, copy, modify, ... }' },
+        pageSize: { type: 'string', enum: [...PAGE_SIZES], description: 'create' },
+        landscape: { type: 'boolean', description: 'create' },
+        pageNumbers: { type: 'boolean', description: 'create' },
+        output: { type: 'string', description: 'File name for the saved file' }
+    }
+};
+export function createPdfTool(load = loadPdfium) {
+    return {
+        name: 'pdf',
+        toolset: null,
+        skillGated: true,
+        description: DESCRIPTION,
+        parameters: PARAMETERS,
+        effect: () => 'read',
+        addons: { 'bare-pdfium': load },
+        validate(args) {
+            const request = parseRequest(args);
+            return typeof request === 'string' ? request : null;
+        },
+        async execute(args, ctx = {}) {
+            const request = parseRequest(args);
+            if (typeof request === 'string') {
+                return { error: request };
+            }
+            const pdfium = await load();
+            if (!pdfium) {
+                return { error: 'this device cannot open PDFs' };
+            }
+            return run(pdfium, request, ctx);
+        }
+    };
+}

package/dist-lib/lib/tools/read-files.d.ts

@@ -1,4 +1,4 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type FsToolOptions } from './fs/scope.ts';
 export declare const DEFAULT_READ_CHARS = 8192;
 export declare const MAX_READ_CHARS = 65536;

package/dist-lib/lib/tools/read-files.js

@@ -1,4 +1,5 @@
 import { errorMessage, isRecord } from '../guards.js';
+import { createLocalRoots } from './fs/local.js';
 import { readLines } from './fs/read.js';
 import { isDriveReadTruncated } from './fs/remote.js';
 import { canonicalDenyRoots, defaultRealpath, resolveKey } from './fs/scope.js';
@@ -91,6 +92,7 @@ export function createReadFilesTool({ realpath = defaultRealpath, deniedRoots }
             required: ['files']
         },
         effect: () => 'read',
+        concurrent: true,
         autoApprove: true,
         rootsRequired: true,
         validate(rawArgs) {
@@ -130,8 +132,10 @@ export function createReadFilesTool({ realpath = defaultRealpath, deniedRoots }
             const files = [];
             const failed = [];
             const deny = await canonicalDenyRoots(deniedRoots, realpath);
+            const spill = ctx?.spill ? await createLocalRoots([ctx.spill.dir], realpath) : [];
             for (const request of requests) {
-                const resolved = await resolveKey(request.path, roots, { realpath, deny });
+                const own = spill.length ? await resolveKey(request.path, spill, { realpath }) : null;
+                const resolved = own && !('error' in own) ? own : await resolveKey(request.path, roots, { realpath, deny });
                 if ('error' in resolved) {
                     failed.push({ path: request.path, error: resolved.error });
                     continue;

package/dist-lib/lib/tools/skill.d.ts

@@ -1,5 +1,4 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import { type CredentialStoreFn } from './skills/auth-resolver.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 export type ReadSkillFn = (name: string, file: string) => Promise<string> | string;
 export declare function mainFileRequested(name: string, file: unknown): boolean;
 export declare function skillFileArg(args: Record<string, unknown> | null | undefined): unknown;
@@ -8,6 +7,5 @@ export interface SkillToolOptions {
     skillsDir?: string;
     overlayDir?: string | null;
     read?: ReadSkillFn;
-    credentialStore?: CredentialStoreFn;
 }
-export declare function createSkillTool({ skillsDir, overlayDir, read, credentialStore }?: SkillToolOptions): ToolDefinition;
+export declare function createSkillTool({ skillsDir, overlayDir, read }?: SkillToolOptions): ToolDefinition;

package/dist-lib/lib/tools/skill.js

@@ -1,14 +1,11 @@
 import path from 'path';
 import b4a from 'b4a';
 import Localdrive from 'localdrive';
-import { OBSIDIAN_VAULT_MODE_NOTE } from './exec/obsidian/guidance.js';
-import { unquoteArg } from './model-args.js';
-import { credentialRecord } from './skills/auth-resolver.js';
+import { unquoteArg } from '../helpers/model-args.js';
 import { resolveSkillsOverlayDir } from './skills/overlay-dir.js';
 import { parseSkillFrontMatter } from './skills/frontmatter-parser.js';
-import { parseToolGrant } from './skills/tool-grants.js';
+import { Agent } from '../agent/index.js';
 import { shellEscapeArg } from './exec/shell-argv.js';
-import { isObsidianVaultPath, OBSIDIAN_SKILL_NAME, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY } from './skills/obsidian-readiness.js';
 const MAIN_FILE = 'SKILL.md';
 const NO_FILE = /^(?:none|null|undefined|main)$/i;
 export function mainFileRequested(name, file) {
@@ -39,7 +36,7 @@ function toolNote(tools) {
         return null;
     const grants = [];
     for (const entry of tools) {
-        const { name } = parseToolGrant(entry);
+        const { name } = Agent.parseToolGrant(entry);
         if (!grants.includes(name)) {
             grants.push(name);
         }
@@ -75,17 +72,7 @@ function nearestFile(wanted, available) {
     const matches = available.filter((file) => skillFileStem(file) === skillFileStem(wanted));
     return matches.length === 1 ? matches[0] : null;
 }
-async function vaultModeNote(name, credentialStore, ctx) {
-    if (name !== OBSIDIAN_SKILL_NAME || !credentialStore)
-        return null;
-    const record = credentialRecord(await credentialStore(OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, { ...ctx, skills: [name] }));
-    const token = record?.token?.trim();
-    if (!token || !isObsidianVaultPath(token)) {
-        return null;
-    }
-    return OBSIDIAN_VAULT_MODE_NOTE;
-}
-export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDir(), read, credentialStore } = {}) {
+export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDir(), read } = {}) {
     const baseDrive = skillsDir ? new Localdrive(skillsDir) : null;
     const overlayDrive = overlayDir ? new Localdrive(overlayDir) : null;
     async function resolveSkill(name, file) {
@@ -148,14 +135,19 @@ export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDi
                 const { body, meta } = parseSkillFrontMatter(raw);
                 const dir = resolveSkillDir(root, name);
                 const content = dir ? body.replaceAll('{{SKILL_DIR}}', shellEscapeArg(dir)) : body;
-                const notes = [
-                    toolNote(meta.tools),
-                    await vaultModeNote(name, credentialStore, ctx)
-                ].filter(Boolean);
+                const note = toolNote(meta.tools);
                 return {
                     name,
                     file: target === MAIN_FILE ? undefined : target,
-                    content: notes.length ? [content.trim(), ...notes].join('\n\n') : content
+                    content: note ? `${content.trim()}\n\n${note}` : content
+                };
+            };
+            const mainInstead = async (asked, available) => {
+                const main = await load(MAIN_FILE);
+                const others = available.length ? ` Its other files: ${available.join(', ')}.` : '';
+                return {
+                    ...main,
+                    content: `There is no file ${asked} in this skill; these are its instructions.${others}\n\n${main.content}`
                 };
             };
             try {
@@ -173,6 +165,12 @@ export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDi
                     }
                     catch { }
                 }
+                if (!ctx?.skillsLoadedThisTurn?.includes(name)) {
+                    try {
+                        return await mainInstead(file, available);
+                    }
+                    catch { }
+                }
                 const rest = available.length
                     ? ` — files this skill has: ${available.join(', ')}`
                     : '. This skill has no other files; you already have its full instructions — act now.';

package/dist-lib/lib/tools/skills/auth-resolver.d.ts

@@ -1,5 +1,5 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { ToolExecuteContext } from '../../capabilities/completion.ts';
+import type { ToolExecuteContext } from '../../contract/index.ts';
 import { type ParseResult } from '../http-request/request.ts';
 export interface HttpRequestAuth {
     type: 'bearer';

package/dist-lib/lib/tools/skills/catalog.d.ts

@@ -1,3 +1,4 @@
+import type { SkillReadiness } from '../../contract/index.ts';
 import type { CredentialStoreFn } from './auth-resolver.ts';
 import type { SkillSettingsFn } from './skill-settings.ts';
 import type { InstallStep, SkillRequires, SkillSetup } from './manifest.ts';
@@ -33,7 +34,12 @@ export interface ResolvedSkillCatalogEntry extends SkillCatalogEntry {
     status: SkillState;
 }
 export declare function skillSupportsPlatform(entry: SkillCatalogEntry, platform: string | undefined): boolean;
-export declare function versionProbeSkills(catalog: readonly SkillCatalogEntry[], installedTools: ReadonlySet<string>, platform: string | undefined): SkillCatalogEntry[];
+export interface VersionProbeOptions {
+    installedTools: ReadonlySet<string>;
+    platform: string | undefined;
+    readiness?: ReadonlyMap<string, SkillReadiness>;
+}
+export declare function versionProbeSkills(catalog: readonly SkillCatalogEntry[], { installedTools, platform, readiness }: VersionProbeOptions): SkillCatalogEntry[];
 export declare function availableSkills(catalog: readonly SkillCatalogEntry[], installedTools: ReadonlySet<string>, activeProfile?: CapabilityProfile): SkillCatalogEntry[];
 export interface ResolveSkillStatusOptions {
     installedTools?: ReadonlySet<string>;
@@ -46,13 +52,14 @@ export interface ResolveSkillStatusOptions {
     refresh?: boolean;
     skipCredentialProbe?: boolean;
     fetchImpl?: CredentialCheckFetch;
+    readiness?: ReadonlyMap<string, SkillReadiness>;
 }
 export interface CredentialProbeEligibilityOptions {
     platform?: string | undefined;
     installedTools?: ReadonlySet<string> | undefined;
 }
 export declare function skillsEligibleForCredentialProbe(catalog: readonly SkillCatalogEntry[], { platform, installedTools }?: CredentialProbeEligibilityOptions): SkillCatalogEntry[];
-export declare function resolveSkillStatuses(catalog: readonly SkillCatalogEntry[], { installedTools, credentialStore, settingsStore, platform, agentId, activeProfile, binVersions, refresh, skipCredentialProbe, fetchImpl }?: ResolveSkillStatusOptions): Promise<ResolvedSkillCatalogEntry[]>;
+export declare function resolveSkillStatuses(catalog: readonly SkillCatalogEntry[], { installedTools, credentialStore, settingsStore, platform, agentId, activeProfile, binVersions, refresh, skipCredentialProbe, fetchImpl, readiness }?: ResolveSkillStatusOptions): Promise<ResolvedSkillCatalogEntry[]>;
 export interface LoadSkillCatalogOptions {
     platform?: string | null;
     overlayDir?: string | null;

package/dist-lib/lib/tools/skills/catalog.js

@@ -7,8 +7,7 @@ import { parseSkillFrontMatter } from './frontmatter-parser.js';
 import { buildCliValidator, loadSkillCli } from './cli-schema.js';
 import { isModelCompatible, isStub, isToolSupported, resolveSkillState, SKILL_STATE, supportsPlatform } from './skill-state.js';
 import { validateCredentialChecks } from './credential-check.js';
-import { OBSIDIAN_SKILL_NAME } from './obsidian-readiness.js';
-import { parseToolGrant } from './tool-grants.js';
+import { Agent } from '../../agent/index.js';
 import { deriveSetup } from './setup-routes.js';
 import { resolveSkillsOverlayDir } from './overlay-dir.js';
 import { parseOperationsManifest } from '../operations/manifest.js';
@@ -16,12 +15,12 @@ import { hlog } from '../../log.js';
 export function skillSupportsPlatform(entry, platform) {
     return supportsPlatform(entry, platform);
 }
-export function versionProbeSkills(catalog, installedTools, platform) {
-    return catalog.filter((entry) => entry.name !== OBSIDIAN_SKILL_NAME &&
+export function versionProbeSkills(catalog, { installedTools, platform, readiness }) {
+    return catalog.filter((entry) => readiness?.get(entry.name)?.probeVersions !== false &&
         entry.requires?.binMinVersions &&
         skillSupportsPlatform(entry, platform) &&
         !entry.stub &&
-        entry.tools.every((name) => installedTools.has(parseToolGrant(name).name)));
+        entry.tools.every((name) => installedTools.has(Agent.parseToolGrant(name).name)));
 }
 export function availableSkills(catalog, installedTools, activeProfile) {
     return catalog.filter((skill) => !isStub(skill) &&
@@ -33,7 +32,7 @@ export function skillsEligibleForCredentialProbe(catalog, { platform, installedT
         !isStub(entry) &&
         (!installedTools || isToolSupported(entry, installedTools)));
 }
-export function resolveSkillStatuses(catalog, { installedTools, credentialStore, settingsStore, platform, agentId, activeProfile, binVersions, refresh, skipCredentialProbe, fetchImpl } = {}) {
+export function resolveSkillStatuses(catalog, { installedTools, credentialStore, settingsStore, platform, agentId, activeProfile, binVersions, refresh, skipCredentialProbe, fetchImpl, readiness } = {}) {
     const probeCatalog = skillsEligibleForCredentialProbe(catalog, { platform, installedTools });
     const checked = skipCredentialProbe
         ? Promise.resolve()
@@ -46,7 +45,8 @@ export function resolveSkillStatuses(catalog, { installedTools, credentialStore,
             platform,
             agentId,
             activeProfile,
-            binVersions: binVersions?.get(entry.name)
+            binVersions: binVersions?.get(entry.name),
+            readiness: readiness?.get(entry.name)
         })))));
 }
 function withSetup(entry, state) {

package/dist-lib/lib/tools/skills/cli-schema.js

@@ -5,7 +5,7 @@ import { buildSchemaAnnotation, buildSchemaCheck } from './cli-schema-check.js';
 import { createHash } from 'crypto';
 import fs from 'fs';
 import { errorCode } from '../../guards.js';
-import { stableStringify } from '../../machine/index.js';
+import { stableStringify } from '../../helpers/stable-stringify.js';
 const CLI_POLICY_VERSION = 1;
 function resourceIdentity(resourcePath) {
     try {

package/dist-lib/lib/tools/skills/frontmatter-parser.d.ts

@@ -1,4 +1,5 @@
 import type { InstallStep, SkillRequires, SkillSetup } from './manifest.ts';
+export { credentialSlots, type CredentialSlotSource } from './credential-slots.ts';
 export interface SkillFrontMatter {
     name?: string;
     description?: string;

package/dist-lib/lib/tools/skills/frontmatter-parser.js

@@ -1,4 +1,5 @@
 import { parseManifestBlock } from './manifest-parse.js';
+export { credentialSlots } from './credential-slots.js';
 const FRONT_MATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 const FIELD_RE = /^([A-Za-z_][\w-]*):(.*)$/;
 export function parseSkillFrontMatter(raw) {

package/dist-lib/lib/tools/skills/mention.d.ts

@@ -1,6 +1,5 @@
 import type { SkillCatalogEntry } from './catalog.ts';
 import { skillMentionName } from './mention-name.ts';
 export { skillMentionName };
-export declare function resolveSkillMention(text: string, catalog: readonly SkillCatalogEntry[]): SkillCatalogEntry | null;
+export declare function resolveSkillMention<Skill extends SkillCatalogEntry>(text: string, catalog: readonly Skill[]): Skill | null;
 export declare function resolveImplicitSkill(text: string, activeSkills: readonly SkillCatalogEntry[]): SkillCatalogEntry | null;
-export declare function skillPreloadMessage(content: string, name: string, body: string): string;

package/dist-lib/lib/tools/skills/mention.js

@@ -38,6 +38,3 @@ export function resolveImplicitSkill(text, activeSkills) {
     }
     return best;
 }
-export function skillPreloadMessage(content, name, body) {
-    return `[Skill invoked by user: ${name}]\n${body}\n\nThe user's message:\n${content}`;
-}

package/dist-lib/lib/tools/skills/scope-key.d.ts

@@ -1,7 +1,8 @@
+import type { SkillReadiness } from '../../contract/index.ts';
 export interface CredentialScope {
     readonly agentId?: string | null | undefined;
     readonly skill?: string | null | undefined;
     readonly key: string;
 }
 export declare function scopeKey({ agentId, skill, key }: CredentialScope): string;
-export declare function isDeviceSharedCredentialKey(key: string): boolean;
+export declare function deviceSharedKeys(readiness: Iterable<SkillReadiness>): Set<string>;

package/dist-lib/lib/tools/skills/scope-key.js

@@ -1,7 +1,6 @@
 export function scopeKey({ agentId, skill, key }) {
     return `${agentId ?? ''}\0${skill ?? ''}\0${key}`;
 }
-const DEVICE_SHARED_CREDENTIAL_KEYS = new Set(['obsidian_vault_path']);
-export function isDeviceSharedCredentialKey(key) {
-    return DEVICE_SHARED_CREDENTIAL_KEYS.has(key);
+export function deviceSharedKeys(readiness) {
+    return new Set([...readiness].flatMap((entry) => entry.deviceSharedKeys ?? []));
 }

package/dist-lib/lib/tools/skills/skill-state.d.ts

@@ -1,7 +1,7 @@
 import { type CredentialStoreFn } from './auth-resolver.ts';
 import type { SkillRequires, SkillSetup } from './manifest.ts';
 import { type SkillSettingsFn } from './skill-settings.ts';
-import { type ObsidianPathProbe } from './obsidian-readiness.ts';
+import type { SkillReadiness } from '../../contract/index.ts';
 import { type CapabilityProfile } from '../../models/model-catalog.ts';
 import { SKILL_STATE, isAvailableState, type SkillState } from './skill-state-constants.ts';
 export { SKILL_STATE, isAvailableState, type SkillState };
@@ -22,7 +22,7 @@ export interface SkillStateInputs {
     readonly agentId?: string | null | undefined;
     readonly binVersions?: ReadonlyMap<string, 'ok' | 'too-old' | 'unknown'> | undefined;
     readonly activeProfile?: CapabilityProfile | undefined;
-    readonly obsidianProbe?: ObsidianPathProbe;
+    readonly readiness?: SkillReadiness | undefined;
     readonly binOnPath?: (bin: string, platform?: string) => boolean;
 }
 export declare function isStub(entry: Pick<SkillStateEntry, 'stub'>): boolean;