@skrr-ai/cli 0.1.8

package/dist/lib/update-check.d.ts

@@ -0,0 +1,31 @@
+/** Trailing-slash- and case-insensitive normalization for baseURL compares. */
+export declare function normalizeBaseUrl(url: string): string;
+/**
+ * True when the advisory must stay silent regardless of version state:
+ * explicit suppression, or a desktop-app-bundled CLI (which auto-updates
+ * with the app and must not be told to `npm update -g`).
+ */
+export declare function isNudgeSuppressed(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * True iff `current` is strictly older than `latest` by numeric release
+ * core. Conservative: any unparseable input returns false (no nudge).
+ * Prerelease suffixes are ignored, so `0.2.0-rc.1` is treated as `0.2.0` —
+ * we never nag someone testing a prerelease of the latest line.
+ */
+export declare function isOlderVersion(current: string, latest: string): boolean;
+/**
+ * Build the one-line stderr advisory, or null when no nudge is warranted.
+ * Exported for direct unit testing without touching disk or the network.
+ */
+export declare function buildNudgeLine(currentVersion: string, latest: string | null, npmPackage: string | null): string | null;
+/**
+ * Entry point, called once per command from `BaseCommand.init()`.
+ *
+ * Synchronous by design: it decides the nudge from the cache (no network
+ * on the hot path) and only kicks off a background refresh when the cache
+ * is stale, missing, or from a different server. Returns immediately.
+ */
+export declare function maybeWarnOutdatedCli(opts: {
+    currentVersion: string;
+    baseURL: string;
+}): void;

package/dist/lib/update-check.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBaseUrl = normalizeBaseUrl;
+exports.isNudgeSuppressed = isNudgeSuppressed;
+exports.isOlderVersion = isOlderVersion;
+exports.buildNudgeLine = buildNudgeLine;
+exports.maybeWarnOutdatedCli = maybeWarnOutdatedCli;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+/**
+ * update-check.ts — non-blocking "a newer `skrr` is available" advisory.
+ *
+ * The standalone `skrr` CLI (npm `@skrr-ai/cli`) has no self-update path,
+ * so a user who installed it via npm has no signal that they are behind.
+ * This module is the CLI-side analog of the daemon's server-driven
+ * `daemon:update-available` advisory: on every command it decides — from a
+ * ~4h on-disk cache, with ZERO added latency — whether to print a single
+ * line to stderr, and refreshes that cache in the background.
+ *
+ * Hard guarantees (a version advisory must never make the CLI worse):
+ *   - Writes ONLY to stderr, never stdout, so `--json` output stays clean.
+ *   - Prints at most ONE line, and only on an interactive TTY (scripts /
+ *     CI / pipes never see it).
+ *   - Never blocks the command: the nudge decision is synchronous off the
+ *     cache; the network refresh is fire-and-forget and time-bounded.
+ *   - Never throws: every path is wrapped so a malformed cache, offline
+ *     API, or read-only home directory can't break a command.
+ *   - Suppressible: `OVERSKY_NO_UPDATE_NUDGE` / `OVERSKY_SKIP_UPDATE_CHECK`
+ *     silence it; `OVERSKY_CLI_BUNDLED=1` (set by the desktop app's `skrr`
+ *     wrapper) suppresses it entirely — bundled installs auto-update with
+ *     the app, so an "npm update -g" nudge would be actively wrong there.
+ */
+/** How long a cached advisory stays fresh before a background refresh. */
+const CHECK_TTL_MS = 4 * 60 * 60 * 1000; // 4h
+/** Hard ceiling on the background refresh request. */
+const FETCH_TIMEOUT_MS = 1500;
+function cacheFilePath() {
+    return path.join(os.homedir(), '.skrr', 'cli-update-check.json');
+}
+/** Trailing-slash- and case-insensitive normalization for baseURL compares. */
+function normalizeBaseUrl(url) {
+    return url.trim().replace(/\/+$/, '').toLowerCase();
+}
+function isTruthyEnv(value) {
+    if (!value)
+        return false;
+    return ['1', 'true', 'on', 'yes'].includes(value.trim().toLowerCase());
+}
+/**
+ * True when the advisory must stay silent regardless of version state:
+ * explicit suppression, or a desktop-app-bundled CLI (which auto-updates
+ * with the app and must not be told to `npm update -g`).
+ */
+function isNudgeSuppressed(env = process.env) {
+    return (isTruthyEnv(env.OVERSKY_NO_UPDATE_NUDGE) ||
+        isTruthyEnv(env.OVERSKY_SKIP_UPDATE_CHECK) ||
+        env.OVERSKY_CLI_BUNDLED === '1');
+}
+/**
+ * Parse the numeric release core of a version (`1.2.3-rc.1` → `[1,2,3]`),
+ * padded to three parts. Returns null when the core isn't cleanly numeric,
+ * so an unparseable version can only ever DISABLE the nudge, never fire a
+ * spurious one.
+ */
+function parseVersionCore(version) {
+    const core = version.trim().split(/[-+]/, 1)[0];
+    const parts = core.split('.');
+    if (parts.length === 0 || parts.length > 3)
+        return null;
+    const nums = [];
+    for (const part of parts) {
+        if (!/^\d+$/.test(part))
+            return null;
+        nums.push(Number(part));
+    }
+    while (nums.length < 3)
+        nums.push(0);
+    return [nums[0], nums[1], nums[2]];
+}
+/**
+ * True iff `current` is strictly older than `latest` by numeric release
+ * core. Conservative: any unparseable input returns false (no nudge).
+ * Prerelease suffixes are ignored, so `0.2.0-rc.1` is treated as `0.2.0` —
+ * we never nag someone testing a prerelease of the latest line.
+ */
+function isOlderVersion(current, latest) {
+    const a = parseVersionCore(current);
+    const b = parseVersionCore(latest);
+    if (!a || !b)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a[i] < b[i])
+            return true;
+        if (a[i] > b[i])
+            return false;
+    }
+    return false;
+}
+/**
+ * Build the one-line stderr advisory, or null when no nudge is warranted.
+ * Exported for direct unit testing without touching disk or the network.
+ */
+function buildNudgeLine(currentVersion, latest, npmPackage) {
+    if (!latest || !isOlderVersion(currentVersion, latest))
+        return null;
+    const pkg = npmPackage || '@skrr-ai/cli';
+    return (`[sky] Update available: ${currentVersion} → ${latest}. ` +
+        `Run \`npm update -g ${pkg}\` (or update the skrr app). ` +
+        `Silence with OVERSKY_NO_UPDATE_NUDGE=1.\n`);
+}
+function readCache() {
+    try {
+        const raw = fs.readFileSync(cacheFilePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.lastCheckAt === 'number' && typeof parsed.baseURL === 'string') {
+            return {
+                lastCheckAt: parsed.lastCheckAt,
+                latest: typeof parsed.latest === 'string' ? parsed.latest : null,
+                npmPackage: typeof parsed.npmPackage === 'string' ? parsed.npmPackage : null,
+                baseURL: parsed.baseURL,
+            };
+        }
+    }
+    catch {
+        // Missing / corrupt cache → treat as absent; a refresh rebuilds it.
+    }
+    return null;
+}
+function writeCache(cache) {
+    try {
+        const file = cacheFilePath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const tmp = `${file}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(cache), { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // Best-effort — a read-only home just means we re-check next run.
+    }
+}
+async function refreshCache(baseURL) {
+    try {
+        const url = `${baseURL.replace(/\/+$/, '')}/api/config/cli-version`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            headers: { accept: 'application/json' },
+        });
+        if (!res.ok)
+            return;
+        const body = (await res.json());
+        writeCache({
+            lastCheckAt: Date.now(),
+            latest: typeof body.latest === 'string' ? body.latest : null,
+            npmPackage: typeof body.npmPackage === 'string' ? body.npmPackage : null,
+            baseURL: normalizeBaseUrl(baseURL),
+        });
+    }
+    catch {
+        // Offline / timeout / bad payload — leave the old cache, retry later.
+    }
+}
+/**
+ * Entry point, called once per command from `BaseCommand.init()`.
+ *
+ * Synchronous by design: it decides the nudge from the cache (no network
+ * on the hot path) and only kicks off a background refresh when the cache
+ * is stale, missing, or from a different server. Returns immediately.
+ */
+function maybeWarnOutdatedCli(opts) {
+    try {
+        if (isNudgeSuppressed())
+            return;
+        // Scripts, pipes, and CI never get the advisory — matches npm/oclif
+        // convention and keeps `sky ... | jq` and captured stderr clean.
+        if (!process.stderr.isTTY)
+            return;
+        const normalized = normalizeBaseUrl(opts.baseURL);
+        const cache = readCache();
+        // Decide from whatever we last saw. A STALE cache is still a valid
+        // signal — CLI versions only move forward — so we nudge off it and
+        // refresh in the background for next time. We only trust a cache that
+        // was fetched against the same server the CLI is currently pointed at.
+        if (cache && cache.baseURL === normalized) {
+            const line = buildNudgeLine(opts.currentVersion, cache.latest, cache.npmPackage);
+            if (line)
+                process.stderr.write(line);
+        }
+        const stale = !cache || cache.baseURL !== normalized || Date.now() - cache.lastCheckAt > CHECK_TTL_MS;
+        if (stale) {
+            // Fire-and-forget. Not awaited, so it adds no latency; if the command
+            // exits before it resolves the refresh is simply dropped and retried
+            // on the next invocation.
+            void refreshCache(opts.baseURL);
+        }
+    }
+    catch {
+        // A version advisory must never break a command.
+    }
+}

package/dist/lib/usage-discovery.d.ts

@@ -0,0 +1,75 @@
+import type { CommandManifest } from './command-manifest';
+/**
+ * `skrr commands --json` is intentionally exhaustive. That makes it the right
+ * source of truth, but a bad first read for an agent: loading several hundred
+ * command schemas to answer one task burns context before it has selected a
+ * domain. These smaller views are derived from that same manifest; there is no
+ * second, hand-maintained command catalogue to drift from the binary.
+ */
+export declare const USAGE_OVERVIEW_TOKEN_BUDGET = 200;
+export declare const USAGE_DOMAIN_TOKEN_BUDGET = 500;
+export type UsageCommand = {
+    command: string;
+    description: string;
+    keyFlags: string[];
+    example: string;
+};
+export type UsageDomain = {
+    domain: string;
+    commandCount: number;
+    usage: string;
+};
+export type UsageOverview = {
+    object: 'sky_usage_overview';
+    generatedFrom: 'oclif.manifest.json';
+    tokenBudget: number;
+    estimatedTokens: number;
+    domains: UsageDomain[];
+};
+export type UsageReference = {
+    object: 'sky_usage_reference';
+    generatedFrom: 'oclif.manifest.json';
+    domain: string;
+    tokenBudget: number;
+    estimatedTokens: number;
+    page: number;
+    pages: number;
+    commandCount: number;
+    data: UsageCommand[];
+    nextPage?: number;
+};
+/**
+ * A dependency-free approximation suitable for an output guardrail. Four
+ * characters per token tracks ordinary English and command references closely
+ * enough to prevent an accidental context dump without pretending to be any
+ * particular model's tokenizer.
+ */
+export declare function estimateUsageTokens(value: string): number;
+export declare function usageDomains(manifest: CommandManifest, bin?: string): UsageDomain[];
+export declare function buildUsageOverview(manifest: CommandManifest, bin?: string): UsageOverview;
+/** Return case-insensitive manifest domain names without inventing aliases. */
+export declare function resolveUsageDomain(manifest: CommandManifest, value: string): string | undefined;
+/**
+ * Render one bounded page of a domain. A page is chosen greedily from its own
+ * generated text, so a newly-added long command description never pushes the
+ * user across the token budget. `page` is one-based for shell ergonomics.
+ */
+export declare function buildUsageReference(manifest: CommandManifest, domainInput: string, options?: {
+    bin?: string;
+    page?: number;
+}): UsageReference | undefined;
+export declare function renderUsageOverview(overview: UsageOverview): string;
+export declare function renderUsageReference(reference: UsageReference, bin?: string): string;
+export type UsageBudgetIssue = {
+    scope: 'overview' | 'domain';
+    domain?: string;
+    page?: number;
+    estimatedTokens: number;
+    tokenBudget: number;
+};
+/**
+ * Kept separate from the CLI command so `skrr commands --audit` can prove the
+ * same invariant CI checks. Iterate every page, rather than only page one:
+ * progressive discovery is only budgeted if its continuation is too.
+ */
+export declare function auditUsageBudgets(manifest: CommandManifest, bin?: string): UsageBudgetIssue[];

package/dist/lib/usage-discovery.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USAGE_DOMAIN_TOKEN_BUDGET = exports.USAGE_OVERVIEW_TOKEN_BUDGET = void 0;
+exports.estimateUsageTokens = estimateUsageTokens;
+exports.usageDomains = usageDomains;
+exports.buildUsageOverview = buildUsageOverview;
+exports.resolveUsageDomain = resolveUsageDomain;
+exports.buildUsageReference = buildUsageReference;
+exports.renderUsageOverview = renderUsageOverview;
+exports.renderUsageReference = renderUsageReference;
+exports.auditUsageBudgets = auditUsageBudgets;
+const command_manifest_1 = require("./command-manifest");
+/**
+ * `skrr commands --json` is intentionally exhaustive. That makes it the right
+ * source of truth, but a bad first read for an agent: loading several hundred
+ * command schemas to answer one task burns context before it has selected a
+ * domain. These smaller views are derived from that same manifest; there is no
+ * second, hand-maintained command catalogue to drift from the binary.
+ */
+exports.USAGE_OVERVIEW_TOKEN_BUDGET = 200;
+exports.USAGE_DOMAIN_TOKEN_BUDGET = 500;
+const GENERIC_FLAGS = new Set(['bare', 'help', 'json', 'token', 'workspace']);
+/**
+ * A dependency-free approximation suitable for an output guardrail. Four
+ * characters per token tracks ordinary English and command references closely
+ * enough to prevent an accidental context dump without pretending to be any
+ * particular model's tokenizer.
+ */
+function estimateUsageTokens(value) {
+    return Math.ceil(value.length / 4);
+}
+function usageDomains(manifest, bin = 'skrr') {
+    const grouped = groupEntries(manifest);
+    return [...grouped.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([domain, entries]) => ({
+        domain,
+        commandCount: entries.length,
+        usage: `${bin} usage ${domain}`,
+    }));
+}
+function buildUsageOverview(manifest, bin = 'skrr') {
+    const domains = usageDomains(manifest, bin);
+    const text = renderUsageOverview({
+        object: 'sky_usage_overview',
+        generatedFrom: 'oclif.manifest.json',
+        tokenBudget: exports.USAGE_OVERVIEW_TOKEN_BUDGET,
+        estimatedTokens: 0,
+        domains,
+    });
+    return {
+        object: 'sky_usage_overview',
+        generatedFrom: 'oclif.manifest.json',
+        tokenBudget: exports.USAGE_OVERVIEW_TOKEN_BUDGET,
+        estimatedTokens: estimateUsageTokens(text),
+        domains,
+    };
+}
+/** Return case-insensitive manifest domain names without inventing aliases. */
+function resolveUsageDomain(manifest, value) {
+    const needle = value.trim().toLowerCase();
+    return usageDomains(manifest).find(({ domain }) => domain.toLowerCase() === needle)?.domain;
+}
+/**
+ * Render one bounded page of a domain. A page is chosen greedily from its own
+ * generated text, so a newly-added long command description never pushes the
+ * user across the token budget. `page` is one-based for shell ergonomics.
+ */
+function buildUsageReference(manifest, domainInput, options = {}) {
+    const domain = resolveUsageDomain(manifest, domainInput);
+    if (!domain)
+        return undefined;
+    const bin = options.bin ?? 'skrr';
+    const entries = groupEntries(manifest).get(domain) ?? [];
+    const commands = entries.map((entry) => usageCommand(entry, bin));
+    const pages = paginate(commands, domain, bin);
+    const requested = options.page ?? 1;
+    const index = requested - 1;
+    if (!Number.isInteger(requested) || index < 0 || index >= pages.length)
+        return undefined;
+    const data = pages[index];
+    const draft = {
+        object: 'sky_usage_reference',
+        generatedFrom: 'oclif.manifest.json',
+        domain,
+        tokenBudget: exports.USAGE_DOMAIN_TOKEN_BUDGET,
+        estimatedTokens: 0,
+        page: requested,
+        pages: pages.length,
+        commandCount: commands.length,
+        data,
+        ...(index + 1 < pages.length ? { nextPage: requested + 1 } : {}),
+    };
+    return { ...draft, estimatedTokens: estimateUsageTokens(renderUsageReference(draft, bin)) };
+}
+function renderUsageOverview(overview) {
+    const lines = [
+        `Sky command domains (${overview.domains.length}; manifest-derived).`,
+        'Read one domain at a time: skrr usage <domain>.',
+        ...overview.domains.map(({ domain }) => domain),
+    ];
+    return lines.join('\n');
+}
+function renderUsageReference(reference, bin = 'skrr') {
+    const lines = [
+        `${reference.domain} commands — page ${reference.page}/${reference.pages} ` +
+            `(${reference.commandCount} total; manifest-derived).`,
+    ];
+    for (const command of reference.data) {
+        const flags = command.keyFlags.length > 0 ? ` Flags: ${command.keyFlags.join(', ')}.` : '';
+        lines.push(`sky ${command.command} — ${command.description}.${flags} Example: ${command.example}`);
+    }
+    if (reference.nextPage)
+        lines.push(`Next: ${bin} usage ${reference.domain} --page ${reference.nextPage}`);
+    return lines.join('\n');
+}
+/**
+ * Kept separate from the CLI command so `skrr commands --audit` can prove the
+ * same invariant CI checks. Iterate every page, rather than only page one:
+ * progressive discovery is only budgeted if its continuation is too.
+ */
+function auditUsageBudgets(manifest, bin = 'skrr') {
+    const issues = [];
+    const overview = buildUsageOverview(manifest, bin);
+    if (overview.estimatedTokens > overview.tokenBudget) {
+        issues.push({
+            scope: 'overview',
+            estimatedTokens: overview.estimatedTokens,
+            tokenBudget: overview.tokenBudget,
+        });
+    }
+    for (const { domain } of usageDomains(manifest, bin)) {
+        const first = buildUsageReference(manifest, domain, { bin, page: 1 });
+        if (!first)
+            continue;
+        for (let page = 1; page <= first.pages; page += 1) {
+            const reference = page === 1 ? first : buildUsageReference(manifest, domain, { bin, page });
+            if (reference && reference.estimatedTokens > reference.tokenBudget) {
+                issues.push({
+                    scope: 'domain',
+                    domain,
+                    page,
+                    estimatedTokens: reference.estimatedTokens,
+                    tokenBudget: reference.tokenBudget,
+                });
+            }
+        }
+    }
+    return issues;
+}
+function groupEntries(manifest) {
+    const grouped = new Map();
+    for (const entry of (0, command_manifest_1.visibleCommandEntries)(manifest)) {
+        const domain = entry.id.split(':')[0];
+        const existing = grouped.get(domain) ?? [];
+        existing.push(entry);
+        grouped.set(domain, existing);
+    }
+    return grouped;
+}
+function usageCommand(entry, bin) {
+    const flags = Object.entries(entry.flags)
+        .filter(([, value]) => !value.hidden)
+        .map(([name, value]) => ({
+        name: `--${name}`,
+        required: Boolean(value.required),
+        generic: GENERIC_FLAGS.has(name),
+    }))
+        .sort((a, b) => Number(b.required) - Number(a.required) ||
+        Number(a.generic) - Number(b.generic) ||
+        a.name.localeCompare(b.name))
+        .slice(0, 3)
+        .map(({ name }) => name);
+    const command = entry.command;
+    return {
+        command,
+        description: compact(entry.description, 120) || 'Run this command',
+        keyFlags: flags,
+        example: exampleFor(entry, bin),
+    };
+}
+function exampleFor(entry, bin) {
+    const raw = entry.examples[0]
+        ?.replace(/<%=\s*config\.bin\s*%>/g, bin)
+        .split('#')[0]
+        .trim();
+    return compact(raw || `${bin} ${entry.command}`, 96);
+}
+function compact(value, maxCharacters) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxCharacters)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxCharacters - 1)).trimEnd()}…`;
+}
+function paginate(commands, domain, bin) {
+    const pages = [];
+    let page = [];
+    for (const command of commands) {
+        const candidate = [...page, command];
+        // Use a deliberately high page count while measuring. The final header is
+        // never longer than this placeholder, so if it fits here it fits once the
+        // actual page count is known too.
+        const preview = {
+            object: 'sky_usage_reference',
+            generatedFrom: 'oclif.manifest.json',
+            domain,
+            tokenBudget: exports.USAGE_DOMAIN_TOKEN_BUDGET,
+            estimatedTokens: 0,
+            page: 999,
+            pages: 999,
+            commandCount: commands.length,
+            data: candidate,
+            nextPage: 999,
+        };
+        if (page.length > 0 &&
+            estimateUsageTokens(renderUsageReference(preview, bin)) > exports.USAGE_DOMAIN_TOKEN_BUDGET) {
+            pages.push(page);
+            page = [command];
+        }
+        else {
+            page = candidate;
+        }
+    }
+    if (page.length > 0)
+        pages.push(page);
+    return pages;
+}

package/dist/lib/view-subscriptions.d.ts

@@ -0,0 +1,32 @@
+import { dataService, type EntitySubscription } from '@skrr-ai/data-provider';
+export declare const VIEW_SUBSCRIPTION_CHANNELS: readonly ["inApp", "slack_channel", "discord_channel"];
+export type ViewSubscriptionChannel = (typeof VIEW_SUBSCRIPTION_CHANNELS)[number];
+export declare function deliveryTargets(flags: {
+    'slack-channel'?: string;
+    'discord-channel'?: string;
+    agent?: string;
+}): {
+    discord?: {
+        channelId: string;
+        agentId: string;
+    } | undefined;
+    slack?: {
+        channelId: string;
+        agentId: string;
+    } | undefined;
+};
+export declare function subscribeToView(input: {
+    entityType: 'task_view' | 'space_view';
+    entityId: string;
+    channels?: readonly string[];
+    targets: ReturnType<typeof deliveryTargets>;
+}): Promise<{
+    subscription: EntitySubscription;
+}>;
+export declare function subscriptionsForView(entityType: 'task_view' | 'space_view', entityId: string): Promise<dataService.EntitySubscription[]>;
+export declare function unsubscribeFromView(entityType: 'task_view' | 'space_view', entityId: string): Promise<{
+    subscription: EntitySubscription;
+} | {
+    unsubscribed: boolean;
+}>;
+export declare function describeSubscriptionTargets(subscription: EntitySubscription): string;

package/dist/lib/view-subscriptions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIEW_SUBSCRIPTION_CHANNELS = void 0;
+exports.deliveryTargets = deliveryTargets;
+exports.subscribeToView = subscribeToView;
+exports.subscriptionsForView = subscriptionsForView;
+exports.unsubscribeFromView = unsubscribeFromView;
+exports.describeSubscriptionTargets = describeSubscriptionTargets;
+const data_provider_1 = require("@skrr-ai/data-provider");
+exports.VIEW_SUBSCRIPTION_CHANNELS = ['inApp', 'slack_channel', 'discord_channel'];
+function deliveryTargets(flags) {
+    const agentId = flags.agent?.trim();
+    const slack = flags['slack-channel']?.trim();
+    const discord = flags['discord-channel']?.trim();
+    if ((slack || discord) && !agentId) {
+        throw new Error('--agent is required with --slack-channel or --discord-channel.');
+    }
+    return {
+        ...(slack ? { slack: { channelId: slack, agentId: agentId } } : {}),
+        ...(discord ? { discord: { channelId: discord, agentId: agentId } } : {}),
+    };
+}
+async function subscribeToView(input) {
+    const selected = input.channels?.length ? [...input.channels] : ['inApp'];
+    if (!selected.every((channel) => exports.VIEW_SUBSCRIPTION_CHANNELS.includes(channel))) {
+        throw new Error(`Unsupported view subscription channel. Use: ${exports.VIEW_SUBSCRIPTION_CHANNELS.join(', ')}.`);
+    }
+    const channels = selected;
+    if (channels.includes('slack_channel') && !input.targets.slack) {
+        throw new Error('--slack-channel is required when --channel slack_channel is selected.');
+    }
+    if (channels.includes('discord_channel') && !input.targets.discord) {
+        throw new Error('--discord-channel is required when --channel discord_channel is selected.');
+    }
+    return data_provider_1.dataService.createEntitySubscription({
+        subscriberType: 'user',
+        entityType: input.entityType,
+        entityId: input.entityId,
+        channels,
+        eventTypes: ['task.view_added', 'task.view_completed', 'task.view_cancelled'],
+        ...(Object.keys(input.targets).length ? { deliveryTargets: input.targets } : {}),
+    });
+}
+async function subscriptionsForView(entityType, entityId) {
+    const response = await data_provider_1.dataService.listEntitySubscriptions({ entityType });
+    return response.items.filter((item) => item.entityId === entityId);
+}
+async function unsubscribeFromView(entityType, entityId) {
+    const matches = await subscriptionsForView(entityType, entityId);
+    const own = matches.find((item) => item.subscriberType === 'user');
+    return own?.id ? data_provider_1.dataService.archiveEntitySubscription(own.id) : { unsubscribed: false };
+}
+function describeSubscriptionTargets(subscription) {
+    const targets = subscription.metadata?.viewSubscription?.deliveryTargets;
+    const parts = [...(subscription.channels || [])];
+    if (targets?.slack?.channelId)
+        parts.push(`slack:${targets.slack.channelId}`);
+    if (targets?.discord?.channelId)
+        parts.push(`discord:${targets.discord.channelId}`);
+    return parts.join(', ');
+}

package/dist/lib/views/vocabulary.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI parity re-export for persisted task views.
+ *
+ * Keep command flag choices anchored to data-provider. This file is purposely
+ * a re-export, not a second CLI vocabulary: adding a saved-view capability is
+ * one data-provider registration followed by renderer work on each surface.
+ */
+export { SPACE_RENDERABLE_VIEW_TYPES, TASK_RENDERABLE_VIEW_TYPES, VIEW_GROUP_BY_REGISTRY, VIEW_GROUP_BY_VALUES, VIEW_QUICK_FILTER_REGISTRY, VIEW_QUICK_FILTERS, VIEW_SORT_DIRECTIONS, VIEW_SORT_KEY_REGISTRY, VIEW_SORT_KEYS, VIEW_TYPE_REGISTRY, VIEW_TYPES, viewTypesForSurface, } from '@skrr-ai/data-provider';