@getbourdon/participants 0.5.5 → 0.6.0

package/dist/index.d.cts

@@ -1,6 +1,7 @@
-import { L5ManifestModel, SessionModel, VisibilityPolicyModel, EntityModel, Visibility } from '@getbourdon/l5';
-export { EntityModel, L5ManifestModel, SessionModel, Visibility, VisibilityPolicyModel, applyVisibility, filterForFederation, toDict, validateManifest } from '@getbourdon/l5';
+import { L5ManifestModel, SessionModel, SkillRefModel, SkillOriginModel, VisibilityPolicyModel, EntityModel, Visibility } from '@getbourdon/l5';
+export { EntityModel, L5ManifestModel, SessionModel, SkillRefModel, Visibility, VisibilityPolicyModel, applyVisibility, filterForFederation, toDict, validateManifest } from '@getbourdon/l5';
 import DatabaseT from 'better-sqlite3';
+import { FederationAudit } from '@getbourdon/federation';
 
 /**
  * Bourdon participant base — the Protocol → TS interface, errors, and the
@@ -317,6 +318,297 @@ declare class HermesParticipant implements BourdonParticipant {
     healthCheck(): HealthStatus;
 }
 
+/**
+ * Skill readers: advertise the local skills an agent can see in its L5
+ * manifest (plan 005, discovery side). Port of `participants/_skills.py`.
+ *
+ * A participant that knows where its agent keeps skills (a folder per skill
+ * holding a `SKILL.md` with `name` / `description` front matter) lists them as
+ * `SkillRef` rows: name, description and a content hash. Nothing is shared or
+ * promoted here; the body never enters the manifest.
+ *
+ * Two kinds of skill directory:
+ *  - **The agent's own** (`~/.claude/skills`, `$CODEX_HOME/skills`,
+ *    `~/.cursor/skills` and their project forms).
+ *  - **The cross-agent store**, `~/.agents/skills` (and `<project>/.agents/skills`):
+ *    a vendor-neutral directory no single agent owns. The cross-agent skills
+ *    installer CLI keeps its installs there and records each one in
+ *    `~/.agents/.skill-lock.json`; people also write skills there by hand. Refs
+ *    from it carry `store: cross_agent`. Every skill-reading participant reads
+ *    it with its own directories; a reader of several manifests collapses the
+ *    copies (`collectAdvertisedSkills` in @getbourdon/federation).
+ *
+ * One skill, one ref per manifest: when an agent's own folder holds a skill
+ * that is also in the cross-agent store, the agent-folder ref is kept and
+ * records the store copy in `also_in` (`via: copy` for a copy with the same
+ * `content_sha256`, `via: link` for a link into the store); the store's own ref
+ * is then left out. A link counts only when it resolves to a direct child
+ * folder of the store at the same scope, and the skill is then read through
+ * the store's own path, never through the link. Any other link is skipped.
+ *
+ * Provenance (user-level store only): a skill with an entry in the installer
+ * lock carries `origin: {kind: installed, ...}`; one without carries
+ * `origin: {kind: authored}`. Nothing else is read from the lock, and a
+ * missing, linked, oversized or malformed lock never fails a scan.
+ *
+ * Scope: one skill at a time. By default a participant lists only the skills
+ * the person approved one by one with `bourdon skills share` (stored locally
+ * in `<library>/.skill-shares.json`, see skill-shares.ts), and only while the
+ * folder still hashes to the approved content; no other skill folder is read.
+ * `BOURDON_SKILLS_ADVERTISE` set to an on value lists every skill; an off
+ * value or an unrecognised one lists none, shared or not. A caller that builds
+ * a participant with explicit `skillSources` lists every skill in them
+ * ({@link skillsListingMode}). The directories: user-level skill directories,
+ * and a project's directories
+ * only when the project is named in `BOURDON_SKILL_PROJECTS` (absolute paths
+ * separated by the platform's path delimiter). Disallowed files are skipped
+ * and flagged, never fatal; no link is followed; no absolute path reaches the
+ * manifest (`path_hint` starts at a symbolic root); refs are emitted as
+ * `team`.
+ */
+
+/** Opt-in list of project roots whose skill directories may be indexed. */
+declare const SKILL_PROJECTS_ENV = "BOURDON_SKILL_PROJECTS";
+/**
+ * The listing switch for every participant. Skill descriptions are free text
+ * and can name private projects, clients or infrastructure, so by default
+ * (unset or empty) only the skills approved one by one are listed. `1` /
+ * `true` / `yes` / `on` list every skill; `0` / `false` / `no` / `off` list
+ * none, approved or not, and so does any other value (fail closed): a typo
+ * never lists anything.
+ */
+declare const SKILLS_ADVERTISE_ENV = "BOURDON_SKILLS_ADVERTISE";
+/**
+ * Turns named participants off in every mode: agent ids separated by commas
+ * (or whitespace), e.g. `codex,cursor`. Matching ignores case.
+ */
+declare const SKILLS_NO_ADVERTISE_ENV = "BOURDON_SKILLS_NO_ADVERTISE";
+/** {@link skillsListingMode} results. */
+declare const LIST_ALL = "all";
+declare const LIST_APPROVED = "approved";
+declare const LIST_OFF = "off";
+type SkillsListingMode = typeof LIST_ALL | typeof LIST_APPROVED | typeof LIST_OFF;
+/** Every advertised ref carries this visibility. */
+declare const SKILL_REF_VISIBILITY: "team";
+/** The L5 schema bounds (`skills.maxItems` and the `SkillRef` fields). */
+declare const MAX_SKILL_REFS = 512;
+declare const MAX_SKIPPED_FILES = 32;
+declare const MAX_PATH_HINT_CHARS = 255;
+/** An installer lock larger than this is not read (origin is then omitted). */
+declare const MAX_LOCK_BYTES: number;
+declare const SCOPE_USER = "user";
+declare const SCOPE_PROJECT = "project";
+/** Whose directory a skill folder sits in; `agent` is the default and never written. */
+declare const STORE_AGENT = "agent";
+declare const STORE_CROSS_AGENT = "cross_agent";
+declare const VIA_COPY = "copy";
+declare const VIA_LINK = "link";
+declare const ORIGIN_INSTALLED = "installed";
+declare const ORIGIN_AUTHORED = "authored";
+/** The cross-agent installer's lock file, beside the user-level store. */
+declare const CROSS_AGENT_LOCK_NAME = ".skill-lock.json";
+/**
+ * One directory a reader indexes, one skill per child folder. `label` is the
+ * symbolic form of `root` that `path_hint` starts with; it never contains an
+ * absolute path. `store` says whose directory it is; `lockFile` is the
+ * installer lock that records where the store's skills came from.
+ */
+interface SkillSource {
+    root: string;
+    scope: string;
+    label: string;
+    project?: string | null;
+    store?: string;
+    lockFile?: string | null;
+}
+/** A skill (or a whole skills directory) that was not advertised, and why. */
+interface SkippedSkill {
+    pathHint: string;
+    scope: string;
+    reason: string;
+    project?: string | null;
+}
+interface SkillScanReport {
+    refs: SkillRefModel[];
+    skipped: SkippedSkill[];
+}
+/** The home directory user-level skill directories are found under. */
+declare function userHome(): string;
+/**
+ * Project roots opted in through {@link SKILL_PROJECTS_ENV}, in order. Only
+ * absolute paths count: a relative entry is ignored (and logged) rather than
+ * resolved against whatever directory the export happens to run in.
+ */
+declare function skillProjects(): string[];
+interface SkillSourceOptions {
+    /** The home directory to use instead of {@link userHome}. */
+    home?: string;
+    /** Project roots instead of {@link skillProjects}. */
+    projects?: readonly string[];
+}
+/**
+ * Claude Code: `<config dir>/skills` and, on opt-in, `<project>/.claude/skills`.
+ * The config directory is `CLAUDE_CONFIG_DIR` (Claude Code's own override),
+ * else `CLAUDE_HOME`, else `~/.claude`.
+ */
+declare function claudeCodeSkillSources(options?: SkillSourceOptions): SkillSource[];
+/**
+ * Codex: `$CODEX_HOME/skills`. `codexHome` is an explicit Codex home, if one
+ * was given; otherwise `CODEX_HOME`, else `~/.codex`. Codex keeps its bundled
+ * skills in a hidden `.system` folder there, which is not indexed. The mirror
+ * has no Codex participant yet; this is the source a Codex reader would use.
+ */
+declare function codexSkillSources(options?: {
+    codexHome?: string | null;
+    home?: string;
+}): SkillSource[];
+/**
+ * Cursor: `~/.cursor/skills` and, on opt-in, `<project>/.cursor/skills`.
+ * `CURSOR_HOME` overrides `~/.cursor`. `~/.cursor/skills-cursor` holds
+ * Cursor's own built-in skills and is not indexed.
+ */
+declare function cursorSkillSources(options?: SkillSourceOptions): SkillSource[];
+/**
+ * The vendor-neutral store: `~/.agents/skills` and, on opt-in,
+ * `<project>/.agents/skills`. The user-level store comes with the installer
+ * lock for provenance; no lock is read for a project store.
+ */
+declare function crossAgentSkillSources(options?: SkillSourceOptions): SkillSource[];
+type LockEntry = Record<string, unknown>;
+/**
+ * The `skills` table of the installer lock, keyed by skill name. An empty map
+ * when there is no lock (every store skill is then `authored`); `null` when a
+ * lock exists but cannot be trusted or parsed (a link, not a regular file, too
+ * large, not JSON, or without a `skills` mapping), in which case origin is left
+ * off rather than guessed.
+ */
+declare function readInstallLock(path: string): Map<string, LockEntry> | null;
+/**
+ * `installed` with the lock entry's sanitised source fields, else `authored`.
+ * Reads only `source`, `sourceType`, `sourceUrl` and `updatedAt`; a field
+ * that is missing, of the wrong type or fails its check is left out.
+ */
+declare function originFromLockEntry(entry: LockEntry | null | undefined): SkillOriginModel;
+/** Which child folders of a source to read: absent reads every one. */
+type SkillFolderFilter = (source: SkillSource, folderName: string) => boolean;
+interface ScanSkillSourcesOptions {
+    /**
+     * Limits the scan to the child folders it accepts; every other folder is
+     * passed over unread. A store folder that an accepted agent folder links to
+     * is read too, so the link resolves as in a full scan. An accepted agent
+     * folder that is a copy of a store folder the scan did not read carries no
+     * `also_in`.
+     */
+    include?: SkillFolderFilter | null;
+}
+/**
+ * Index every source; one ref per skill, first occurrence of a name wins per
+ * store and scope. Cross-agent stores are scanned first so the agent's own
+ * folders can be matched against them (`also_in`). Refs come back with the
+ * agent's own folders first, in source order, then the cross-agent store
+ * skills that no advertised agent folder already represents.
+ */
+declare function scanSkillSources(sources: Iterable<SkillSource>, options?: ScanSkillSourcesOptions): SkillScanReport;
+/** A participant that advertises skills (plan 005). */
+interface SkillAdvertiser {
+    agentId: string;
+    exportSkills(): SkillRefModel[];
+    /**
+     * Whether the participant was built with explicit `skillSources`, which
+     * lists every skill in them ({@link skillsListingMode}). Absent = no.
+     */
+    hasExplicitSkillSources?(): boolean;
+    /**
+     * The directories the reader indexes. When present, the default
+     * (approved-only) mode reads just the approved folders in them; without it
+     * the reader's own scan runs and only approved refs are kept.
+     */
+    skillSources?(): SkillSource[];
+}
+/**
+ * Which skills the participant `agentId` may list in its manifest.
+ *
+ *  - {@link LIST_APPROVED}: {@link SKILLS_ADVERTISE_ENV} unset or empty: only
+ *    the skills approved one by one (`bourdon skills share`) whose folder still
+ *    hashes to the approved content.
+ *  - {@link LIST_ALL}: an on value; or, while the variable is unset, a
+ *    participant built with explicit `skillSources` (the caller chose what to
+ *    index).
+ *  - {@link LIST_OFF}: an off value, or any unrecognised one (fail closed):
+ *    nothing is listed, approved or not.
+ *
+ * {@link SKILLS_NO_ADVERTISE_ENV} turns named participants off in every mode.
+ */
+declare function skillsListingMode(agentId: string, options?: {
+    explicitSources?: boolean;
+}): SkillsListingMode;
+/**
+ * Whether the participant `agentId` lists every skill it can see: true only
+ * in {@link LIST_ALL} mode ({@link skillsListingMode}). In the default mode a
+ * participant lists only the skills shared one by one.
+ */
+declare function skillsAdvertisingEnabled(agentId: string, options?: {
+    explicitSources?: boolean;
+}): boolean;
+/**
+ * The refs `participant`'s manifest carries, for `exportL5`.
+ *
+ * Follows {@link skillsListingMode}: nothing, and no skill directory read,
+ * when off; by default only the skills with a current approval, reading only
+ * their folders; every skill the reader sees when listing all. A participant
+ * built with explicit `skillSources` lists all unless turned off. A failure
+ * here never fails an export: skills are an addition to the manifest, not a
+ * reason to lose its memory rows. Private refs are dropped, as private
+ * entities are.
+ */
+declare function advertisedSkills(participant: SkillAdvertiser): SkillRefModel[];
+/**
+ * The default skill directories of a built-in skill-reading participant.
+ *
+ * The same directories the participant's own export reads (its user-level
+ * directory honouring its home override, the opted-in projects, and the
+ * cross-agent store). `null` for an agent with no skill reader here, so a skill
+ * it advertises can be listed but not proposed from this machine.
+ */
+declare function skillSourcesForAgent(agentId: string): SkillSource[] | null;
+/**
+ * The folder an advertised ref was scanned from, found through `sources` only.
+ *
+ * `ref` is a SkillRef as it sits in a manifest. Its `path_hint` is matched
+ * against each source's symbolic label (same scope and project), so the result
+ * is always one direct child of a directory the reader indexes; a path from
+ * anywhere else cannot be produced. A ref that is a link into the cross-agent
+ * store resolves to the store's own folder, as the reader read it. `null` when
+ * nothing matches.
+ */
+declare function resolveAdvertisedFolder(sources: readonly SkillSource[], ref: Readonly<Record<string, unknown>>): string | null;
+/** The built-in skill readers, in listing order. */
+declare const SKILL_READERS: readonly ["claude-code", "codex", "cursor"];
+/**
+ * One skill folder a built-in reader sees, for `bourdon skills available|share`.
+ *
+ * `agent` is the reader that owns the folder, or `null` for a cross-agent
+ * store folder; `agents` names every reader that sees it. Local use only:
+ * `folder` is an absolute path and never leaves the terminal command that
+ * asked for it.
+ */
+interface LocalSkill {
+    ref: SkillRefModel;
+    agent: string | null;
+    agents: string[];
+    folder: string;
+    /** `agent` or `cross_agent`. */
+    store: string;
+}
+/**
+ * Every skill folder the built-in readers see on this machine (each one is
+ * read). The same directories the readers' exports use: user-level, opted-in
+ * projects and the cross-agent store. One row per folder; a store folder seen
+ * by several readers is one row naming them all. `agent` keeps the folders
+ * that one reader sees.
+ */
+declare function localSkills(agent?: string | null): LocalSkill[];
+
 /**
  * Claude Code participant — reads agent-brain + auto-memory + MCP knowledge
  * graph. Port of `participants/claude_code.py`.
@@ -346,7 +638,25 @@ declare class ClaudeCodeParticipant implements BourdonParticipant {
     autoMemoryPath: string | null;
     knowledgeGraphPath: string | null;
     static defaultNativePath(home?: string): string;
-    constructor();
+    /**
+     * Explicit skill directories; `null` = the defaults (see skills.ts), read
+     * only for shared skills unless `BOURDON_SKILLS_ADVERTISE` lists all.
+     * Explicit sources list every skill in them.
+     */
+    private readonly explicitSkillSources;
+    constructor(options?: {
+        skillSources?: readonly SkillSource[] | null;
+    });
+    /**
+     * `~/.claude/skills` (or the config-dir override) and the cross-agent store,
+     * plus the opted-in projects' `.claude/skills` and `.agents/skills`.
+     */
+    /** Built with explicit skill sources: this participant lists all of them. */
+    hasExplicitSkillSources(): boolean;
+    skillSources(): SkillSource[];
+    /** Advertised skills plus the skills that could not be advertised. */
+    scanSkills(): SkillScanReport;
+    exportSkills(): SkillRefModel[];
     discover(): AgentStore;
     exportL5(since?: Date): L5ManifestModel;
     exportSessions(since?: Date, limit?: number): SessionModel[];
@@ -421,7 +731,27 @@ declare class CursorParticipant implements BourdonParticipant {
      * extraction intentionally use different anchors.
      */
     static defaultNativePath(home?: string): string;
-    constructor(cursorDir?: string | null, workspaceRoot?: string | null);
+    /**
+     * Explicit skill directories; `null` = the defaults (see skills.ts), read
+     * only for shared skills unless `BOURDON_SKILLS_ADVERTISE` lists all.
+     * Explicit sources list every skill in them.
+     * `workspaceRoot` does not opt a project in: that takes an explicit
+     * `BOURDON_SKILL_PROJECTS` entry, or explicit sources.
+     */
+    private readonly explicitSkillSources;
+    constructor(cursorDir?: string | null, workspaceRoot?: string | null, options?: {
+        skillSources?: readonly SkillSource[] | null;
+    });
+    /**
+     * `~/.cursor/skills` (not the built-in `skills-cursor`) and the cross-agent
+     * store, plus the opted-in projects' `.cursor/skills` and `.agents/skills`.
+     */
+    /** Built with explicit skill sources: this participant lists all of them. */
+    hasExplicitSkillSources(): boolean;
+    skillSources(): SkillSource[];
+    /** Advertised skills plus the skills that could not be advertised. */
+    scanSkills(): SkillScanReport;
+    exportSkills(): SkillRefModel[];
     get nativePath(): string;
     discover(): AgentStore;
     exportSessions(since?: Date, limit?: number): SessionModel[];
@@ -1040,6 +1370,625 @@ declare function recentSessionThreads(codexHome?: string | null, opts?: {
     limit?: number;
 }): RecentThread[];
 
+/**
+ * Per-skill share approvals: which local skills a participant may list. Port
+ * of the engine's `core/skill_shares.py`.
+ *
+ * Like approving a hook, a skill is listed in an agent's L5 manifest only
+ * after the person at this machine approves that one skill (`bourdon skills
+ * share`). Each approval pins the exact content approved: a skill whose folder
+ * has changed since is not listed again until it is re-approved.
+ *
+ * Layout (interoperable with the engine: either side reads what the other wrote):
+ *
+ *     <library>/.skill-shares.json
+ *
+ *     {
+ *       "version": 1,
+ *       "approvals": [
+ *         {
+ *           "kind": "skill",
+ *           "source": {
+ *             "agent": "alice",            // null: any reader of a cross-agent store skill
+ *             "store": "agent",            // "agent" | "cross_agent"
+ *             "scope": "user",             // "user" | "project"
+ *             "project": null,             // the project's folder name, for scope "project"
+ *             "path_hint": "~/.alice/skills/release-checklist"
+ *           },
+ *           "item": "release-checklist",
+ *           "content_sha256": "<64 hex>",
+ *           "approved_at": "2026-10-15T08:00:00Z",
+ *           "actor": "operator"
+ *         }
+ *       ]
+ *     }
+ *
+ * An approval is identified by `(kind, source, item, content_sha256)`. Only
+ * `kind: "skill"` is written today; an entry of a kind this version does not
+ * know is kept untouched on rewrite (and never treated as an approval).
+ * Approving an item again from the same source replaces its earlier approval,
+ * so a re-approved edit does not leave the old content approved.
+ *
+ * Load-bearing rules:
+ *
+ *  - **Local only.** The file sits beside the library's other local state and
+ *    is never synced: nothing in this package stages a library for the network,
+ *    and the engine's sync stages only `agents/*.l5.yaml`.
+ *  - **No absolute paths.** A share names its folder by the reader's symbolic
+ *    `path_hint` (`~/...`, `$ENV_VAR/...` or project-relative), never by where
+ *    it sits on disk.
+ *  - **Corruption means no approvals.** A missing, linked, oversized or
+ *    unparseable file reads as no shares at all, and a malformed entry is
+ *    dropped; reading never throws, so an export never fails here.
+ *  - **Writes are locked** with the same cross-process lock the library's other
+ *    writers use, and replace the file atomically.
+ *
+ * Nothing here is reachable over MCP; the terminal commands are the only
+ * writers, and they ask the person at the keyboard to confirm.
+ */
+declare const SHARES_FILENAME = ".skill-shares.json";
+declare const SHARES_VERSION = 1;
+/** The only approval kind written by this version. */
+declare const KIND_SKILL = "skill";
+/** Who approved a share. Only the operator's terminal writes this file. */
+declare const SHARE_ACTOR = "operator";
+/** A shares file larger than this is not read (it then holds no approvals). */
+declare const MAX_SHARES_BYTES: number;
+type Dict$3 = Record<string, unknown>;
+/** A share cannot be recorded (the file is unsafe to write, or the share is invalid). */
+declare class SkillShareError extends Error {
+    constructor(message: string);
+}
+/** One approval: this skill folder, with exactly this content, may be listed. */
+interface SkillShare {
+    name: string;
+    agent: string | null;
+    store: string;
+    scope: string;
+    project: string | null;
+    pathHint: string;
+    contentSha256: string;
+    approvedAt: string;
+    actor: string;
+}
+/** The skill folder a share is about, whoever reads it (a comparable key). */
+declare function shareFolderKey(share: SkillShare): string;
+/** The reader source: the same folder as read by the same reader. */
+declare function shareSourceKey(share: SkillShare): string;
+/** The approval's identity: `(kind, source, item, content_sha256)`. */
+declare function shareKey(share: SkillShare): string;
+/**
+ * Whether the participant `agentId` may list the skill under `share`. A share
+ * of an agent's own folder applies to that agent; a share of a cross-agent
+ * store skill with no `agent` applies to every reader of the store.
+ */
+declare function shareAppliesTo(share: SkillShare, agentId: string): boolean;
+/** The on-disk record, in the engine's key order. */
+declare function shareToDict(share: SkillShare): Dict$3;
+/**
+ * The library whose shares the participants' exports read. Resolved at call
+ * time (not import time) so a relocated home is honoured.
+ */
+declare function defaultSharesLibrary(): string;
+declare function sharesPath(libraryPath?: string | null): string;
+/**
+ * Every readable approval, in file order. Never throws.
+ *
+ * A missing file is no approvals. So is a file that is a link, not a regular
+ * file, too large, not JSON or of an unknown layout; a malformed entry is
+ * dropped and the rest are kept.
+ */
+declare function loadShares(libraryPath?: string | null): SkillShare[];
+interface AddShareOptions {
+    name: string;
+    agent: string | null;
+    store: string;
+    scope: string;
+    project: string | null;
+    pathHint: string;
+    contentSha256: string;
+    approvedAt?: string | null;
+}
+/**
+ * Record one approval, replacing earlier approvals of the same item from the
+ * same source. An unreadable shares file is replaced: it held no usable
+ * approvals.
+ */
+declare function addShare(libraryPath: string | null | undefined, options: AddShareOptions): SkillShare;
+/** Remove the shares whose {@link shareKey} is in `keys`; how many went. */
+declare function removeShares(libraryPath: string | null | undefined, keys: Iterable<string>): number;
+
+/**
+ * Reader-side skill folder scan (plan 005). Port of the parts of the engine's
+ * `core/skill_index.py` a participant needs to advertise a local skill: the
+ * text-only content rules, the no-follow folder walk, front-matter parsing,
+ * the `content_sha256` framing and `scan_local_skill` (skip and flag).
+ *
+ * `readSkillFolder` is the promotion-side twin of `scanLocalSkill`: it refuses
+ * a folder that breaks any rule instead of skipping files. The library-level
+ * shared store (index rows, versions, promotion) is in `skill-store.ts`. Both
+ * use the same limits and name rule, so a hash computed here compares
+ * directly with a shared skill's.
+ *
+ * Rules a v1 shared skill must meet (anything else is skipped and flagged):
+ *  - `SKILL.md` plus markdown, plain text and template files only;
+ *  - no links, no hidden entries, bounded depth and path length, no paths that
+ *    differ only in case;
+ *  - UTF-8 text without NUL bytes, no interpreter line, no credential-like text;
+ *  - per-file and total size caps, at most {@link MAX_REFERENCE_FILES} reference files.
+ */
+
+declare const SKILL_BODY_NAME = "SKILL.md";
+/** Reference-file types a v1 shared skill may carry: markdown, plain text and templates. */
+declare const TEXT_FILE_SUFFIXES: ReadonlySet<string>;
+declare const MAX_SKILL_BODY_BYTES: number;
+declare const MAX_REFERENCE_FILE_BYTES: number;
+declare const MAX_REFERENCE_FILES = 64;
+declare const MAX_SKILL_TOTAL_BYTES: number;
+/**
+ * Why a reader left a file out of an advertised skill. `limit` means the
+ * file-count or total-size cap was reached; every other code names the content
+ * rule the file breaks.
+ */
+declare const SKIP_REASONS: ReadonlySet<string>;
+/**
+ * A skill folder cannot be advertised (or shared) as it stands. `problems`
+ * lists every offending path with the reason; content is never echoed back.
+ */
+declare class SkillContentError extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+/** Python `str.strip()` with no argument. */
+declare function pyStrip(text: string): string;
+/** The first `limit` code points, as Python's `text[:limit]`. */
+declare function codePointSlice(text: string, limit: number): string;
+interface SkillFrontMatter {
+    name: string;
+    description: string;
+}
+/** Extract `name` and `description` from a `SKILL.md` body. Throws {@link SkillContentError}. */
+declare function parseFrontMatter(body: Uint8Array | string): SkillFrontMatter;
+/**
+ * Hash a skill's files as the schema's `content_sha256` defines: entries sorted
+ * by the UTF-8 bytes of their POSIX path relative to the skill folder, each
+ * framed as `path \0 len(bytes) \0 bytes`.
+ */
+declare function computeContentSha256(entries: Iterable<readonly [string, Uint8Array]>): string;
+/** One file a reader left out of a local skill, and why (a {@link SKIP_REASONS} code). */
+interface SkippedFile {
+    path: string;
+    reason: string;
+}
+/**
+ * What a participant reader can advertise about one local skill folder. `files`
+ * is the shareable part (`SKILL.md` plus every reference file that passes the
+ * v1 content rules); `skipped` lists the rest. The hash covers `files` only.
+ */
+interface LocalSkillScan {
+    frontMatter: SkillFrontMatter;
+    files: ReadonlyArray<readonly [string, Uint8Array]>;
+    skipped: readonly SkippedFile[];
+    contentSha256: string;
+}
+/**
+ * Scan one local skill folder for discovery: skip and flag, don't refuse.
+ *
+ * A disallowed reference file (a script, a binary, a link, a hidden file,
+ * credential-like text) is left out and reported in `skipped` instead of making
+ * the whole skill disappear. Only a `SKILL.md` that is missing, unreadable or
+ * itself breaks a content rule throws {@link SkillContentError}, because then
+ * there is nothing safe to advertise. Nothing is followed through a link and
+ * nothing is modified.
+ */
+declare function scanLocalSkill(folder: string): LocalSkillScan;
+/** A validated skill: front matter plus every file, `SKILL.md` included, sorted by path. */
+interface SkillContent {
+    frontMatter: SkillFrontMatter;
+    files: ReadonlyArray<readonly [string, Uint8Array]>;
+}
+/**
+ * Read a skill folder and enforce every v1 content rule (the oracle's
+ * `read_skill_folder`). Throws {@link SkillContentError} listing every problem
+ * found. The folder is read in place and never modified; links are reported,
+ * never followed.
+ */
+declare function readSkillFolder(folder: string): SkillContent;
+
+/**
+ * Shared skill store: the library-level home of federated procedural memory.
+ * Port of the store half of the engine's `core/skill_index.py` (plan 005,
+ * phase 1); the content rules it relies on are in `skill-index.ts`.
+ *
+ * Layout (one folder per shared skill, beside the per-agent manifests):
+ *
+ *     <library>/skills/<name>/
+ *         SKILL.md          verbatim body, as promoted
+ *         skill.yaml        index row (the skill index schema)
+ *         files/...         reference files, verbatim, text-only, size-capped
+ *         .versions/<n>/    the same three entries for each replaced version
+ *
+ * Load-bearing rules:
+ *
+ *  - **Org-tier write semantics.** The store is readable by every caller allowed
+ *    to read the federation and writable only through {@link promoteSkill}. The
+ *    ordinary federation write path never touches `<library>/skills`.
+ *  - **One namespace, rename at promotion.** A shared name belongs to one skill.
+ *    Promoting under a taken name throws {@link SkillNameCollisionError} with a
+ *    free suggestion, unless the caller updates that skill by passing the
+ *    current version as `expectedVersion` (also the compare-and-swap that stops
+ *    two promotions from silently overwriting each other). A renamed skill keeps
+ *    its front-matter name in `source_name`.
+ *  - **Fail closed on reads.** A row that does not validate is not served.
+ */
+
+type Dict$2 = Record<string, unknown>;
+declare const SKILL_INDEX_SPEC_VERSION = "0.1";
+declare const SKILLS_DIRNAME = "skills";
+declare const INDEX_ROW_NAME = "skill.yaml";
+declare const FILES_DIRNAME = "files";
+declare const VERSIONS_DIRNAME = ".versions";
+/** The shared store behaves as org-tier memory: readable by every federation
+ * reader, writable by no one through the ordinary write API. */
+declare const SKILL_STORE_WRITE_POLICY = "read-only";
+/** Promotion widens nothing unless the promoting caller asks it to. */
+declare const DEFAULT_SKILL_VISIBILITY = "private";
+declare const MAX_INDEX_ROW_BYTES: number;
+/** Base class for every refusal the skill store raises. */
+declare class SkillIndexError extends Error {
+    constructor(message: string);
+}
+/** An index row does not conform to the skill index schema. */
+declare class InvalidSkillRowError extends SkillIndexError {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+/** The shared name is already taken and the caller did not ask to update it. */
+declare class SkillNameCollisionError extends SkillIndexError {
+    readonly skillName: string;
+    readonly existingVersion: number;
+    readonly suggestedName: string | null;
+    constructor(name: string, existingVersion: number, suggestedName: string | null);
+}
+/** `expectedVersion` does not match what is in the store. */
+declare class SkillVersionConflictError extends SkillIndexError {
+    readonly skillName: string;
+    readonly expected: number | null;
+    readonly current: number | null;
+    constructor(name: string, expected: number | null, current: number | null);
+}
+/** No shared skill (or no such version of it) exists. */
+declare class SkillNotFoundError extends SkillIndexError {
+    constructor(message: string);
+}
+/** Return `name` if it is a valid shared skill name, else throw {@link SkillIndexError}. */
+declare function validateSkillName(name: unknown): string;
+/**
+ * Check a parsed `skill.yaml` mapping against the schema's rules. Returns every
+ * violation found (empty means valid), in the oracle's order and wording.
+ */
+declare function validateIndexRow(row: unknown): string[];
+/** One validated `skill.yaml`. */
+declare class SkillIndexRow {
+    readonly specVersion: string;
+    readonly name: string;
+    readonly sourceName: string | null;
+    readonly description: string;
+    readonly version: number;
+    readonly contentSha256: string;
+    readonly sourceAgent: string;
+    readonly promotedBy: string;
+    readonly promotedAt: string;
+    readonly proposalId: string | null;
+    readonly visibility: string;
+    readonly validTo: string | null;
+    readonly supersedes: number | null;
+    private constructor();
+    /** Validate `data` and build a row; throws {@link InvalidSkillRowError}. */
+    static fromDict(data: unknown): SkillIndexRow;
+    /** Serialize in schema order, omitting absent optional fields. */
+    toDict(): Dict$2;
+    /** False once `valid_to` is on or before `today` (UTC today by default, `YYYY-MM-DD`). */
+    isActive(today?: string): boolean;
+}
+/** Read and validate one `skill.yaml`. */
+declare function loadIndexRow(path: string): SkillIndexRow;
+/** Validate `row` and write it atomically to `path`. */
+declare function writeIndexRow(path: string, row: SkillIndexRow): void;
+/** `<library>/skills` -- the shared skill store. */
+declare function skillsRoot(libraryPath: string): string;
+/** The folder of one shared skill; `name` is validated first. */
+declare function skillDir(libraryPath: string, name: string): string;
+/**
+ * The index row for `name` (the live one, or an archived `version`). Throws
+ * {@link SkillNotFoundError} when absent and {@link InvalidSkillRowError} when
+ * present but invalid.
+ */
+declare function getSkillRow(libraryPath: string, name: string, version?: number | null): SkillIndexRow;
+/**
+ * Every valid live index row, sorted by name. Retired rows are omitted unless
+ * `includeRetired`. Rows that fail validation are skipped (and logged) rather
+ * than served.
+ */
+declare function listSkillRows(libraryPath: string, options?: {
+    includeRetired?: boolean;
+    today?: string;
+}): SkillIndexRow[];
+/** Every version number on disk for `name`, oldest first. */
+declare function listSkillVersions(libraryPath: string, name: string): number[];
+/** The row and the stored files of one shared skill version. */
+declare function readSharedSkill(libraryPath: string, name: string, version?: number | null): {
+    row: SkillIndexRow;
+    content: SkillContent;
+};
+/** Whether the stored files still hash to the row's `content_sha256`. */
+declare function verifySharedSkill(libraryPath: string, name: string, version?: number | null): boolean;
+/**
+ * A free shared name derived from `name` (`name-2`, `name-3`...). Returns null
+ * only if no candidate within the length limit is free.
+ */
+declare function suggestAvailableName(libraryPath: string, name: string): string | null;
+interface PromotionResult {
+    row: SkillIndexRow;
+    /** False when the content already matched the live version (nothing written). */
+    changed: boolean;
+}
+interface PromoteSkillOptions {
+    sourceAgent: string;
+    promotedBy: string;
+    /** Shared name; defaults to the front-matter name. Another name renames at promotion. */
+    name?: string | null;
+    /** The live version when replacing a skill; null/absent for a new one. */
+    expectedVersion?: number | null;
+    visibility?: string;
+    proposalId?: string | null;
+    /** ISO 8601 with a UTC offset; defaults to now, to the second. */
+    promotedAt?: string | null;
+}
+/**
+ * Write `content` into the shared store as a new skill or a new version.
+ *
+ * This is the store's only write path and performs no authorization: the
+ * caller (the promotion gate) must already have established that a trusted
+ * caller approved it. `content` must come from `readSkillFolder`.
+ *
+ *  - `name` defaults to the front-matter name. Another name renames at
+ *    promotion; the front-matter name is then kept as `source_name`.
+ *  - If the name is free, `expectedVersion` must be null.
+ *  - If the name is taken, `expectedVersion` must equal the live version; null
+ *    throws {@link SkillNameCollisionError} (with a free name to suggest) and
+ *    any other value throws {@link SkillVersionConflictError}.
+ *  - Content identical to the live version is a no-op (`changed: false`).
+ *
+ * The previous version moves to `.versions/<n>/`. `skill.yaml` is moved out
+ * first and written last, so a reader never sees a row next to the wrong body;
+ * an interrupted promotion leaves the skill unlisted, with the old version
+ * intact under `.versions/`.
+ */
+declare function promoteSkill(libraryPath: string, content: SkillContent, options: PromoteSkillOptions): PromotionResult;
+/**
+ * Set (retire) or clear (restore) the live row's `valid_to`.
+ *
+ * Retirement is a row edit, not a new version: the body and its hash are
+ * untouched, so every version stays fetchable by number. Like
+ * {@link promoteSkill} this performs no authorization; the caller is the gate.
+ * `expectedVersion` must equal the live version (compare-and-swap, under the
+ * same lock promotion writes under).
+ */
+declare function setSkillValidTo(libraryPath: string, name: string, validTo: string | null, options: {
+    expectedVersion: number;
+}): SkillIndexRow;
+
+/**
+ * Skill proposals: the approval gate in front of the shared skill library.
+ * Port of the engine's `core/skill_proposals.py` (plan 005, phase 4).
+ *
+ * An agent *proposes* one of the skills it advertises; a person *approves* it;
+ * only then does {@link promoteSkill} write it into `<library>/skills`.
+ *
+ * Layout (interoperable with the engine: either side reads what the other wrote):
+ *
+ *     <library>/.skill-proposals/<proposal_id>/
+ *         proposal.yaml     the record: what was proposed, by whom, and the decision
+ *         content/          a snapshot of the skill folder, taken at proposal time
+ *
+ * Load-bearing rules:
+ *
+ *  - **The snapshot is what gets approved.** Proposing copies the skill's files
+ *    into `content/` and records their `content_sha256`. Approval re-reads that
+ *    snapshot, re-checks every text-only rule and refuses unless it still hashes
+ *    to the recorded value, so editing the agent's folder after proposing cannot
+ *    change what lands in the library.
+ *  - **One human-confirmed approval promotes.** Nothing in this module is
+ *    reachable over MCP except {@link createProposal}. Approval, rejection,
+ *    retirement and rollback are called by the operator's terminal command,
+ *    which asks the person at the keyboard to confirm. Consensus votes on a
+ *    proposal's ballot are advisory: they are shown to the approver and recorded
+ *    beside the decision, and never promote anything on their own.
+ *  - **Every decision is audited before it happens, fail-closed**, in the same
+ *    federation audit log the quarantine staging decisions use.
+ *
+ * Nothing here performs caller authorization; the callers (the MCP tool for
+ * proposing, the CLI for deciding) are the gates.
+ */
+
+type Dict$1 = Record<string, unknown>;
+declare const PROPOSALS_DIRNAME = ".skill-proposals";
+declare const RECORD_NAME = "proposal.yaml";
+declare const CONTENT_DIRNAME = "content";
+declare const STATUS_PENDING = "pending";
+declare const STATUS_APPROVED = "approved";
+declare const STATUS_REJECTED = "rejected";
+declare const PROPOSER_TRUSTED = "trusted";
+declare const PROPOSER_QUARANTINED = "quarantined";
+/** The advisory ballot's options. A ballot only informs the person deciding. */
+declare const BALLOT_OPTIONS: readonly ["approve", "reject"];
+/** Tunable limits. `maxPendingPerProposer`: pending proposals one proposer may
+ * hold at once, so a caller cannot fill the library with snapshots nobody
+ * asked for. */
+declare const SKILL_PROPOSAL_LIMITS: {
+    maxPendingPerProposer: number;
+    maxReasonChars: number;
+};
+/** Base class for refusals raised by the proposal gate. */
+declare class SkillProposalError extends SkillIndexError {
+    constructor(message: string);
+}
+/** No proposal with that id. */
+declare class ProposalNotFoundError extends SkillProposalError {
+    constructor(message: string);
+}
+/** The proposal is not pending (it was already decided). */
+declare class ProposalStateError extends SkillProposalError {
+    constructor(message: string);
+}
+/** The snapshot no longer hashes to what was proposed, or to what the approver saw. */
+declare class ProposalDigestMismatchError extends SkillProposalError {
+    constructor(message: string);
+}
+/** One proposal record (`proposal.yaml`). Field names follow the on-disk keys. */
+interface SkillProposal {
+    proposal_id: string;
+    name: string;
+    description: string;
+    content_sha256: string;
+    source_agent: string;
+    proposed_by: string;
+    proposer_tier: string;
+    created_at: string;
+    path_hint: string;
+    scope: string;
+    visibility: string;
+    project: string | null;
+    origin: Dict$1 | null;
+    files: Dict$1[];
+    ballot: boolean;
+    status: string;
+    decision: Dict$1 | null;
+}
+/** The record as written: the engine's key order, absent optionals omitted. */
+declare function proposalToDict(proposal: SkillProposal): Dict$1;
+/** Parse a record; throws {@link SkillProposalError} on anything malformed. */
+declare function proposalFromDict(data: unknown): SkillProposal;
+/** The row a listing shows: no file list, no decision detail. */
+declare function proposalSummary(proposal: SkillProposal): Dict$1;
+declare function isProposalId(value: unknown): value is string;
+/** `<library>/.skill-proposals`. */
+declare function proposalsRoot(libraryPath: string): string;
+/** Read one proposal; throws {@link ProposalNotFoundError} or {@link SkillProposalError}. */
+declare function loadProposal(libraryPath: string, proposalId: string): SkillProposal;
+/** Every readable proposal (optionally of one `status`), oldest first. */
+declare function listProposals(libraryPath: string, status?: string | null): SkillProposal[];
+interface CreateProposalOptions {
+    /** The advertised SkillRef, as it sits in the agent's manifest. */
+    ref: Readonly<Dict$1>;
+    sourceAgent: string;
+    proposedBy: string;
+    proposerTier: string;
+    createdAt?: string | null;
+}
+/**
+ * Snapshot `content` into a new pending proposal.
+ *
+ * `content` must come from `readSkillFolder` over the folder the agent's own
+ * reader resolved for `ref` (the advertised SkillRef). Returns
+ * `{ proposal, created }`: proposing the same bytes of the same skill again
+ * while a proposal is pending returns that proposal unchanged.
+ */
+declare function createProposal(libraryPath: string, content: SkillContent, options: CreateProposalOptions): {
+    proposal: SkillProposal;
+    created: boolean;
+};
+/** The snapshot, re-checked against every content rule and its recorded hash. */
+declare function readProposalContent(libraryPath: string, proposal: SkillProposal): SkillContent;
+/** The shared skill already using `name`, if any (retired included). */
+declare function collisionFor(libraryPath: string, name: string): SkillIndexRow | null;
+/**
+ * Open a consensus ballot under the proposal's id. Votes on it only advise.
+ *
+ * Returns false (and leaves the proposal without a ballot) when one cannot be
+ * opened; a proposal never fails over its advisory ballot.
+ */
+declare function openAdvisoryBallot(libraryPath: string, proposal: SkillProposal): boolean;
+type AdvisoryTally = Record<(typeof BALLOT_OPTIONS)[number], {
+    votes: number;
+    voters: string[];
+}>;
+/** Vote counts and voters on the proposal's ballot; null without one. */
+declare function advisoryTally(libraryPath: string, proposal: SkillProposal): AdvisoryTally | null;
+interface ApprovalResult {
+    proposal: SkillProposal;
+    row: SkillIndexRow;
+    changed: boolean;
+    renamedFrom: string | null;
+    advisory: AdvisoryTally | null;
+}
+interface ApproveProposalOptions {
+    approvedBy: string;
+    channel: string;
+    /** At least 8 hex characters: pins the decision to the bytes reviewed. */
+    expectedSha256?: string | null;
+    name?: string | null;
+    update?: boolean;
+    visibility?: string | null;
+    audit?: FederationAudit | null;
+}
+/**
+ * Promote a pending proposal's snapshot into the shared library.
+ *
+ * This is the one human-confirmed approval. It is not exposed over MCP; the
+ * operator's terminal command calls it after asking the person at the keyboard
+ * to confirm (`channel` records how).
+ *
+ * Naming: the skill's own name by default, or `name`. When that name is taken,
+ * `update: true` promotes the snapshot as the next version of the existing
+ * skill; otherwise the skill is renamed to a free name and the original name is
+ * reported in `renamedFrom`.
+ */
+declare function approveProposal(libraryPath: string, proposalId: string, options: ApproveProposalOptions): ApprovalResult;
+interface RejectProposalOptions {
+    rejectedBy: string;
+    channel: string;
+    reason?: string;
+    expectedSha256?: string | null;
+    audit?: FederationAudit | null;
+}
+/** Mark a pending proposal rejected. The snapshot is kept for the record. */
+declare function rejectProposal(libraryPath: string, proposalId: string, options: RejectProposalOptions): SkillProposal;
+/**
+ * Retire the live version (`valid_to`, default today). Versions are kept.
+ *
+ * A retired skill leaves the default index and `get_skill` without a version;
+ * every version stays fetchable by number, and {@link rollbackSharedSkill}
+ * brings one back.
+ */
+declare function retireSharedSkill(libraryPath: string, name: string, options: {
+    retiredBy: string;
+    channel: string;
+    validTo?: string | null;
+    audit?: FederationAudit | null;
+}): SkillIndexRow;
+interface RollbackResult {
+    row: SkillIndexRow;
+    /** True when a new version was written. */
+    changed: boolean;
+    /** True when a retirement was lifted. */
+    restored: boolean;
+}
+/**
+ * Make version `toVersion`'s content current again, as a NEW version.
+ *
+ * History is never rewritten: rolling back to version 2 of a skill at version 4
+ * writes version 5 with version 2's files (re-hashed before they are used), so
+ * every version stays fetchable. Rolling back a retired skill also lifts the
+ * retirement; rolling back to the live version of a retired skill only lifts it.
+ */
+declare function rollbackSharedSkill(libraryPath: string, name: string, toVersion: number, options: {
+    promotedBy: string;
+    channel: string;
+    audit?: FederationAudit | null;
+}): RollbackResult;
+
 /**
  * Participant discovery — a STATIC TS registry replacing Python's `pkgutil`
  * package scan + entry-point duck-type (`participants/__init__.py`).
@@ -1248,4 +2197,4 @@ declare class V0Participant extends ExportStoreParticipant {
     static defaultNativePath(home?: string): string;
 }
 
-export { type AgentStore, type AuthProvider, BOLT_CONFIG, BoltParticipant, type BourdonParticipant, CONTRACT_VERSION, CacheEntry, CascadeParticipant, ClaudeCodeAutomationsParticipant, ClaudeCodeParticipant, ClaudeDesktopCodeParticipant, ClaudeDesktopCoworkParticipant, CodexAutomationsParticipant, CopilotAutomationsParticipant, CopilotCliParticipant, CopilotParticipant, CopilotVscodeParticipant, CursorAutomationsParticipant, CursorParticipant, DEFAULT_CACHE_TTL_SECONDS, DEFAULT_RECENT_THREAD_LIMIT, DEFAULT_TITLE_LIMIT, type ExportStoreConfig, ExportStoreParticipant, FIRST_PARTY, GitHubCopilotParticipant, type HealthStatus, HermesParticipant, LOVABLE_CONFIG, LovableParticipant, MIN_PATCHED_VERSION, NETWORK_CONTRACT_VERSION, NetworkParticipant, type NetworkParticipantOptions, NetworkUnavailable, OpenClawApiClient, OpenClawParticipant, type OpenReadonlyOptions, PROJECT_HINTS_ENV, ParticipantAuthError, type ParticipantCtor, ParticipantDiscoveryError, ParticipantError, ParticipantExportError, ParticipantVersionMismatchError, PayloadCache, type RecentThread, SPEC_VERSION, type SqliteDatabase, V0Participant, V0_CONFIG, defaultCacheRoot, discoverParticipants, envAuthProvider, epochToIsoDate, epochToIsoDatetime, friendlyLabel, ghTokenProvider, isParticipant, isoDate, loadProjectHints, openReadonly, parseSessionIndex, parseVisibility, projectKeyFromCwd, recentSessionThreads, resolveCodexHome, resolvePluginParticipants, safeStr, safeStrList, sessionThreadTitles, sqliteAvailable, tableColumns, tableExists, tryOpenReadonly, verifyInstance };
+export { type AddShareOptions, type AdvisoryTally, type AgentStore, type ApprovalResult, type ApproveProposalOptions, type AuthProvider, BALLOT_OPTIONS, BOLT_CONFIG, BoltParticipant, type BourdonParticipant, CONTENT_DIRNAME, CONTRACT_VERSION, CROSS_AGENT_LOCK_NAME, CacheEntry, CascadeParticipant, ClaudeCodeAutomationsParticipant, ClaudeCodeParticipant, ClaudeDesktopCodeParticipant, ClaudeDesktopCoworkParticipant, CodexAutomationsParticipant, CopilotAutomationsParticipant, CopilotCliParticipant, CopilotParticipant, CopilotVscodeParticipant, type CreateProposalOptions, CursorAutomationsParticipant, CursorParticipant, DEFAULT_CACHE_TTL_SECONDS, DEFAULT_RECENT_THREAD_LIMIT, DEFAULT_SKILL_VISIBILITY, DEFAULT_TITLE_LIMIT, type ExportStoreConfig, ExportStoreParticipant, FILES_DIRNAME, FIRST_PARTY, GitHubCopilotParticipant, type HealthStatus, HermesParticipant, INDEX_ROW_NAME, InvalidSkillRowError, KIND_SKILL, LIST_ALL, LIST_APPROVED, LIST_OFF, LOVABLE_CONFIG, type LocalSkill, type LocalSkillScan, LovableParticipant, MAX_INDEX_ROW_BYTES, MAX_LOCK_BYTES, MAX_PATH_HINT_CHARS, MAX_REFERENCE_FILES, MAX_REFERENCE_FILE_BYTES, MAX_SHARES_BYTES, MAX_SKILL_BODY_BYTES, MAX_SKILL_REFS, MAX_SKILL_TOTAL_BYTES, MAX_SKIPPED_FILES, MIN_PATCHED_VERSION, NETWORK_CONTRACT_VERSION, NetworkParticipant, type NetworkParticipantOptions, NetworkUnavailable, ORIGIN_AUTHORED, ORIGIN_INSTALLED, OpenClawApiClient, OpenClawParticipant, type OpenReadonlyOptions, PROJECT_HINTS_ENV, PROPOSALS_DIRNAME, PROPOSER_QUARANTINED, PROPOSER_TRUSTED, ParticipantAuthError, type ParticipantCtor, ParticipantDiscoveryError, ParticipantError, ParticipantExportError, ParticipantVersionMismatchError, PayloadCache, type PromoteSkillOptions, type PromotionResult, ProposalDigestMismatchError, ProposalStateError, RECORD_NAME, type RecentThread, type RejectProposalOptions, type RollbackResult, SCOPE_PROJECT, SCOPE_USER, SHARES_FILENAME, SHARES_VERSION, SHARE_ACTOR, SKILLS_ADVERTISE_ENV, SKILLS_DIRNAME, SKILLS_NO_ADVERTISE_ENV, SKILL_BODY_NAME, SKILL_INDEX_SPEC_VERSION, SKILL_PROJECTS_ENV, SKILL_PROPOSAL_LIMITS, SKILL_READERS, SKILL_REF_VISIBILITY, SKILL_STORE_WRITE_POLICY, SKIP_REASONS, SPEC_VERSION, STATUS_APPROVED, STATUS_PENDING, STATUS_REJECTED, STORE_AGENT, STORE_CROSS_AGENT, type ScanSkillSourcesOptions, type SkillAdvertiser, type SkillContent, SkillContentError, type SkillFolderFilter, type SkillFrontMatter, SkillIndexError, SkillIndexRow, SkillNameCollisionError, SkillNotFoundError, type SkillProposal, SkillProposalError, ProposalNotFoundError as SkillProposalNotFoundError, type SkillScanReport, type SkillShare, SkillShareError, type SkillSource, type SkillSourceOptions, SkillVersionConflictError, type SkillsListingMode, type SkippedFile, type SkippedSkill, type SqliteDatabase, TEXT_FILE_SUFFIXES, V0Participant, V0_CONFIG, VERSIONS_DIRNAME, VIA_COPY, VIA_LINK, addShare, advertisedSkills, advisoryTally, approveProposal, claudeCodeSkillSources, codePointSlice, codexSkillSources, collisionFor, computeContentSha256, createProposal, crossAgentSkillSources, cursorSkillSources, defaultCacheRoot, defaultSharesLibrary, discoverParticipants, envAuthProvider, epochToIsoDate, epochToIsoDatetime, friendlyLabel, getSkillRow, ghTokenProvider, isParticipant, isProposalId, isoDate, listProposals, listSkillRows, listSkillVersions, loadIndexRow, loadProjectHints, loadProposal, loadShares, localSkills, openAdvisoryBallot, openReadonly, originFromLockEntry, parseFrontMatter, parseSessionIndex, parseVisibility, projectKeyFromCwd, promoteSkill, proposalFromDict, proposalSummary, proposalToDict, proposalsRoot, pyStrip, readInstallLock, readProposalContent, readSharedSkill, readSkillFolder, recentSessionThreads, rejectProposal, removeShares, resolveAdvertisedFolder, resolveCodexHome, resolvePluginParticipants, retireSharedSkill, rollbackSharedSkill, safeStr, safeStrList, scanLocalSkill, scanSkillSources, sessionThreadTitles, setSkillValidTo, shareAppliesTo, shareFolderKey, shareKey, shareSourceKey, shareToDict, sharesPath, skillDir, skillProjects, skillSourcesForAgent, skillsAdvertisingEnabled, skillsListingMode, skillsRoot, sqliteAvailable, suggestAvailableName, tableColumns, tableExists, tryOpenReadonly, userHome, validateIndexRow, validateSkillName, verifyInstance, verifySharedSkill, writeIndexRow };