@wirecat/cli-core 0.406.0 → 0.408.0

package/dist/mcp/surface.js

@@ -57,7 +57,7 @@ const runnableOnly = (result, offered) => {
 /**
  * **Three tools in place of one per command** (CLI-74, NEED-766): search the commands, then run one
  * with `read` or `write`. A command keeps its CLI path and its arguments, and runs as its own tool
- * did. The list never changes during a connection; what a profile may not use is not in `commands`.
+ * did. The catalogue stays discoverable; current permissions annotate availability and are checked before execution.
  */
 export const registerCommands = (server, prefix, commands, errors, 
 /** Throws the refusal of a command left out because the lock or a level stops it, so the agent learns why. */
@@ -79,10 +79,16 @@ withheld) => {
                 title: one.title,
                 description: one.description,
                 writes: one.writes,
+                availability: one.availability?.() ?? { available: true },
                 arguments: toJsonSchema(one.input),
                 output: toJsonSchema(one.output ?? ANSWER),
             }))
-            : found.map(([command, one]) => ({ command, title: one.title, writes: one.writes }));
+            : found.map(([command, one]) => ({
+                command,
+                title: one.title,
+                writes: one.writes,
+                availability: one.availability?.() ?? { available: true },
+            }));
         // The tool takes no page: more matches mean narrower words, so the list carries no page.next to rerun.
         const { next: _paging, ...list } = listOf(`${prefix}_tools_search`, {
             items,

package/dist/meetings/cli/index.js

@@ -73,7 +73,7 @@ export const addMeetingCommands = (program, deps) => {
         .argument("<meeting>", "stored meeting id", integer)).action(async (id, _opts, command) => {
         print(await meetingSummaryAnswer(deps.store, id, deps.accountId), command);
     });
-    output(annotate(group.command("export"), { effects: LOCAL_WRITE })
+    output(annotate(group.command("export"), { effects: LOCAL_WRITE, output: { entity: "meeting_export" } })
         .description("export a meeting as Markdown or one transcript as WebVTT")
         .argument("<meeting>", "stored meeting id", integer)
         .addOption(new Option("--format <format>", "export format").choices(["markdown", "vtt"]).default("markdown"))
@@ -110,7 +110,11 @@ export const addMeetingCommands = (program, deps) => {
             cursor: opts.cursor,
         }), command);
     });
-    output(annotate(group.command("sync"), { effects: FETCH, offline: false }).description("bring the stored meetings up to date from the connected account"))
+    output(annotate(group.command("sync"), {
+        effects: FETCH,
+        offline: false,
+        output: { entity: "meeting_ingestion" },
+    }).description("bring the stored meetings up to date from the connected account"))
         .option("--since-time <time>", "fetch meetings starting at or after this ISO 8601 date or time", date)
         .option("--lookback-days <days>", "revisit recent occurrences for late transcripts (0–31)", lookbackDays, 0)
         .action(async (opts, command) => {
@@ -123,7 +127,10 @@ export const addMeetingCommands = (program, deps) => {
             lookbackMs: opts.lookbackDays * 86400000,
         }), command);
     });
-    const importCommand = annotate(group.command("import"), { effects: LOCAL_WRITE })
+    const importCommand = annotate(group.command("import"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "meeting_ingestion" },
+    })
         .description("import downloaded meeting transcripts")
         .argument("<folder>", "folder of transcripts downloaded from the provider");
     if (deps.importHelp)

package/dist/meetings/index.d.ts

@@ -34,6 +34,7 @@ export { parseRecordingSyncCheckpoint, type RecordingSyncCheckpoint, type Record
 export { type RecordingPartial, RecordingTransferError, type RecordingTransferResponse, type RecordingTransferSource, type RecordingTransferStorage, type RecordingTransferWriter, strongRecordingValidator, transferRecording, } from "./recording-transfer.js";
 export { canonicalMeetingReference, formatMeetingReference, type MeetingReference, parseMeetingReference, } from "./reference.js";
 export { type MeetingRelatedHistoryEntry, type MeetingRelatedHistoryRequest, type MeetingRelatedHistoryStore, validateMeetingRelatedHistory, } from "./related-history.js";
+export { MEETING_RESULT_ENTITIES } from "./result-items.js";
 export { type MeetingReview, type MeetingReviewInput, type MeetingReviewItem, type MeetingReviewSpeaker, type MeetingReviewStore, REVIEW_LIMIT, } from "./review.js";
 export { SAVE_HELP, SAVE_INSTRUCTION } from "./save-hints.js";
 export type { MeetingHitSearchRequest, MeetingSearchIndexInput, MeetingSearchIndexReceipt, MeetingSearchIndexStore, MeetingSearchOptions, MeetingSearchPage, MeetingSearchStore, } from "./search-store.js";

package/dist/meetings/index.js

@@ -25,6 +25,7 @@ export { parseRecordingSyncCheckpoint, RecordingSyncError, recordingAssetFingerp
 export { RecordingTransferError, strongRecordingValidator, transferRecording, } from "./recording-transfer.js";
 export { canonicalMeetingReference, formatMeetingReference, parseMeetingReference, } from "./reference.js";
 export { validateMeetingRelatedHistory, } from "./related-history.js";
+export { MEETING_RESULT_ENTITIES } from "./result-items.js";
 export { REVIEW_LIMIT, } from "./review.js";
 export { SAVE_HELP, SAVE_INSTRUCTION } from "./save-hints.js";
 export { validateMeetingHitSearch } from "./search-validation.js";

package/dist/meetings/result-items.d.ts

@@ -0,0 +1,127 @@
+import * as v from "valibot";
+export declare const MEETING_RESULT_ENTITIES: {
+    readonly meeting_ingestion: v.StrictObjectSchema<{
+        readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly participants: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly transcript_rows: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly summaries: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly warnings: v.ArraySchema<v.StrictObjectSchema<{
+            readonly external_id: v.StringSchema<undefined>;
+            readonly message: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly timezone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly meeting_export: v.UnionSchema<[v.StrictObjectSchema<{
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly format: v.PicklistSchema<["markdown", "vtt"], undefined>;
+        readonly filename: v.StringSchema<undefined>;
+        readonly content: v.StringSchema<undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly format: v.PicklistSchema<["markdown", "vtt"], undefined>;
+        readonly output: v.StringSchema<undefined>;
+    }, undefined>], undefined>;
+    readonly meeting_association: v.StrictObjectSchema<{
+        readonly scope: v.StrictObjectSchema<{
+            readonly provider: v.StringSchema<undefined>;
+            readonly account: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly change: v.UnionSchema<[v.StrictObjectSchema<{
+            readonly action: v.LiteralSchema<"event.link", undefined>;
+            readonly event_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly expected_event_id: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly action: v.LiteralSchema<"person.link", undefined>;
+            readonly participant_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly person_uid: v.StringSchema<undefined>;
+            readonly expected_person_uid: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly target_account_ids: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, undefined>;
+        }, undefined>], undefined>;
+        readonly applied: v.BooleanSchema<undefined>;
+        readonly result: v.OptionalSchema<v.UnionSchema<[v.StrictObjectSchema<{
+            readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly event_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly previous_event_id: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+            readonly changed: v.BooleanSchema<undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly participant_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly person_uid: v.StringSchema<undefined>;
+            readonly previous_person_uid: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly changed: v.BooleanSchema<undefined>;
+        }, undefined>], undefined>, undefined>;
+    }, undefined>;
+    readonly meeting_transcription: v.UnionSchema<[v.StrictObjectSchema<{
+        readonly applied: v.LiteralSchema<false, undefined>;
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly external_id: v.StringSchema<undefined>;
+        readonly segments: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly media: v.StrictObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly content_hash: v.StringSchema<undefined>;
+            readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly duration_ms: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly format: v.StringSchema<undefined>;
+            readonly sample_rate: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly channels: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly recognition: v.StrictObjectSchema<{
+                readonly engine: v.StringSchema<undefined>;
+                readonly model: v.StringSchema<undefined>;
+                readonly version: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly timing: v.OptionalSchema<v.PicklistSchema<["fixed-windows", "recognition-segments"], undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly applied: v.LiteralSchema<true, undefined>;
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly external_id: v.StringSchema<undefined>;
+        readonly meeting_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly created: v.BooleanSchema<undefined>;
+        readonly inserted_transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly replayed_transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly superseded_transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly segments: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly media_sha256: v.StringSchema<undefined>;
+        readonly engine: v.StringSchema<undefined>;
+        readonly model: v.StringSchema<undefined>;
+        readonly model_version: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly timing: v.PicklistSchema<["fixed-windows", "recognition-segments"], undefined>;
+    }, undefined>], undefined>;
+    readonly meeting_embedding: v.UnionSchema<[v.StrictObjectSchema<{
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly model: v.StrictObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly dims: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly kind: v.PicklistSchema<["local", "remote"], undefined>;
+            readonly model: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly status: v.StrictObjectSchema<{
+            readonly chunks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        }, undefined>;
+        readonly applied: v.LiteralSchema<false, undefined>;
+        readonly scope: v.LiteralSchema<"existing-current-chunks", undefined>;
+        readonly rebuild_required: v.LiteralSchema<"explicit", undefined>;
+    }, undefined>, v.StrictObjectSchema<{
+        readonly account_id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly model: v.StrictObjectSchema<{
+            readonly key: v.StringSchema<undefined>;
+            readonly dims: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly kind: v.PicklistSchema<["local", "remote"], undefined>;
+            readonly model: v.StringSchema<undefined>;
+        }, undefined>;
+        readonly saved: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly next_hash: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly applied: v.LiteralSchema<true, undefined>;
+        readonly rebuild: v.StrictObjectSchema<{
+            readonly transcripts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly chunks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly has_more: v.BooleanSchema<undefined>;
+            readonly next_transcript_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>], undefined>;
+};

package/dist/meetings/result-items.js

@@ -0,0 +1,125 @@
+import * as v from "valibot";
+const text = v.string();
+const identifier = v.pipe(text, v.minLength(1));
+const nullableText = v.nullable(text);
+const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+const flag = v.boolean();
+const scope = v.strictObject({ provider: text, account: text });
+const run = v.strictObject({
+    meetings: count,
+    participants: count,
+    transcript_rows: count,
+    summaries: count,
+    warnings: v.array(v.strictObject({ external_id: text, message: text })),
+    timezone: v.optional(text),
+});
+const exported = v.union([
+    v.strictObject({ meeting_id: identifier, format: v.picklist(["markdown", "vtt"]), filename: text, content: text }),
+    v.strictObject({ meeting_id: identifier, format: v.picklist(["markdown", "vtt"]), output: text }),
+]);
+const eventChange = v.strictObject({
+    action: v.literal("event.link"),
+    event_id: v.nullable(identifier),
+    expected_event_id: v.optional(v.nullable(identifier)),
+});
+const personChange = v.strictObject({
+    action: v.literal("person.link"),
+    participant_id: identifier,
+    person_uid: text,
+    expected_person_uid: v.optional(nullableText),
+    target_account_ids: v.optional(v.array(identifier)),
+});
+const eventResult = v.strictObject({
+    meeting_id: identifier,
+    event_id: v.nullable(identifier),
+    previous_event_id: v.nullable(identifier),
+    changed: flag,
+});
+const personResult = v.strictObject({
+    meeting_id: identifier,
+    participant_id: identifier,
+    person_uid: text,
+    previous_person_uid: nullableText,
+    changed: flag,
+});
+const meetingChange = v.strictObject({
+    scope,
+    account_id: identifier,
+    meeting_id: identifier,
+    change: v.union([eventChange, personChange]),
+    applied: flag,
+    result: v.optional(v.union([eventResult, personResult])),
+});
+const recognition = v.strictObject({
+    engine: text,
+    model: text,
+    version: v.optional(text),
+    timing: v.optional(v.picklist(["fixed-windows", "recognition-segments"])),
+});
+const transcription = v.union([
+    v.strictObject({
+        applied: v.literal(false),
+        account_id: identifier,
+        external_id: text,
+        segments: count,
+        media: v.strictObject({
+            id: text,
+            content_hash: text,
+            size: count,
+            duration_ms: count,
+            format: text,
+            sample_rate: count,
+            channels: count,
+            recognition,
+        }),
+    }),
+    v.strictObject({
+        applied: v.literal(true),
+        account_id: identifier,
+        external_id: text,
+        meeting_id: identifier,
+        created: flag,
+        inserted_transcripts: count,
+        replayed_transcripts: count,
+        superseded_transcripts: count,
+        segments: count,
+        media_sha256: text,
+        engine: text,
+        model: text,
+        model_version: nullableText,
+        timing: v.picklist(["fixed-windows", "recognition-segments"]),
+    }),
+]);
+const embeddingModel = v.strictObject({ key: text, dims: count, kind: v.picklist(["local", "remote"]), model: text });
+const embedding = v.union([
+    v.strictObject({
+        account_id: identifier,
+        model: embeddingModel,
+        status: v.strictObject({ chunks: count, embedded: count }),
+        applied: v.literal(false),
+        scope: v.literal("existing-current-chunks"),
+        rebuild_required: v.literal("explicit"),
+    }),
+    v.strictObject({
+        account_id: identifier,
+        model: embeddingModel,
+        saved: count,
+        skipped: count,
+        has_more: flag,
+        next_hash: v.optional(text),
+        applied: v.literal(true),
+        rebuild: v.strictObject({
+            transcripts: count,
+            chunks: count,
+            has_more: flag,
+            next_transcript_id: v.optional(identifier),
+        }),
+    }),
+]);
+export const MEETING_RESULT_ENTITIES = {
+    meeting_ingestion: run,
+    meeting_export: exported,
+    meeting_association: meetingChange,
+    meeting_transcription: transcription,
+    meeting_embedding: embedding,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.406.0",
+  "version": "0.408.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",