@skrr-ai/cli 0.1.119 → 0.1.120

package/dist/commands/wiki/history.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAuthor = formatAuthor;
+exports.buildHistoryRows = buildHistoryRows;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+/**
+ * `agent <id>` for a write a verified Run proved; otherwise the person whose
+ * credential wrote it, with the channel it came through — so an agent working
+ * through a delegated CLI credential without Run proof reads as
+ * "person <id> (via delegated agent CLI credential)", never as a bare person.
+ */
+function formatAuthor(author) {
+    if (!author)
+        return 'unknown';
+    if (author.kind === 'agent')
+        return `agent ${author.agentId ?? '?'}`;
+    const channel = author.via
+        ? (data_provider_1.CREDENTIAL_CHANNEL_LABELS[author.via] ?? author.via)
+        : null;
+    return channel ? `person ${author.userId} (via ${channel})` : `person ${author.userId}`;
+}
+function sameAuthor(a, b) {
+    return (a.kind === b.kind &&
+        a.userId === b.userId &&
+        a.agentId === b.agentId &&
+        a.runId === b.runId &&
+        a.via === b.via);
+}
+function buildHistoryRows(revisions) {
+    return revisions.map((revision) => {
+        const others = (revision.contributors ?? []).filter((contributor) => !revision.author || !sameAuthor(contributor, revision.author));
+        const source = revision.source === 'write'
+            ? `write${revision.mode ? `/${revision.mode}` : ''}`
+            : `editor${revision.open ? ' (open)' : ''}`;
+        return {
+            rev: String(revision.revisionNumber),
+            when: revision.capturedAt ?? revision.createdAt ?? '',
+            author: formatAuthor(revision.author),
+            also: others.map(formatAuthor).join(', '),
+            source,
+            chars: String(revision.chars ?? 0),
+        };
+    });
+}
+class WikiHistory extends base_command_1.BaseCommand {
+    static description = "Show a wiki page's revision history: each version, and whether a person or an agent wrote it";
+    static examples = [
+        '<%= config.bin %> wiki history <space-id> Engineering/Runbooks/deploy',
+        '<%= config.bin %> wiki history <space-id> Engineering/Runbooks/deploy --revision 3 > v3.md',
+        '<%= config.bin %> wiki history <space-id> --page-id <page-id> --json',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+        path: core_1.Args.string({ description: 'Page path', required: false, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        'page-id': core_1.Flags.string({ description: 'Address the page by id instead of path' }),
+        limit: core_1.Flags.integer({ description: 'Revisions per page (max 100)', default: 20 }),
+        cursor: core_1.Flags.string({ description: 'Continue from a previous listing (its next_cursor)' }),
+        revision: core_1.Flags.integer({
+            description: 'Print one revision as Markdown instead of listing them',
+            min: 1,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WikiHistory);
+        if (!args.path && !flags['page-id']) {
+            this.failWithCliError({
+                message: 'Provide a page path or --page-id.',
+                code: 'WIKI_PAGE_ADDRESS_REQUIRED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const pageId = flags['page-id'];
+        const path = args.path;
+        if (flags.revision !== undefined) {
+            let revision;
+            try {
+                revision = pageId
+                    ? await data_provider_1.dataService.getSpaceWikiPageRevision(args.space, pageId, flags.revision)
+                    : await data_provider_1.dataService.getSpaceWikiRevisionByPath(args.space, path, flags.revision);
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+            if (flags.json) {
+                this.printJsonResult(revision);
+                return;
+            }
+            // Body only, like `wiki cat`, so `> v3.md` produces a clean file.
+            this.log(revision.content ?? '');
+            return;
+        }
+        let response;
+        const paging = { limit: flags.limit, cursor: flags.cursor };
+        try {
+            response = pageId
+                ? await data_provider_1.dataService.getSpaceWikiPageHistory(args.space, pageId, paging)
+                : await data_provider_1.dataService.getSpaceWikiHistoryByPath(args.space, path, paging);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.printJsonResult(response);
+            return;
+        }
+        const revisions = response.data ?? [];
+        if (revisions.length === 0) {
+            // History starts with the first write recorded after it shipped; an
+            // older page has none until it is next edited.
+            this.log('No recorded revisions yet.');
+            return;
+        }
+        (0, format_1.renderTable)(buildHistoryRows(revisions), [
+            { key: 'rev', header: 'REV' },
+            { key: 'when', header: 'WHEN', maxWidth: 24 },
+            { key: 'author', header: 'AUTHOR', maxWidth: 60 },
+            { key: 'also', header: 'ALSO', maxWidth: 60 },
+            { key: 'source', header: 'SOURCE' },
+            { key: 'chars', header: 'CHARS' },
+        ], (line) => this.log(line));
+        if (response.has_more && response.next_cursor) {
+            this.log(`More: --cursor ${response.next_cursor}`);
+        }
+    }
+}
+exports.default = WikiHistory;

package/dist/commands/wiki/ls.d.ts

@@ -5,6 +5,8 @@ export type WikiLsRow = {
     kind: string;
     name: string;
     title: string;
+    /** A page's kind when it is not an ordinary `doc` page (`charter`, ...); '' otherwise. */
+    pageKind: string;
     updated: string;
     id: string;
 };

package/dist/commands/wiki/ls.js

@@ -20,6 +20,7 @@ function buildRows(listing) {
             // title would just repeat it. The listing carries no folder timestamp, so
             // it has no date to show either.
             title: '',
+            pageKind: '',
             updated: '',
             id: f.folder_id,
         })),
@@ -32,6 +33,9 @@ function buildRows(listing) {
             // `tree` has always rendered `slug [title]`; `ls` simply had no column
             // for it, though `--json` carried it all along.
             title: p.title && p.title !== p.slug ? p.title : '',
+            // Only a page that is not an ordinary doc names its kind (OSK-17985).
+            // A server that predates kinds sends none, which reads as `doc`.
+            pageKind: p.kind && p.kind !== 'doc' ? p.kind : '',
             updated: (0, format_1.localStamp)(p.lastEditedAt ?? p.updatedAt) || '',
             id: p.pageId,
         })),
@@ -39,6 +43,7 @@ function buildRows(listing) {
             kind: 'file',
             name: f.filename,
             title: '',
+            pageKind: '',
             updated: '',
             id: f.file_id,
         })),
@@ -58,6 +63,9 @@ function columnsFor(rows) {
     ];
     if (rows.some((r) => r.title))
         columns.push({ key: 'title', header: 'TITLE', maxWidth: 48 });
+    // Elided like TITLE: a wiki of ordinary pages prints exactly what it did.
+    if (rows.some((r) => r.pageKind))
+        columns.push({ key: 'pageKind', header: 'KIND' });
     // The thing most worth knowing from a listing is what moved recently, and
     // `ls` gave a UUID nobody asked for and no date at all.
     if (rows.some((r) => r.updated))

package/dist/commands/wiki/update.d.ts

@@ -1,6 +1,7 @@
 import { BaseCommand } from '../../base-command';
 /**
- * `skrr wiki update <space> <path>` — a page's METADATA: title, icon, order.
+ * `skrr wiki update <space> <path>` — a page's METADATA: title, icon, order,
+ * kind.
  *
  * Distinct from `mv`, which owns the page's PATH, and from `write`, which owns
  * its body. That split follows the server: retitling deliberately keeps the
@@ -21,6 +22,7 @@ export default class WikiUpdate extends BaseCommand {
         icon: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'clear-icon': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         order: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        kind: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/wiki/update.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const space_charter_1 = require("../../lib/space-charter");
 const wiki_1 = require("../../lib/wiki");
 const wiki_update_1 = require("../../lib/wiki-update");
 /**
- * `skrr wiki update <space> <path>` — a page's METADATA: title, icon, order.
+ * `skrr wiki update <space> <path>` — a page's METADATA: title, icon, order,
+ * kind.
  *
  * Distinct from `mv`, which owns the page's PATH, and from `write`, which owns
  * its body. That split follows the server: retitling deliberately keeps the
@@ -16,12 +18,16 @@ const wiki_update_1 = require("../../lib/wiki-update");
  * `mv` is for, and two commands that both rewrite a slug is how they drift.
  */
 class WikiUpdate extends base_command_1.BaseCommand {
-    static description = "Update a wiki page's title, icon, or sort order";
+    static description = "Update a wiki page's title, icon, sort order, or kind. A Space holds at most one " +
+        'live charter page: making a second page the charter is refused until the first ' +
+        'is changed to another kind or archived.';
     static examples = [
         '<%= config.bin %> wiki update <space-id> Engineering/deploy --title "Deploy Runbook"',
         '<%= config.bin %> wiki update <space-id> Engineering/deploy --icon 🚀',
         '<%= config.bin %> wiki update <space-id> Engineering/deploy --clear-icon',
         '<%= config.bin %> wiki update <space-id> Engineering/deploy --order 0 --json',
+        '<%= config.bin %> wiki update <space-id> charter --kind charter',
+        '<%= config.bin %> wiki update <space-id> journal/2026-10-22 --kind journal_entry',
     ];
     static args = {
         space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
@@ -37,6 +43,11 @@ class WikiUpdate extends base_command_1.BaseCommand {
             exclusive: ['icon'],
         }),
         order: core_1.Flags.integer({ description: 'Sort position within its folder (0-based)' }),
+        kind: core_1.Flags.string({
+            description: "What the page is for. `charter` is the Space's one charter (its lead section, " +
+                'before the first ## heading, is read by every agent in the Space).',
+            options: [...data_provider_1.WIKI_PAGE_KINDS],
+        }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
@@ -56,6 +67,7 @@ class WikiUpdate extends base_command_1.BaseCommand {
             icon: flags.icon,
             clearIcon: flags['clear-icon'],
             order: flags.order,
+            kind: flags.kind,
         });
         if (!built.ok) {
             this.failWithCliError({
@@ -82,6 +94,16 @@ class WikiUpdate extends base_command_1.BaseCommand {
             });
         }
         catch (err) {
+            const hint = (0, space_charter_1.charterConflictHint)(err, { binName: this.config.bin, spaceId: args.space });
+            if (hint) {
+                this.failWithCliError({
+                    message: hint.message,
+                    code: 'WIKI_CHARTER_EXISTS',
+                    exit: 1,
+                    retryable: false,
+                    details: hint.details,
+                });
+            }
             this.handleApiError(err, { subject: `wiki page ${path}` });
         }
         if (flags.json) {

package/dist/commands/wiki/write.d.ts

@@ -35,6 +35,23 @@ export declare function slugifyLikeServer(input: string): string;
  * later reads as "no collision" rather than as a fresh false positive.
  */
 export declare function createdSlugCollided(requestedSlug: string, createdSlug?: string): boolean;
+/**
+ * The warning for `--kind` on a write that landed in a page that already
+ * existed, or `null` when there is nothing to say.
+ *
+ * `--kind`, like `--title`, describes a page this command CREATES: `write` owns
+ * the body, `update` owns metadata. A write into an existing page of another
+ * kind therefore changes the body and not the kind, and saying so is the
+ * difference between that and a silent no-op. A page an older server returns
+ * without a kind reads as `doc`.
+ */
+export declare function kindIgnoredWarning(opts: {
+    requested?: string;
+    existingKind?: string;
+    binName: string;
+    spaceId: string;
+    path: string;
+}): string | null;
 export default class WikiWrite extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -49,7 +66,12 @@ export default class WikiWrite extends BaseCommand {
         stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         html: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         append: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'create-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         title: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        kind: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        section: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        lead: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        note: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/wiki/write.js

@@ -4,10 +4,12 @@ exports.isWikiPageNotFound = isWikiPageNotFound;
 exports.conflictingPageId = conflictingPageId;
 exports.slugifyLikeServer = slugifyLikeServer;
 exports.createdSlugCollided = createdSlugCollided;
+exports.kindIgnoredWarning = kindIgnoredWarning;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const http_error_1 = require("../../lib/http-error");
+const space_charter_1 = require("../../lib/space-charter");
 const web_url_1 = require("../../lib/web-url");
 const wiki_1 = require("../../lib/wiki");
 /**
@@ -90,6 +92,27 @@ function createdSlugCollided(requestedSlug, createdSlug) {
     // fallback, an 8-char uuid head.
     return /^\d+$/.test(suffix) || /^[0-9a-f]{8}$/.test(suffix);
 }
+/**
+ * The warning for `--kind` on a write that landed in a page that already
+ * existed, or `null` when there is nothing to say.
+ *
+ * `--kind`, like `--title`, describes a page this command CREATES: `write` owns
+ * the body, `update` owns metadata. A write into an existing page of another
+ * kind therefore changes the body and not the kind, and saying so is the
+ * difference between that and a silent no-op. A page an older server returns
+ * without a kind reads as `doc`.
+ */
+function kindIgnoredWarning(opts) {
+    const { requested, existingKind, binName, spaceId, path } = opts;
+    if (requested === undefined)
+        return null;
+    const actual = (0, data_provider_1.readWikiPageKind)(existingKind);
+    if (actual === requested)
+        return null;
+    return (`--kind was ignored: '${path}' already exists as a ${actual} page, and \`wiki write\` only sets ` +
+        `the kind of pages it creates. Change it with \`${binName} wiki update ${spaceId} ${path} ` +
+        `--kind ${requested}\`.`);
+}
 class WikiWrite extends base_command_1.BaseCommand {
     // The markdown dialect note lives here, not only in SKRR_WIKI.md: --help is the
     // one place a CLI user (or an agent with no docs) looks before writing, and
@@ -118,6 +141,11 @@ class WikiWrite extends base_command_1.BaseCommand {
         '<%= config.bin %> wiki write <space-id> Engineering/deploy --file runbook.md',
         'cat notes.md | <%= config.bin %> wiki write <space-id> notes --stdin',
         '<%= config.bin %> wiki write <space-id> log --content "Shipped v2" --append',
+        '<%= config.bin %> wiki write <space-id> charter --kind charter --file charter.md',
+        '<%= config.bin %> wiki write <space-id> journal/2026-10-22 --kind journal_entry --stdin',
+        '<%= config.bin %> wiki write <space-id> Reviews/2026-w43 --kind report --create-only --stdin',
+        '<%= config.bin %> wiki write <space-id> charter --section "## Goals" --file goals.md --note "Tighter after the KR review"',
+        '<%= config.bin %> wiki write <space-id> charter --lead --file lead.md',
     ];
     static args = {
         space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
@@ -130,9 +158,33 @@ class WikiWrite extends base_command_1.BaseCommand {
         stdin: core_1.Flags.boolean({ description: 'Read content from stdin' }),
         html: core_1.Flags.boolean({ description: 'Treat the input as HTML instead of Markdown' }),
         append: core_1.Flags.boolean({ description: 'Append instead of replacing (>> rather than >)' }),
+        'create-only': core_1.Flags.boolean({
+            description: 'Create a new page only. Refuse an existing path or a create race without replacing its content',
+            exclusive: ['append', 'section', 'lead'],
+        }),
         title: core_1.Flags.string({
             description: 'Title for a NEWLY-CREATED page (defaults to the slug). Retitle an existing page with `wiki update --title`',
         }),
+        kind: core_1.Flags.string({
+            description: 'Kind for a NEWLY-CREATED page (default doc). A Space holds one live `charter`; its lead ' +
+                'section is read by every agent in the Space. Change an existing page with `wiki update --kind`',
+            options: [...data_provider_1.WIKI_PAGE_KINDS],
+        }),
+        section: core_1.Flags.string({
+            description: 'Replace ONE section of an existing page instead of the whole page: a heading line ' +
+                '(`## Goals`, which also fixes the level) or its text. The content replaces the heading and ' +
+                'everything under it, up to the next heading of the same or a higher level, so include the heading',
+            exclusive: ['lead', 'append'],
+        }),
+        lead: core_1.Flags.boolean({
+            description: 'Replace only the lead of an existing page: everything before its first `##` heading (for a ' +
+                'charter, the part every agent in the Space reads)',
+            exclusive: ['section', 'append'],
+        }),
+        note: core_1.Flags.string({
+            description: 'Why you are making the change. When the Space holds the write for approval it becomes a ' +
+                'suggestion on the page, and this is its first comment; otherwise it is not stored',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -155,9 +207,10 @@ class WikiWrite extends base_command_1.BaseCommand {
         }
         const format = flags.html ? 'html' : 'markdown';
         const mode = flags.append ? 'append' : 'replace';
-        // Create-or-write, so an agent never has to branch on existence. Look the
-        // page up first; a 404 means "create it", which also creates the folder
-        // chain via `folderPath` (mkdir -p).
+        const partial = flags.section !== undefined || flags.lead === true;
+        // Create-or-write by default; --create-only refuses the existing branch.
+        // A lookup 404 means "create it", which also creates the folder chain via
+        // `folderPath` (mkdir -p). The server's conflict check below owns the race.
         let existing = null;
         try {
             existing = await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
@@ -167,17 +220,47 @@ class WikiWrite extends base_command_1.BaseCommand {
                 this.handleApiError(err);
             }
         }
+        if (flags['create-only'] && existing) {
+            this.failWithCliError({
+                message: `Page '${args.path}' already exists (${existing.pageId}); --create-only changed nothing.`,
+                code: 'WIKI_PAGE_EXISTS',
+                status: 409,
+                exit: 1,
+                retryable: false,
+                details: { requestedPath: args.path, pageId: existing.pageId },
+            });
+        }
+        // A section or the lead is a part of a page that exists: there is nothing
+        // to create it in.
+        if (partial && !existing) {
+            this.failWithCliError({
+                message: `No page at '${args.path}' to replace ${flags.lead ? 'the lead of' : 'a section of'}. ` +
+                    'Write the whole page first.',
+                code: 'WIKI_PAGE_NOT_FOUND',
+                status: 404,
+                exit: 1,
+                retryable: false,
+            });
+        }
         const { dir, name } = (0, wiki_1.splitParentPath)(args.path);
         const writeInto = (pageId) => data_provider_1.dataService.writeSpaceWikiPageContent({
             spaceId: args.space,
             pageId,
-            data: { content, format, mode },
+            data: {
+                content,
+                format,
+                mode,
+                ...(flags.section !== undefined ? { section: flags.section } : {}),
+                ...(flags.lead ? { lead: true } : {}),
+                ...(flags.note ? { note: flags.note } : {}),
+            },
         });
         let page;
         // `existing` decides which branch we OPEN with, never which one we end in:
         // the lookup above can be stale (a CDN-cached 404 is the documented case),
         // so the create below asks the server to refuse rather than rename, and a
-        // refusal is resolved by writing into whatever was really there.
+        // refusal is normally resolved by writing into whatever was really there.
+        // --create-only preserves that refusal instead of changing the winner.
         let wroteIntoExisting = Boolean(existing);
         try {
             if (existing) {
@@ -193,6 +276,7 @@ class WikiWrite extends base_command_1.BaseCommand {
                             folderPath: dir || undefined,
                             content,
                             format,
+                            ...(flags.kind ? { kind: flags.kind } : {}),
                             // Never let the server rename an EXACTLY addressed path. Without
                             // this it answers 201 having created `x-2` beside `x`, and the
                             // write the user asked for silently did not happen.
@@ -202,7 +286,7 @@ class WikiWrite extends base_command_1.BaseCommand {
                 }
                 catch (err) {
                     const conflictId = conflictingPageId(err);
-                    if (conflictId === undefined) {
+                    if (conflictId === undefined || flags['create-only']) {
                         throw err;
                     }
                     // The page existed after all. This is the outcome the user asked
@@ -213,11 +297,50 @@ class WikiWrite extends base_command_1.BaseCommand {
             }
         }
         catch (err) {
+            const charterConflict = (0, space_charter_1.charterConflictHint)(err, {
+                binName: this.config.bin,
+                spaceId: args.space,
+            });
+            if (charterConflict) {
+                this.failWithCliError({
+                    message: charterConflict.message,
+                    code: 'WIKI_CHARTER_EXISTS',
+                    status: 409,
+                    exit: 1,
+                    retryable: false,
+                    details: charterConflict.details,
+                });
+            }
             this.handleApiError(err);
         }
+        // A write an unattended run makes may be held for approval by the Space's
+        // write policy (`202 pending_approval`): a journal entry or report create,
+        // or an append to the one it created (`--append`, OSK-17995), in its Run's
+        // approval bundle (OSK-17994); an edit of any other page's body as a
+        // suggestion on the page (OSK-17997). Nothing was written yet.
+        if (this.reportHeldSpaceWrite(page, { json: flags.json }))
+            return;
         // Fallback for a server predating `conflict: 'fail'`, which answers 201
         // with a renamed slug instead of 409. Unreachable against a current server.
         if (!wroteIntoExisting && createdSlugCollided(name, page.slug)) {
+            if (flags['create-only']) {
+                this.failWithCliError({
+                    message: `The server created '${page.path ?? page.slug}' (${page.pageId}) instead of '${args.path}'. ` +
+                        'This server did not honor atomic --create-only. The existing page was not replaced, ' +
+                        'and the newly created page has not been removed. Upgrade the server before retrying this operation.',
+                    code: 'WIKI_CREATE_ONLY_UNSUPPORTED',
+                    exit: 1,
+                    retryable: false,
+                    details: {
+                        outcome: 'created_different_path',
+                        requestedPath: args.path,
+                        requestedSlug: name,
+                        createdSlug: page.slug,
+                        createdPath: page.path,
+                        pageId: page.pageId,
+                    },
+                });
+            }
             this.failWithCliError({
                 message: `Wrote a DUPLICATE page: asked for '${args.path}' but the server already had that slug and created ` +
                     `'${page.path ?? page.slug}' (${page.pageId}) beside it. The content did NOT overwrite the original.\n` +
@@ -249,6 +372,17 @@ class WikiWrite extends base_command_1.BaseCommand {
                 `it creates. Retitle it with \`${this.config.bin} wiki update ${args.space} ${page.path ?? args.path} ` +
                 `--title ${JSON.stringify(flags.title)}\` (the slug is kept, so stored paths stay valid).`);
         }
+        const ignoredKind = wroteIntoExisting
+            ? kindIgnoredWarning({
+                requested: flags.kind,
+                existingKind: page.kind,
+                binName: this.config.bin,
+                spaceId: args.space,
+                path: page.path ?? args.path,
+            })
+            : null;
+        if (ignoredKind)
+            this.warn(ignoredKind);
         const withUrl = (0, web_url_1.withWikiPageUrl)(this.cliConfig.baseURL, page);
         if (flags.json) {
             this.log(JSON.stringify(withUrl, null, 2));
@@ -260,6 +394,10 @@ class WikiWrite extends base_command_1.BaseCommand {
         let verb = 'Created';
         if (wroteIntoExisting) {
             verb = flags.append ? 'Appended to' : 'Updated';
+            if (flags.lead)
+                verb = 'Replaced the lead of';
+            if (flags.section !== undefined)
+                verb = `Replaced the section ${JSON.stringify(flags.section)} of`;
         }
         this.log(`${verb} ${page.path ?? args.path} (${page.pageId}).`);
         if (withUrl.url)