@skrr-ai/cli 0.1.37 → 0.1.39

package/dist/lib/first-party-harness-doctor.js

@@ -36,6 +36,7 @@ exports.projectStateDir = projectStateDir;
 exports.runDoctor = runDoctor;
 exports.formatReport = formatReport;
 const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const first_party_harness_1 = require("./first-party-harness");
 const auth_core_1 = require("@skrr-ai/auth-core");
@@ -285,40 +286,138 @@ function stateDirCheck(cwd, env) {
     ];
     return { name: 'state-paths', status: 'ok', detail: parts.join('; ') };
 }
-function compatCheck(cwd, env) {
-    // Report both the engine's own writable instruction surfaces and read-only
-    // compatibility sources so "where did this instruction come from?" has an
-    // answer — a WL-2 acceptance criterion.
-    const root = node_path_1.default.resolve(cwd);
-    const own = [];
-    for (const file of [
-        node_path_1.default.join(projectStateDir(root), 'AGENTS.md'),
-        node_path_1.default.join((0, first_party_harness_1.engineInstructionHome)(env), 'AGENTS.md'),
-    ]) {
-        if ((0, node_fs_1.existsSync)(file))
-            own.push(file);
+/**
+ * Skill directories directly under `root` that hold a SKILL.md.
+ *
+ * A symlinked skill directory counts: installers and dotfile managers link
+ * skills in, and a count that skipped them reported 11 of a root's 31.
+ */
+function countSkills(root) {
+    try {
+        return (0, node_fs_1.readdirSync)(root).filter((name) => {
+            try {
+                return ((0, node_fs_1.statSync)(node_path_1.default.join(root, name)).isDirectory() &&
+                    (0, node_fs_1.existsSync)(node_path_1.default.join(root, name, 'SKILL.md')));
+            }
+            catch {
+                return false;
+            }
+        }).length;
     }
-    const compatibility = [];
-    for (const rel of ['AGENTS.md', 'CLAUDE.md', '.agents/skills', '.claude/skills']) {
-        if ((0, node_fs_1.existsSync)(node_path_1.default.join(root, rel)))
-            compatibility.push(rel);
+    catch {
+        return 0;
     }
-    if (own.length === 0 && compatibility.length === 0) {
+}
+function compatCheck(cwd, env) {
+    // Report every instruction and skill source the engine reads, owned and
+    // compatibility alike, so "where did this come from?" has an answer — a WL-2
+    // acceptance criterion.
+    //
+    // It named two skill roots, project-level only, as bare directory names: the
+    // user-level `~/.agents/skills` and `~/.claude/skills` the engine also reads
+    // were missing, an empty root and a full one looked the same, and nothing said
+    // why a machine's other roots (.devin, .windsurf, .codex, …) were absent — so
+    // a reader could not tell "not read" from "not reported" (OSK-9357). The set
+    // below is the engine's documented compatibility contract
+    // (opencode-white-label-implementation-plan §7.2); roots beyond it reach a
+    // session only when the daemon links them in, which `skrr skills local` shows.
+    const root = node_path_1.default.resolve(cwd);
+    const home = env.HOME || (0, node_os_1.homedir)();
+    const projectDir = auth_core_1.FIRST_PARTY_HARNESS_ENGINE.projectDirectory;
+    const noCompatPrompts = Boolean(env[auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts]);
+    const engineHomeDir = (0, first_party_harness_1.engineInstructionHome)(env);
+    const shown = (abs) => abs.startsWith(root + node_path_1.default.sep)
+        ? node_path_1.default.relative(root, abs)
+        : abs.startsWith(home + node_path_1.default.sep)
+            ? `~/${node_path_1.default.relative(home, abs)}`
+            : abs;
+    const declared = [
+        {
+            abs: node_path_1.default.join(root, projectDir, 'AGENTS.md'),
+            kind: 'instructions',
+            owner: 'engine',
+            scope: 'project',
+        },
+        {
+            abs: node_path_1.default.join(engineHomeDir, 'AGENTS.md'),
+            kind: 'instructions',
+            owner: 'engine',
+            scope: 'user',
+        },
+        {
+            abs: node_path_1.default.join(root, 'AGENTS.md'),
+            kind: 'instructions',
+            owner: 'compatibility',
+            scope: 'project',
+        },
+        {
+            abs: node_path_1.default.join(root, 'CLAUDE.md'),
+            kind: 'instructions',
+            owner: 'compatibility',
+            scope: 'project',
+            ...(noCompatPrompts ? { disabled: auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts } : {}),
+        },
+        {
+            abs: node_path_1.default.join(home, '.claude', 'CLAUDE.md'),
+            kind: 'instructions',
+            owner: 'compatibility',
+            scope: 'user',
+            ...(noCompatPrompts ? { disabled: auth_core_1.FIRST_PARTY_HARNESS_ENGINE.env.noCompatPrompts } : {}),
+        },
+        {
+            abs: node_path_1.default.join(root, '.agents', 'skills'),
+            kind: 'skills',
+            owner: 'compatibility',
+            scope: 'project',
+        },
+        {
+            abs: node_path_1.default.join(root, '.claude', 'skills'),
+            kind: 'skills',
+            owner: 'compatibility',
+            scope: 'project',
+        },
+        {
+            abs: node_path_1.default.join(home, '.agents', 'skills'),
+            kind: 'skills',
+            owner: 'compatibility',
+            scope: 'user',
+        },
+        {
+            abs: node_path_1.default.join(home, '.claude', 'skills'),
+            kind: 'skills',
+            owner: 'compatibility',
+            scope: 'user',
+        },
+    ];
+    const sources = declared.map(({ abs, ...source }) => {
+        const present = (0, node_fs_1.existsSync)(abs);
         return {
-            name: 'compat-sources',
-            status: 'ok',
-            detail: `no ${auth_core_1.FIRST_PARTY_HARNESS.displayName}-owned or compatibility instruction files in this project`,
+            path: shown(abs),
+            ...source,
+            present,
+            ...(source.kind === 'skills' && present ? { skills: countSkills(abs) } : {}),
         };
-    }
-    const details = [];
-    if (own.length > 0)
-        details.push(`${auth_core_1.FIRST_PARTY_HARNESS.displayName}-owned: ${own.join(', ')}`);
-    if (compatibility.length > 0)
-        details.push(`compatibility (read-only): ${compatibility.join(', ')}`);
+    });
+    const describe = (source) => {
+        if (!source.present)
+            return `${source.path} (absent)`;
+        if (source.disabled)
+            return `${source.path} (off: ${source.disabled})`;
+        if (source.kind === 'skills') {
+            return `${source.path} (${source.skills} skill${source.skills === 1 ? '' : 's'})`;
+        }
+        return source.path;
+    };
+    const owned = sources.filter((source) => source.owner === 'engine');
+    const compatibility = sources.filter((source) => source.owner === 'compatibility');
     return {
         name: 'compat-sources',
         status: 'ok',
-        detail: details.join('; '),
+        detail: `${auth_core_1.FIRST_PARTY_HARNESS.displayName}-owned: ${owned.map(describe).join(', ')}; ` +
+            `compatibility (read-only): ${compatibility.map(describe).join(', ')}. ` +
+            'A daemon-hosted session also gets the skills its daemon discovers under other roots ' +
+            '(.devin, .windsurf, .codex, …) — `skrr skills local` lists them.',
+        sources,
     };
 }
 function opencodeCheck(cwd) {

package/dist/lib/followups.d.ts

@@ -1,11 +1,18 @@
 import { withQuery } from './triggers';
 type Query = Parameters<typeof withQuery>[1];
 type Json = Record<string, unknown>;
-export declare const FOLLOWUP_KINDS: readonly ["reminder", "watch", "checkin", "act"];
-export type FollowUpKind = (typeof FOLLOWUP_KINDS)[number];
-export declare const FOLLOWUP_STATES: readonly ["armed", "proposed", "settled", "paused"];
-/** Terminals a caller may name on `resolve` — the rest are the runtime's. */
-export declare const FOLLOWUP_RESOLVE_OUTCOMES: readonly ["resolved", "abandoned"];
+/**
+ * The `id` argument every follow-up command that addresses one takes.
+ *
+ * oclif treats an empty string as a PRESENT required argument, so a scripted
+ * `skrr followups show "$ID"` with an empty variable built `/api/followups/` —
+ * the LIST route — and answered with the list's requirement, "agentId is
+ * required unless allAgents is set", naming two flags `show` does not have
+ * (OSK-9676). Refused at parse time instead, so it renders where a missing
+ * argument does, with usage, before any request is sent.
+ */
+export declare const followUpIdArg: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+export { FOLLOWUP_KINDS, FOLLOWUP_STATES, FOLLOWUP_RESOLVE_OUTCOMES, type FollowUpKind, } from '@skrr-ai/data-provider';
 export declare const WATCH_WAIT_KINDS: readonly ["clock", "event", "poll_until"];
 export interface FollowUpRow {
     id: string;
@@ -13,6 +20,8 @@ export interface FollowUpRow {
     form?: string | null;
     producer?: string;
     why?: string;
+    /** A reminder's own words. */
+    content?: string | null;
     intentKey?: string;
     subject?: {
         type?: string;
@@ -104,4 +113,3 @@ export declare const followupsApi: {
     reschedule: (id: string, body: Json) => Promise<Json>;
 };
 export declare function followupSummaryLine(row: FollowUpRow): string;
-export {};

package/dist/lib/followups.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.followupsApi = exports.WATCH_WAIT_KINDS = exports.FOLLOWUP_RESOLVE_OUTCOMES = exports.FOLLOWUP_STATES = exports.FOLLOWUP_KINDS = void 0;
+exports.followupsApi = exports.WATCH_WAIT_KINDS = exports.FOLLOWUP_RESOLVE_OUTCOMES = exports.FOLLOWUP_STATES = exports.FOLLOWUP_KINDS = exports.followUpIdArg = void 0;
 exports.resolveFollowUpAgent = resolveFollowUpAgent;
 exports.parseSubjectRef = parseSubjectRef;
 exports.followupSummaryLine = followupSummaryLine;
@@ -19,19 +19,44 @@ exports.followupSummaryLine = followupSummaryLine;
  * `why` and the server derives the rest; a second derivation here would be
  * exactly the drift the service exists to kill.
  */
+const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const runtime_context_1 = require("./runtime-context");
 const triggers_1 = require("./triggers");
 const agent_resolver_1 = require("./agent-resolver");
 const MOUNT = '/api/followups';
 const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
+/**
+ * The `id` argument every follow-up command that addresses one takes.
+ *
+ * oclif treats an empty string as a PRESENT required argument, so a scripted
+ * `skrr followups show "$ID"` with an empty variable built `/api/followups/` —
+ * the LIST route — and answered with the list's requirement, "agentId is
+ * required unless allAgents is set", naming two flags `show` does not have
+ * (OSK-9676). Refused at parse time instead, so it renders where a missing
+ * argument does, with usage, before any request is sent.
+ */
+exports.followUpIdArg = core_1.Args.string({
+    description: 'Follow-up (trigger) id',
+    required: true,
+    ignoreStdin: true,
+    parse: async (input) => {
+        const id = input.trim();
+        if (!id)
+            throw new Error('id is empty — pass the follow-up id (see `skrr followups list`)');
+        return id;
+    },
+});
 /* ------------------------------------------------------------------ *
  * Vocabulary (client-side validation only — the server is the authority) *
  * ------------------------------------------------------------------ */
-exports.FOLLOWUP_KINDS = ['reminder', 'watch', 'checkin', 'act'];
-exports.FOLLOWUP_STATES = ['armed', 'proposed', 'settled', 'paused'];
-/** Terminals a caller may name on `resolve` — the rest are the runtime's. */
-exports.FOLLOWUP_RESOLVE_OUTCOMES = ['resolved', 'abandoned'];
+// Owned by `@skrr-ai/data-provider`, which the server validates against. These
+// were declared a second time here, and the state list is where the two copies
+// disagreed.
+var data_provider_2 = require("@skrr-ai/data-provider");
+Object.defineProperty(exports, "FOLLOWUP_KINDS", { enumerable: true, get: function () { return data_provider_2.FOLLOWUP_KINDS; } });
+Object.defineProperty(exports, "FOLLOWUP_STATES", { enumerable: true, get: function () { return data_provider_2.FOLLOWUP_STATES; } });
+Object.defineProperty(exports, "FOLLOWUP_RESOLVE_OUTCOMES", { enumerable: true, get: function () { return data_provider_2.FOLLOWUP_RESOLVE_OUTCOMES; } });
 exports.WATCH_WAIT_KINDS = ['clock', 'event', 'poll_until'];
 /**
  * Which agent a follow-up belongs to.
@@ -65,7 +90,7 @@ function resolveFollowUpAgent(explicitAgentId, env = process.env) {
         return { id: explicitAgentId, boundToSession: false };
     throw new agent_resolver_1.AgentResolutionError({
         code: 'AGENT_CONTEXT_AMBIGUOUS',
-        message: 'No agent context: a follow-up needs an explicit agent and this session supplies none.',
+        message: 'No agent: this session is not bound to one, so name the agent these follow-ups are for.',
         suggestion: 'Pass `--agent <agent-id>`, run inside a daemon session that sets OVERSKY_SESSION_AGENT_ID, or use `--all-agents` where listing is the intent.',
         details: { runtimeKind: runtime.kind },
     });

package/dist/lib/harnesses.d.ts

@@ -42,6 +42,14 @@ export interface Harness {
     _id: string;
     provider: string;
     name?: string;
+    /**
+     * The name everyone else sees, when YOUR alias is covering it. `name` is the
+     * effective one. Present only while an alias is actually shadowing a
+     * different value, so a reader can tell "no alias" from "alias equals the
+     * shared name".
+     */
+    sharedName?: string;
+    aliased?: boolean;
     status?: string;
     harnessLocation?: 'local' | 'cloud';
     daemonId?: string;

package/dist/lib/instruction-input.d.ts

@@ -50,11 +50,29 @@ export declare function resolveBundleLabel(bundleId: string | undefined, names:
  * the daemon is genuinely gone. A remedy that 409s is worse than no remedy — it
  * spends the reader's attention and returns them to where they started.
  */
+/**
+ * A daemon id is `daemon_<hash>_<source>[_<profile>]`, where the hash covers
+ * the MACHINE and the cwd and `<source>` is the supervision mode
+ * (`cli`, `launchd`, `electron`, …). So two ids that differ only in that
+ * segment describe the SAME machine and directory, started a different way.
+ *
+ * That matters because switching how the daemon is started — the desktop app
+ * installs a launchd agent, `skrr daemon start` runs a cli one — mints a new
+ * id and orphans every managed-instruction target pinned to the old one.
+ */
+export declare function parseDaemonId(daemonId: string): {
+    place: string;
+    source: string;
+    profile: string;
+} | null;
+/** The live daemon that is this target's machine and directory, started differently. */
+export declare function sameMachineDaemon(targetDaemonId: string, liveDaemonIds: string[]): string | null;
 export declare function describeTargetSync(target: {
     status: string;
+    daemonId?: string;
     lastError?: string;
     lastSyncedAt?: string;
     lastAttemptedAt?: string;
     updatedAt?: string;
     driftCount?: number;
-}, now?: number): string;
+}, now?: number, liveDaemonIds?: string[]): string;

package/dist/lib/instruction-input.js

@@ -4,6 +4,8 @@ exports.readInstructionBody = readInstructionBody;
 exports.formatSyncStatus = formatSyncStatus;
 exports.buildBundleNameIndex = buildBundleNameIndex;
 exports.resolveBundleLabel = resolveBundleLabel;
+exports.parseDaemonId = parseDaemonId;
+exports.sameMachineDaemon = sameMachineDaemon;
 exports.describeTargetSync = describeTargetSync;
 const promises_1 = require("node:fs/promises");
 async function readStdin() {
@@ -93,7 +95,39 @@ const PENDING_IS_SUSPECT_AFTER_MS = 24 * 60 * 60 * 1000;
  * the daemon is genuinely gone. A remedy that 409s is worse than no remedy — it
  * spends the reader's attention and returns them to where they started.
  */
-function describeTargetSync(target, now = Date.now()) {
+/**
+ * A daemon id is `daemon_<hash>_<source>[_<profile>]`, where the hash covers
+ * the MACHINE and the cwd and `<source>` is the supervision mode
+ * (`cli`, `launchd`, `electron`, …). So two ids that differ only in that
+ * segment describe the SAME machine and directory, started a different way.
+ *
+ * That matters because switching how the daemon is started — the desktop app
+ * installs a launchd agent, `skrr daemon start` runs a cli one — mints a new
+ * id and orphans every managed-instruction target pinned to the old one.
+ */
+function parseDaemonId(daemonId) {
+    const parts = String(daemonId || '').split('_');
+    if (parts.length < 3 || parts[0] !== 'daemon')
+        return null;
+    return { place: parts[1], source: parts[2], profile: parts.slice(3).join('_') };
+}
+/** The live daemon that is this target's machine and directory, started differently. */
+function sameMachineDaemon(targetDaemonId, liveDaemonIds) {
+    const target = parseDaemonId(targetDaemonId);
+    if (!target)
+        return null;
+    for (const live of liveDaemonIds) {
+        if (live === targetDaemonId)
+            continue;
+        const other = parseDaemonId(live);
+        if (!other)
+            continue;
+        if (other.place === target.place && other.profile === target.profile)
+            return live;
+    }
+    return null;
+}
+function describeTargetSync(target, now = Date.now(), liveDaemonIds = []) {
     const base = formatSyncStatus(target.status, target.lastError);
     // Say when skrr has overwritten something you typed.
     //
@@ -131,5 +165,22 @@ function describeTargetSync(target, now = Date.now()) {
     // remedy off the end — the same truncation e51abf3362 exists to prevent. A
     // stalled target is not reconciling, so its drift is historical and the
     // remedy is the actionable half; the count reappears once it is unstuck.
+    // CHECK BEFORE ASSERTING, and never ship `--force` with a guess.
+    //
+    // "daemon may be gone" was stated unconditionally. On this machine it was
+    // false — the daemon had answered a heartbeat 112 ms earlier — because the
+    // target is pinned to `daemon_<hash>_launchd_default` while the live daemon
+    // is `daemon_<hash>_cli_default`: same machine, same directory, started a
+    // different way. So the CLI confidently recommended
+    // `remove, then purge-target --force` against live, correctly-installed
+    // managed blocks. An error that is confidently wrong AND carries its own
+    // `--force` is worse than one that says it does not know.
+    const elsewhere = sameMachineDaemon(target.daemonId || '', liveDaemonIds);
+    if (elsewhere) {
+        const live = parseDaemonId(elsewhere);
+        const pinned = parseDaemonId(target.daemonId || '');
+        // Kept under the STATUS column's `maxWidth: 78`, same constraint as below.
+        return `${base} — stalled ${days}d; daemon here now runs as ${live?.source}, not ${pinned?.source}: re-install`;
+    }
     return `${base} — stalled ${days}d; daemon may be gone: remove, then purge-target --force`;
 }

package/dist/lib/label-scope.d.ts

@@ -11,6 +11,21 @@
  */
 export declare const LABEL_SCOPES: readonly ["user", "workspace"];
 export type LabelScope = (typeof LABEL_SCOPES)[number];
+/**
+ * Scopes whose id the server cannot infer, so `--scope-id` must name it.
+ *
+ * `resolveLabelScope` below and the `--scope-id` help text are BOTH derived
+ * from this, rather than each restating the list. They drifted once already:
+ * `0298b7e4fd` collapsed the vocabulary from three scopes to two, and the help
+ * kept advertising `--scope space` for months after the validator had stopped
+ * accepting it — so following `--help` produced `Expected --scope=space to be
+ * one of: user, workspace`, whose last line points back at the help that was
+ * wrong. Static prose describing a value set is how that happens; deriving it
+ * is what stops the next collapse doing the same.
+ */
+export declare const LABEL_SCOPES_REQUIRING_ID: readonly ["workspace"];
+/** Scopes the server resolves from the caller — passing an id is an error. */
+export declare const LABEL_SCOPES_INFERRED: "user"[];
 export declare const LABEL_APPLICABLE: readonly ["task", "space", "goal", "routine"];
 export type LabelApplicable = (typeof LABEL_APPLICABLE)[number];
 /**

package/dist/lib/label-scope.js

@@ -11,12 +11,31 @@
  * id the server can infer (it falls back to the caller).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.labelScopeFlags = exports.HEX_COLOR_RE = exports.LABEL_APPLICABLE = exports.LABEL_SCOPES = void 0;
+exports.labelScopeFlags = exports.HEX_COLOR_RE = exports.LABEL_APPLICABLE = exports.LABEL_SCOPES_INFERRED = exports.LABEL_SCOPES_REQUIRING_ID = exports.LABEL_SCOPES = void 0;
 exports.normalizeLabelColor = normalizeLabelColor;
 exports.resolveLabelScope = resolveLabelScope;
 exports.resolveApplicableTo = resolveApplicableTo;
 const core_1 = require("@oclif/core");
 exports.LABEL_SCOPES = ['user', 'workspace'];
+/**
+ * Scopes whose id the server cannot infer, so `--scope-id` must name it.
+ *
+ * `resolveLabelScope` below and the `--scope-id` help text are BOTH derived
+ * from this, rather than each restating the list. They drifted once already:
+ * `0298b7e4fd` collapsed the vocabulary from three scopes to two, and the help
+ * kept advertising `--scope space` for months after the validator had stopped
+ * accepting it — so following `--help` produced `Expected --scope=space to be
+ * one of: user, workspace`, whose last line points back at the help that was
+ * wrong. Static prose describing a value set is how that happens; deriving it
+ * is what stops the next collapse doing the same.
+ */
+exports.LABEL_SCOPES_REQUIRING_ID = ['workspace'];
+const scopesRequiringId = () => exports.LABEL_SCOPES_REQUIRING_ID;
+/** Scopes the server resolves from the caller — passing an id is an error. */
+exports.LABEL_SCOPES_INFERRED = exports.LABEL_SCOPES.filter((scope) => !exports.LABEL_SCOPES_REQUIRING_ID.includes(scope));
+function joinScopes(scopes) {
+    return scopes.map((scope) => `--scope ${scope}`).join(' / ');
+}
 exports.LABEL_APPLICABLE = ['task', 'space', 'goal', 'routine'];
 /**
  * The server stores colors as bare 6-hex (`api/server/routes/labels.js` Zod is
@@ -34,7 +53,7 @@ exports.labelScopeFlags = {
         default: 'user',
     }),
     'scope-id': core_1.Flags.string({
-        description: 'Space or workspace ID — required for --scope space|workspace. Omit for --scope user (defaults to you).',
+        description: `Scope owner ID — required for ${joinScopes(scopesRequiringId())}. Omit for ${joinScopes(exports.LABEL_SCOPES_INFERRED)} (defaults to you).`,
     }),
 };
 /**
@@ -44,11 +63,12 @@ exports.labelScopeFlags = {
 function resolveLabelScope(flags) {
     const scope = (flags.scope ?? 'user');
     const scopeId = flags['scope-id'];
-    if (scope === 'workspace' && !scopeId) {
+    const requiresId = exports.LABEL_SCOPES_REQUIRING_ID.includes(scope);
+    if (requiresId && !scopeId) {
         throw new Error(`--scope-id is required for --scope ${scope}.`);
     }
-    if (scope === 'user' && scopeId) {
-        throw new Error('--scope-id is not accepted for --scope user; user-scope labels are always your own.');
+    if (!requiresId && scopeId) {
+        throw new Error(`--scope-id is not accepted for --scope ${scope}; ${scope}-scope labels are always your own.`);
     }
     return { scope, ...(scopeId ? { scopeId } : {}) };
 }

package/dist/lib/local-skills.d.ts

@@ -0,0 +1,98 @@
+import type { DaemonLocalSkill } from '@skrr-ai/data-provider';
+/**
+ * Skills on a machine, as its daemon lists them — the CLI half of the `/` menu.
+ *
+ * `skrr` had two things called "skill" and commands for only one: store and
+ * workspace skills (`skills *`, `--skill <skill-id>`) had a full surface, while
+ * the skills in a machine's `.claude/skills` and sibling roots — the ones the
+ * web `/` menu offers — could be neither listed nor invoked, so a headless
+ * operator or a locally-running coding agent could not use them at all
+ * (OSK-9478). `skills local` lists them; `agents chat --local-skill` invokes
+ * one. Both resolve through here, so a name means the same skill in each.
+ */
+export type ConnectedDaemon = {
+    daemonId: string;
+    deviceName?: string | null;
+};
+/**
+ * Which machine to ask, or why there is no single answer.
+ *
+ * Resolves rather than guesses: picking one of several machines and reporting
+ * its skills as "the" answer is the same silent narrowing the listing exists
+ * to remove.
+ */
+export declare function chooseDaemon(active: ReadonlyArray<ConnectedDaemon>): {
+    daemonId: string;
+} | {
+    problem: string;
+    candidates: ConnectedDaemon[];
+};
+/** A skill with no declared triggers is invocable both ways — the walker's default. */
+export declare function isUserInvocable(skill: Pick<DaemonLocalSkill, 'triggers'>): boolean;
+/**
+ * Turn requested names into the references the server resolves.
+ *
+ * A request is `name`, or `<root>/<name>` when the same name exists under more
+ * than one root (`.claude/skills/review` vs `.agents/skills/review`). Each
+ * problem is reported in words that say what to type instead; nothing is
+ * dropped, because the server's own rule is that a skill the user picked and
+ * the turn did not load must fail the turn rather than run without it.
+ */
+export declare function resolveLocalSkillRefs(inventory: ReadonlyArray<DaemonLocalSkill>, requested: ReadonlyArray<string>): {
+    refs: Array<{
+        name: string;
+        pathHash: string;
+    }>;
+    problems: string[];
+};
+/**
+ * The prompt with a `/name` for every invoked skill it does not already name.
+ *
+ * The web composer sends the `/name` in the text beside the reference, and
+ * drops a reference whose `/name` is gone; a CLI turn carries the same pair so
+ * the agent reads the same invocation either way.
+ */
+export declare function withSkillInvocations(prompt: string, refs: ReadonlyArray<{
+    name: string;
+}>): string;
+/** Whether a skill argument names a place on disk rather than a store id. */
+export declare function looksLikeSkillPath(arg: string): boolean;
+export type LocalSkillSighting = {
+    daemonId: string;
+    deviceName?: string | null;
+    source?: string;
+};
+/**
+ * Where a skill with this name exists on the caller's connected machines.
+ *
+ * Best-effort by design: it runs only to word an error that is already going
+ * to be reported, so a machine that cannot be asked contributes nothing rather
+ * than replacing the real error with a second one.
+ */
+export declare function findLocalSkillsNamed(name: string): Promise<LocalSkillSighting[]>;
+/**
+ * The error for a skill argument a STORE command could not use.
+ *
+ * `skills install <name>` and `skills details <name>` answered a local skill's
+ * name or path with "Skill not found / NOT_FOUND": true of the store, and no
+ * help to someone the product had just told it reads their `.claude/skills`
+ * (OSK-9412). The answer depends on what the argument was, so it says which:
+ * a path (never a store id), a name found on a connected machine (needs no
+ * install), or neither (look the id up in the store).
+ */
+export declare function describeStoreSkillMiss(arg: string, sightings: ReadonlyArray<LocalSkillSighting>, command: 'install' | 'details'): string;
+/**
+ * The first daemon release whose walker scans the skill conventions — the
+ * project's `.claude/skills`, `.agents/skills`, `.devin/skills`,
+ * `.windsurf/skills` and the global `~/.claude/skills`. It arrived in
+ * `e9dfa732cd` and first shipped in 0.8.44; an older daemon scans only
+ * `claudeSession.skillsDir`, which is empty unless someone set it by hand.
+ */
+export declare const SKILL_CONVENTION_DISCOVERY_SINCE = "0.8.44";
+/**
+ * Whether a daemon's reported version is older than `floor`.
+ *
+ * Unknown or unparseable versions answer false: this decides only whether to
+ * add an explanation, and claiming an unknown daemon is old would be a guess.
+ */
+export declare function daemonPredates(version: string | null | undefined, floor: string): boolean;