@knowttl/gitea-axi 0.1.2 → 0.1.3

package/README.md

@@ -71,6 +71,7 @@ Full workflow run APIs require Gitea 1.24 or later; the retained workflow, artif
 ### Search
 
 `search issues|prs|repos|commits "text"` searches at most 20 pages and 1000 candidates per collection, then filters, sorts and applies the total output limit (default 1000).
+Search sorts creation and update times chronologically across time zone offsets before applying the output limit.
 Issue and PR searches support exact arbitrary author and assignee names and comma-separated label ANY matching; an unknown label alone matches nothing.
 Use `--repo OWNER/NAME` for repository scope or `--owner OWNER` for issue, PR and repository searches.
 Repository search supports `--language` and integer `--stars` comparisons.
@@ -108,10 +109,11 @@ Anonymous HTTP reads require `--allow-insecure-http` for that selected origin.
 The tool follows no redirects and never imports tea or Git credentials.
 Output uses TOON; structured errors use stdout, with exit 1 for operational failures and exit 2 for usage errors.
 Business reads share a 30-second deadline, except check watches use their explicit timeout; each request has a 2,000,000-byte response limit.
+The check-watch timeout includes initial repository reads; polling cannot extend the client's deadline.
 `repo view` instead gives each of its server version, specification and repository requests a separate 30-second timeout.
 An explicit repository wins over a matching local origin remote; a remote never changes the selected profile.
-`-R` aliases `--repo` after an explicit command, with the same duplicate-selector checks.
-For the default dashboard, use `gitea-axi --repo OWNER/NAME`; root-level `-R` remains unsupported.
+`-R` aliases `--repo`, with the same duplicate-selector checks.
+For the default dashboard, use `gitea-axi --repo OWNER/NAME` or `gitea-axi -R OWNER/NAME`.
 Hosted repository reads require an explicit repository.
 Lists default to 30 returned records, except `run list` and `release list` default to 10; collection scans stop at 20 pages or at least 1000 unique records and retain at most 1000.
 Automatic page queries apply only to routes whose retained Gitea specification declares a `page` parameter.
@@ -126,7 +128,10 @@ The dashboard shows a compact repository projection (ID, full name, visibility,
 Dashboard sections report permission failures as partial results and point truncated sections to the corresponding standalone list command with `--repo` and `--limit`.
 Issue and PR bodies default to 1000 characters, diffs to 10000 characters, and rendered output to 100000 characters.
 `--full` expands bodies and diffs within the response and output ceilings.
-`pr checks` exits 8 for pending checks and 1 for failed or absent checks; watches require an explicit deadline and accept cancellation.
+Diffs retain an unchanged source prefix sized to fit the serialized output, including escaping and metadata; `chars` reports the original length and `truncated` indicates omitted text.
+`pr checks` exits 8 for pending checks and 1 for failed or absent checks; watches require an explicit deadline.
+During check polling, SIGINT or SIGTERM aborts in-flight PR and status requests, including paginated responses, and returns `cancelled: true` with exit code 8.
+Cancellation preserves the last completed check result; before any completed result, it returns empty items and zero counts, with the head SHA if already read, otherwise null.
 Commits without statuses return an empty check result; watches continue waiting for checks to register until the deadline or cancellation.
 `--fields` refuses unknown names and fields without an evidenced Gitea equivalent, and cannot combine with detail expansion flags.
 PR statusCheckRollup explicitly identifies partial commit statuses, and `fullDatabaseId` is a numeric vendor ID rather than a GraphQL node ID.
@@ -154,8 +159,11 @@ Issue and label deletion require a complete collection and at least one remainin
 
 ### Pull requests
 
+`pr view` includes both user and team review requests in `reviewRequests`: users have `login` and `name`, while teams have `type: team`, `id` and `name`.
 Pull request mutations include `create`, `edit`, `close`, `reopen`, `comment`, `update-branch` and `merge`.
 Creation requires explicit `--title`, `--base` and `--head` branch names in the selected repository.
+PR creation, base edits, updates and merges support slash-containing branch names such as `work/topic` and `release/stable`, resolving exact Git refs rather than prefix matches.
+Branch resolution binds commit identities into preview and confirmation while preserving API path separator and traversal protections.
 Cross-repository heads, draft and project inputs remain unavailable.
 Create accepts repeatable `--reviewer` user names and `--team-reviewer` team names, plus issue-style assignees, labels and milestone selectors.
 Edit accepts `--base`, text fields and assignee/label deltas, plus repeatable `--add-reviewer`, `--remove-reviewer`, `--add-team-reviewer` and `--remove-team-reviewer` deltas.
@@ -167,6 +175,7 @@ If the reviewer step fails after creation, the error reports the created PR ID a
 Close with `--comment` records closure and comment as separate steps and reports partial outcomes without retrying.
 Successful writes verify the same PR identity, expected fields and memberships through fresh reads.
 Update-branch verifies that the resulting head contains both its previous head and base commits; conflicts never report completion.
+Verification stops once both commits are proven present, so older base history need not be traversed; it reads at most 1000 commits and refuses completion if that bound prevents proof.
 Merge requires exactly one of `--merge`, `--squash`, `--rebase` or `--method merge|squash|rebase`, and a full `--match-head-commit` SHA.
 It sends the vendor `head_commit_id` precondition and verifies the closed, merged PR, base branch tip and final commit topology.
 Merge commits retain the previous base and checked head as parents; squash uses one new commit on the previous base; rebase verifies the rewritten linear chain and original commit messages.
@@ -259,8 +268,14 @@ gitea-axi issue close 42 --repo OWNER/NAME --comment 'Resolved' --allow-write is
 gitea-axi label create --repo OWNER/NAME --name bug --color ff0000 --allow-write issueCreateLabel --preview
 ```
 
-The preview identifies the exact operations, payload and current preconditions without sending a mutation.
+The preview identifies the exact operations and payload without sending a mutation.
+To fit the rendered output ceiling, previews, write results and reconciliation output may summarize `preconditions`, then `observations`, then `results`, stopping as soon as the output fits.
+Summarized output sets `truncated: true` and lists affected fields in `truncated_fields`.
+Summaries report `summary: true` with `total_items`, `total_fields` or `total_chars`; object summaries retain numeric `id` and `number` when present.
+Summarized observations retain paths, and observations and results retain at most ten entries with their original counts in `observations_total` and `results_total`.
+Preview steps and requested payloads remain complete subject to credential redaction; output that still exceeds the ceiling fails with `OUTPUT_LIMIT`.
 Confirmation binds the credential revision, origin, target, operations, canonical payload and preconditions.
+Display summaries do not weaken confirmation binding or readback verification, which use the complete data.
 Changing any binding requires a fresh preview.
 Organization casing must match the preview exactly.
 For issues that remain present, successful named writes verify identity and the expected final title, body, assignees, labels, milestone and state through fresh reads.
@@ -282,6 +297,10 @@ Each attempt is persisted before dispatch.
 API timeouts, interrupted requests and partial failures return `WRITE_OUTCOME_UNKNOWN`, completed/pending step information and an exact `gitea-axi write reconcile CONFIRMATION_ID` command.
 Dispatched local Git failures retain their specific error code and include reconciliation information; stack recovery follows the [metadata and recovery contract](docs/local-stack-contract.md).
 Reconciliation performs complete metadata reads for inspection and never repeats a mutation.
+If its display is summarized as described above, use targeted reads to inspect the exact identity and requested fields before authorizing another attempt.
+Raw repository edits with a nonempty `name` verify and reconcile through the repository's immutable ID, so a rename does not depend on the old URL.
+Raw wiki edits use the returned escaped `sub_url` for verification and reconciliation; if the response is lost or its page identity is unusable, reconciliation reads the bounded wiki page list instead.
+These read targets preserve the original confirmation binding and attempted-effect identity.
 An unresolved dispatched attempt cannot be replayed by reusing its confirmation or obtaining another preview for the same effect.
 Replay guards also treat repository owner, repository name and organization name case variants as the same identity for named and raw writes.
 Unresolved organization attempts from older versions conservatively block all writes to the same organization at the same origin, including different names or payloads, and return the original attempt's reconciliation command.
@@ -303,7 +322,7 @@ Incomplete environment profiles report missing variables; profile schema errors
 For file profiles, an explicit profile must match; otherwise exactly one matching profile is required, ignoring `defaultProfile`.
 Without a host selector, file selection uses the explicit profile, otherwise the file's `defaultProfile` or its sole profile; multiple profiles without a selection or default are refused.
 A host selector cannot construct an anonymous origin, bypass tokenOrigin binding or enable HTTP.
-Search commands currently reject `--hostname`; use `GH_HOST` with a matching profile instead.
+Search commands support `--hostname` and `GH_HOST` with the same profile selection and credential binding checks.
 Hosted invocations refuse credential/configuration overrides and ignore ambient `GH_HOST` for the injected Artium profile.
 On Linux, the config file must be owned by the invoking account and must not be group- or world-writable.
 Config files and file SecretRefs must be regular files; symlinks are refused.
@@ -401,7 +420,7 @@ Set `GITEA_AXI_REPORT` to retain their reports at a chosen path.
 Their default reports go to unique files in the OS temporary directory; temporary installation files are removed.
 For S5, set `GITEA_AXI_REPORT_DIR` to an existing directory to retain `S5.1.json` or `S5.2.json`; otherwise only a console summary is emitted.
 
-`npm test` first runs the package-contract check in `scripts/verify-package.ts`, then the offline live-read regressions in `scripts/verify-live-reads.ts`, then the installed-package checks with local Gitea fakes for S1.1, S2.1 through S2.4, S3.1 through S3.5, S4.1 through S4.3, S5.1, S5.2 and S6.1 through S6.4 under an inherited outbound network guard.
+`npm test` first runs the package-contract check in `scripts/verify-package.ts`, then the native Git workspace checks in `scripts/verify-git.ts`, then the offline live-read regressions in `scripts/verify-live-reads.ts`, then the installed-package checks with local Gitea fakes for S1.1, S2.1 through S2.4, S3.1 through S3.5, S4.1 through S4.3, S5.1, S5.2 and S6.1 through S6.4 under an inherited outbound network guard.
 The package-contract check builds, packs and installs offline, validates the tarball file list and bin entry, smoke-tests the installed `--help` and `--version`, parses the consumed JSON artifacts and imports the modules Artium consumes from the installed package.
 Run it independently with `node --import ./scripts/deny-network.ts scripts/verify-package.ts`.
 Each S2 task also has an independent entrypoint, for example `node scripts/verify.mjs --task S2.3`.

package/dist/api.js

@@ -136,9 +136,9 @@ export function rawPath(input, method = 'GET') {
         throw new CliError('READ_ONLY', 'Unclassified API route');
     return path + (query ? '?' + query : '');
 }
-export async function read(client, path) {
+export async function read(client, path, signal) {
     routeFor(path.split('?')[0]);
-    const value = await client.get(path);
+    const value = await client.get(path, signal);
     return validate(path.split('?')[0], value);
 }
 export async function resolveCommit(client, base, ref) {
@@ -166,7 +166,7 @@ export async function rawRead(client, path) {
     const count = response.headers.get('x-total-count');
     return { data, total: count && /^\d+$/.test(count) ? Number(count) : null, next: nextPage(response.headers, path, client.origin), truncated: false };
 }
-export async function collect(client, path, envelope) {
+export async function collect(client, path, envelope, signal) {
     const paginated = routeFor(path).paginated;
     let next = paginated ? path + (path.includes('?') ? '&' : '?') + 'limit=50&page=1' : path;
     const seenPages = new Set();
@@ -176,14 +176,14 @@ export async function collect(client, path, envelope) {
         if (seenPages.has(next))
             throw new CliError('INVALID_RESPONSE', 'Gitea repeated a pagination URL');
         seenPages.add(next);
-        const response = await client.request(next);
+        const response = await client.request(next, false, undefined, signal);
         const data = validate(new URL(next, client.origin).pathname, response.data);
         const rows = envelope ? object(data)[envelope] : data;
         if (!Array.isArray(rows))
             throw new CliError('INVALID_RESPONSE', 'Expected a Gitea list' + (envelope ? ' envelope ' + envelope : ''));
         for (const value of rows) {
             const row = object(value);
-            const id = /\/(?:tags|actions\/(?:secrets|variables))$/.test(path.split('?')[0]) ? row.name : row.id ?? row.number ?? row.sha ?? row.filename ?? (row.user && row.content ? String(object(row.user).id) + ':' + row.content : undefined);
+            const id = /\/(?:tags|actions\/(?:secrets|variables))$/.test(path.split('?')[0]) ? row.name : row.id ?? row.number ?? row.sha ?? row.ref ?? row.sub_url ?? row.filename ?? (row.user && row.content ? String(object(row.user).id) + ':' + row.content : undefined);
             if (typeof id !== 'number' && typeof id !== 'string')
                 throw new CliError('INVALID_RESPONSE', 'List record has no identity');
             items.set(String(id), row);

package/dist/git.js

@@ -43,9 +43,9 @@ export class Git {
         if (!isAbsolute(this.cwd) || await realpath(this.cwd) !== this.cwd || await this.run(['rev-parse', '--show-toplevel']) !== this.cwd) {
             throw new CliError('USAGE', '--workspace must be the absolute native repository root', 2);
         }
-        const config = await this.run(['config', '--local', '--name-only', '--list']) + '\n' +
-            await this.run(['config', '--worktree', '--name-only', '--list']);
-        if (config.split('\n').some(key => /^(?:url\.|http\.|credential\.|include\.|includeif\.|filter\.|diff\.|core\.sshcommand$|remote\..*\.(?:proxy|uploadpack|receivepack|pushurl|vcs)$)/i.test(key))) {
+        const config = await this.run(['config', '--no-includes', '--show-scope', '--name-only', '--list']);
+        // Inspect repository settings without requiring config.worktree or rejecting our command-scope transport settings.
+        if (config.split('\n').some(key => /^(?:local|worktree)\t(?:url\.|http\.|credential\.|include\.|includeif\.|filter\.|diff\.|core\.sshcommand$|remote\..*\.(?:proxy|uploadpack|receivepack|pushurl|vcs)$)/i.test(key))) {
             throw new CliError('UNSAFE_GIT_CONFIG', 'Workspace transport overrides must be removed before using origin-bound Git');
         }
         return this;

package/dist/main.js

@@ -19,6 +19,7 @@ import { actionValues, valuePlan } from './action-values.js';
 import { assetPath, attachToPlan, download, uploadPlan } from './attachments.js';
 import { isLocal, localWorkflow, validateLocal } from './local-workflows.js';
 import { capabilityOutput, commandGap } from './catalogue.js';
+import { diffOutput, maxOutputChars } from './output.js';
 async function input(path) {
     if (path !== '-')
         return readPrivateFile(path, true, 1_000_000);
@@ -42,7 +43,7 @@ export async function main(args) {
         if (args.some(arg => /^--(?:token|api-key|password|authorization)(?:=|$)/i.test(arg))) {
             throw new CliError('CONFIG_INVALID', 'token and other secret arguments are not accepted');
         }
-        const command = args.length === 0 || args[0]?.startsWith('--') ? commands.find(command => command.path[0] === 'dashboard') :
+        const command = args.length === 0 || args[0]?.startsWith('-') ? commands.find(command => command.path[0] === 'dashboard') :
             [...commands].sort((a, b) => b.path.length - a.path.length).find(command => command.path.every((part, index) => args[index] === part));
         if (!command) {
             const children = commands.filter(command => command.path[0] === args[0]);
@@ -54,7 +55,7 @@ export async function main(args) {
         }
         const path = command.path;
         operation = command.path.join(' ');
-        const rest = args[0]?.startsWith('--') || !args.length ? args : args.slice(path.length);
+        const rest = args[0]?.startsWith('-') || !args.length ? args : args.slice(path.length);
         let parsed;
         try {
             const options = Object.fromEntries(Object.entries(command.flags).map(([name, flag]) => [name, { type: flag.type,
@@ -119,7 +120,7 @@ export async function main(args) {
             });
             const output = await localWorkflow(new Client(identity.origin, identity.token, 300_000), identity, operation, positionals, options);
             const rendered = encode(redact(output));
-            if (rendered.length > 100_000)
+            if (rendered.length > maxOutputChars)
                 throw new CliError('OUTPUT_LIMIT', 'Rendered output exceeds 100000 characters');
             console.log(rendered);
             return;
@@ -359,12 +360,11 @@ export async function main(args) {
             else if (operation === 'pr diff') {
                 const response = await client.request(base + '/pulls/' + positionals[0] + '.diff', true);
                 const text = String(response.data);
-                const ceiling = options.full ? 100_000 : 10_000;
-                output = { diff: text.slice(0, ceiling), chars: text.length, truncated: text.length > ceiling, ...(text.length > ceiling ? { help: 'Use --full within the 100000 character diff ceiling' } : {}) };
+                output = diffOutput(text, Boolean(options.full));
             }
         }
         const rendered = encode(redact(output));
-        if (rendered.length > 100_000)
+        if (rendered.length > maxOutputChars)
             throw new CliError('OUTPUT_LIMIT', 'Rendered output exceeds 100000 characters; select fewer fields or a lower --limit');
         console.log(rendered);
     }

package/dist/output.js

@@ -0,0 +1,56 @@
+import { encode } from '@toon-format/toon';
+import { redact } from './credentials.js';
+export const maxOutputChars = 100_000;
+// Reserve the newline added by console.log.
+const fits = (value) => encode(redact(value)).length < maxOutputChars;
+function summary(value) {
+    if (Array.isArray(value))
+        return { summary: true, total_items: value.length };
+    if (value && typeof value === 'object') {
+        const row = value;
+        return { summary: true, total_fields: Object.keys(row).length,
+            ...(typeof row.id === 'number' ? { id: row.id } : {}), ...(typeof row.number === 'number' ? { number: row.number } : {}) };
+    }
+    return typeof value === 'string' ? { summary: true, total_chars: value.length } : value;
+}
+export function writeOutput(value) {
+    const displayed = { ...value };
+    const truncated = [];
+    // Keep requested effects complete; project only their verification context.
+    for (const field of ['preconditions', 'observations', 'results']) {
+        if (fits(displayed))
+            return displayed;
+        if (!(field in value))
+            continue;
+        const context = value[field];
+        if (field === 'observations' && Array.isArray(context)) {
+            displayed[field] = context.slice(0, 10).map(row => ({ path: row.path, data: summary(row.data) }));
+            displayed.observations_total = context.length;
+        }
+        else if (field === 'results' && Array.isArray(context)) {
+            displayed[field] = context.slice(0, 10).map(summary);
+            displayed.results_total = context.length;
+        }
+        else
+            displayed[field] = summary(context);
+        truncated.push(field);
+        displayed.truncated = true;
+        displayed.truncated_fields = [...truncated];
+    }
+    return displayed;
+}
+export function diffOutput(text, full) {
+    const candidate = (length) => ({ diff: text.slice(0, length), chars: text.length, truncated: text.length > length,
+        ...(text.length > length ? { help: full ? 'Diff is bounded to the rendered output ceiling' : 'Use --full for a larger bounded diff' } : {}) });
+    let low = 0, high = Math.min(text.length, full ? maxOutputChars : 10_000);
+    if (fits(candidate(high)))
+        return candidate(high);
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (fits(candidate(middle)))
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return candidate(low);
+}

package/dist/pulls.js

@@ -7,7 +7,27 @@ const sorted = (values) => [...values].sort();
 const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 const delta = (previous, add, remove) => [...new Set([...previous.map(String), ...names(add)])].filter(value => !names(remove).includes(value));
 const members = (pull, field, key) => (pull[field] ?? []).map(row => object(row)[key]);
+function branchPath(base, branch) {
+    const segments = branch.split('/');
+    if (segments.some(segment => !segment || segment === '.' || segment === '..') || /[\s\\\x00-\x1f\x7f]/.test(branch))
+        usage('Select a branch without unsafe path segments');
+    return base + '/git/refs/heads/' + segments.map(encodeURIComponent).join('/');
+}
+function branchSHA(value, branch) {
+    if (!Array.isArray(value))
+        throw new CliError('INVALID_RESPONSE', 'Expected branch references');
+    const selected = value.map(object).find(row => row.ref === 'refs/heads/' + branch);
+    if (!selected)
+        throw new CliError('NOT_FOUND_OR_HIDDEN', 'The selected branch is missing or hidden');
+    const commit = object(selected.object);
+    if (commit.type !== 'commit' || typeof commit.sha !== 'string' || !/^[a-f0-9]{40}$/.test(commit.sha))
+        throw new CliError('INVALID_RESPONSE', 'Expected an immutable branch commit identity');
+    return commit.sha;
+}
 export function validatePull(operation, options) {
+    for (const ref of [options.head, options.base])
+        if (ref !== undefined)
+            branchPath('', String(ref));
     if (operation === 'pr review') {
         if (['approve', 'request-changes', 'comment'].filter(key => options[key]).length !== 1)
             usage('Choose exactly one of --approve, --request-changes or --comment');
@@ -49,6 +69,7 @@ export async function pullPlan(client, operation, base, number, options) {
         reads.add(path);
         return value;
     };
+    const snapshotBranch = async (branch) => branchSHA(await snapshot(branchPath(base, branch), true), branch);
     const add = (method, path, payload) => steps.push({ method, path, ...(payload === undefined ? {} : { payload }) });
     const before = action === 'create' ? undefined : object(await snapshot(path));
     const expected = before ? { id: before.id, number: before.number, ...fields(before), merged: before.merged ?? false, headSHA: object(before.head).sha } :
@@ -101,15 +122,14 @@ export async function pullPlan(client, operation, base, number, options) {
             payload.assignees = names(options.assignee);
             expected.reviewers = sorted(addedReviewers);
             expected.teams = sorted(names(options['team-reviewer']));
-            const head = object(await snapshot(base + '/branches/' + encodeURIComponent(String(options.head))));
-            expected.headSHA = object(head.commit).id;
+            expected.headSHA = await snapshotBranch(String(options.head));
         }
         else {
             if (options['add-assignee'] !== undefined || options['remove-assignee'] !== undefined)
                 payload.assignees = delta(expected.assignees, options['add-assignee'], options['remove-assignee']);
         }
         if (options.base !== undefined)
-            await snapshot(base + '/branches/' + encodeURIComponent(String(options.base)));
+            await snapshotBranch(String(options.base));
         if (options.milestone !== undefined) {
             const list = await snapshot(base + '/milestones?state=all', true);
             const selected = list.find(row => row.title === options.milestone);
@@ -171,12 +191,12 @@ export async function pullPlan(client, operation, base, number, options) {
             payload.MergeMessageField = options.body;
         if (style === 'rebase')
             await snapshot(path + '/commits', true);
-        await snapshot(base + '/branches/' + encodeURIComponent(String(expected.base)));
+        await snapshotBranch(String(expected.base));
         add('POST', path + '/merge', payload);
         expected.state = 'closed';
     }
     else if (action === 'update-branch') {
-        await snapshot(base + '/branches/' + encodeURIComponent(String(expected.base)));
+        await snapshotBranch(String(expected.base));
         add('POST', path + '/update');
     }
     if (action === 'comment' || action === 'close' && options.comment !== undefined) {
@@ -228,8 +248,8 @@ export async function verifyPull(client, plan, results, observations) {
     }
     if (action !== 'merge' && action !== 'update-branch')
         return;
-    const branchPath = base + '/branches/' + encodeURIComponent(String(expected.base));
-    const baseSHA = object(object(before[branchPath]).commit).id;
+    const baseBranchPath = branchPath(base, String(expected.base));
+    const baseSHA = branchSHA(before[baseBranchPath], String(expected.base));
     const commit = async (sha) => {
         if (typeof sha !== 'string' || !/^[a-f0-9]{40}$/.test(sha))
             return mismatch();
@@ -241,25 +261,29 @@ export async function verifyPull(client, plan, results, observations) {
         return data;
     };
     if (action === 'update-branch') {
-        const head = await commit(object(pull.head).sha);
-        const pending = [head], visited = new Set();
-        while (pending.length && visited.size < 1000) {
-            const current = pending.pop();
-            if (visited.has(current.sha))
+        const required = new Set([baseSHA, expected.headSHA]);
+        if ([...required].some(sha => typeof sha !== 'string' || !/^[a-f0-9]{40}$/.test(sha)))
+            mismatch();
+        const pending = [object(pull.head).sha], visited = new Set();
+        for (let cursor = 0; cursor < pending.length && visited.size < 1000; cursor++) {
+            const sha = pending[cursor];
+            if (visited.has(sha))
                 continue;
+            const current = await commit(sha);
             visited.add(current.sha);
-            if (visited.has(baseSHA) && visited.has(expected.headSHA))
+            required.delete(current.sha);
+            const parents = members(current, 'parents', 'sha');
+            for (const parent of parents)
+                required.delete(parent);
+            if (!required.size)
                 return;
-            for (const parent of members(current, 'parents', 'sha')) {
-                if (!visited.has(parent))
-                    pending.push(await commit(parent));
-            }
+            pending.push(...parents.filter(parent => !visited.has(parent)));
         }
         mismatch();
     }
     if (pull.merged !== true || !pull.merge_commit_sha)
         mismatch();
-    const finalSHA = object(object(observation(branchPath)).commit).id;
+    const finalSHA = branchSHA(observation(baseBranchPath), String(expected.base));
     if (finalSHA !== pull.merge_commit_sha)
         mismatch();
     const final = await commit(finalSHA);

package/dist/reads.js

@@ -111,8 +111,8 @@ export async function listIssues(client, base, kind, options) {
         truncated: page.truncated || rows.length > limit, next: page.next, continuation: page.truncated || rows.length > limit,
         help: [`gitea-axi ${kind} view <number> --repo ${base.split('/').slice(-2).join('/')}`, ...continuationHelp(page, rows.length, limit)] };
 }
-async function complete(client, path) {
-    const page = await collect(client, path);
+async function complete(client, path, signal) {
+    const page = await collect(client, path, undefined, signal);
     if (page.truncated)
         throw new CliError('RESPONSE_LIMIT', 'Related collection exceeds the bounded read; use the raw API to page explicitly');
     return page.items;
@@ -127,11 +127,11 @@ async function reviews(client, path, full) {
     }
     return result;
 }
-export async function checks(client, base, sha) {
-    const combined = object(await read(client, base + '/commits/' + encodeURIComponent(sha) + '/status'));
+export async function checks(client, base, sha, signal) {
+    const combined = object(await read(client, base + '/commits/' + encodeURIComponent(sha) + '/status', signal));
     if (combined.sha !== sha && !(combined.sha === '' && combined.total_count === 0 && (combined.statuses === null || Array.isArray(combined.statuses) && !combined.statuses.length)))
         throw new CliError('INVALID_RESPONSE', 'Check response does not match the pull request head SHA');
-    const statuses = await complete(client, base + '/commits/' + encodeURIComponent(sha) + '/statuses');
+    const statuses = await complete(client, base + '/commits/' + encodeURIComponent(sha) + '/statuses', signal);
     statuses.sort((a, b) => Number(b.id) - Number(a.id));
     const latest = new Map();
     for (const status of statuses)
@@ -146,28 +146,37 @@ export async function checks(client, base, sha) {
 export async function watchChecks(client, base, number, options) {
     const seconds = positive(options.timeout, 30, 3600);
     const interval = positive(options.interval, 5, 60) * 1000;
-    const stop = Date.now() + seconds * 1000;
+    const stop = Math.min(client.deadline, Date.now() + seconds * 1000);
     const controller = new AbortController();
+    let head = null;
+    let latest;
     const cancel = () => controller.abort();
     process.once('SIGINT', cancel);
     process.once('SIGTERM', cancel);
     try {
         while (true) {
-            const pull = object(await read(client, base + '/pulls/' + number));
+            const pull = object(await read(client, base + '/pulls/' + number, controller.signal));
             const sha = object(pull.head).sha;
             if (typeof sha !== 'string' || !sha)
                 throw new CliError('INVALID_RESPONSE', 'Pull request head SHA is missing');
-            const result = await checks(client, base, sha);
+            head = sha;
+            const result = await checks(client, base, sha, controller.signal);
+            latest = result;
             if (!options.watch || result.items.length > 0 && !result.pending || result.failed || Date.now() >= stop || controller.signal.aborted)
-                return { ...result, cancelled: controller.signal.aborted };
+                return { ...result, exitCode: controller.signal.aborted ? 8 : result.exitCode, cancelled: controller.signal.aborted };
             await delay(Math.min(interval, Math.max(1, stop - Date.now())), undefined, { signal: controller.signal }).catch(error => {
                 if (!controller.signal.aborted)
                     throw error;
             });
             if (Date.now() >= stop || controller.signal.aborted)
-                return { ...result, cancelled: controller.signal.aborted };
+                return { ...result, exitCode: controller.signal.aborted ? 8 : result.exitCode, cancelled: controller.signal.aborted };
         }
     }
+    catch (error) {
+        if (!controller.signal.aborted)
+            throw error;
+        return { ...(latest ?? { head, items: [], passed: 0, failed: 0, pending: 0 }), exitCode: 8, cancelled: true };
+    }
     finally {
         process.removeListener('SIGINT', cancel);
         process.removeListener('SIGTERM', cancel);
@@ -196,7 +205,8 @@ export async function view(client, base, kind, number, options) {
                 headRepository: head.repo == null ? null : { name: object(head.repo).name, nameWithOwner: object(head.repo).full_name },
                 headRepositoryOwner: head.repo == null ? null : user(object(head.repo).owner), isCrossRepository: head.repo_id == null || tail.repo_id == null ? null : head.repo_id !== tail.repo_id,
                 mergeCommit: row.merge_commit_sha ? { oid: row.merge_commit_sha } : null, mergedBy: user(row.merged_by),
-                mergeable: row.mergeable == null ? 'UNKNOWN' : row.mergeable ? 'MERGEABLE' : 'CONFLICTING', reviewRequests: users(row.requested_reviewers) });
+                mergeable: row.mergeable == null ? 'UNKNOWN' : row.mergeable ? 'MERGEABLE' : 'CONFLICTING', reviewRequests: [...users(row.requested_reviewers),
+                    ...(row.requested_reviewers_teams ?? []).map(team => ({ type: 'team', id: team.id, name: team.name }))] });
         }
         if (options.reviews || requested.has('reviews') || requested.has('latestReviews')) {
             const all = await reviews(client, path, Boolean(options.full || fields));

package/dist/registry.js

@@ -91,7 +91,7 @@ const definitions = [
     ['pr view', { ...repo, ...detail, reviews: { type: 'boolean' }, checks: { type: 'boolean' } }],
     ['pr checks', { ...repo, watch: { type: 'boolean' }, timeout: { type: 'string', description: 'Watch deadline seconds, required with --watch' }, interval: { type: 'string', description: 'Watch interval seconds, default 5' } }],
     ['pr diff', { ...repo, full: detail.full }],
-    ['release list', { ...repo, limit: list.limit, 'exclude-drafts': { type: 'boolean' }, 'exclude-pre-releases': { type: 'boolean' } }],
+    ['release list', { ...repo, limit: { ...list.limit, description: 'Maximum returned records, default 10, maximum 1000' }, 'exclude-drafts': { type: 'boolean' }, 'exclude-pre-releases': { type: 'boolean' } }],
     ['release view', { ...repo, full: detail.full }], ['api', { ...writeFlags,
             method: { type: 'string', short: 'X', description: 'HTTP method; cannot combine with a positional method' },
             field: { type: 'string', multiple: true, description: 'Repeatable key=value; numbers, booleans and null become JSON values' },

package/dist/search.js

@@ -9,7 +9,7 @@ export function validateSearch(kind, query, options) {
     const allowed = kind === 'issues' || kind === 'prs' ? ['owner', 'state', 'label', 'assignee', 'author', 'sort', 'order', 'limit', 'fields', ...(kind === 'prs' ? ['draft'] : [])] :
         kind === 'repos' ? ['owner', 'sort', 'order', 'limit', 'language', 'stars', 'fields'] : ['author', 'sort', 'order', 'limit', 'revision', 'fields'];
     for (const key of Object.keys(options)) {
-        if (!['origin', 'allow-insecure-http', 'config', 'profile', 'repo'].includes(key) && !allowed.includes(key))
+        if (!['origin', 'allow-insecure-http', 'config', 'profile', 'hostname', 'repo'].includes(key) && !allowed.includes(key))
             throw new CliError('CAPABILITY_GAP', '--' + key + ' is not evidenced for search ' + kind);
     }
     positive(options.limit, 1000, 1000);
@@ -94,9 +94,11 @@ export async function search(client, kind, query, options) {
         return true;
     });
     const key = options.sort === 'updated' ? 'updated_at' : options.sort === 'comments' ? 'comments' : options.sort === 'stars' ? 'stars_count' : options.sort === 'name' ? 'full_name' : kind === 'commits' ? 'created' : 'created_at';
+    const temporal = ['created', 'created_at', 'updated_at'].includes(key);
     rows.sort((a, b) => {
         const left = a[key] ?? '', right = b[key] ?? '';
-        const compared = typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right));
+        const compared = temporal && left !== '' && right !== '' ? Date.parse(String(left)) - Date.parse(String(right)) :
+            typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right));
         return (compared || String(a.id ?? a.sha).localeCompare(String(b.id ?? b.sha))) * (options.order === 'asc' ? 1 : -1);
     });
     const limit = positive(options.limit, 1000, 1000);

package/dist/stacks.js

@@ -24,6 +24,8 @@ const schema = new Ajv().compile({
                 originalBranch: { type: 'string' }, originalTips: { type: 'string' },
                 steps: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['effect', 'state'],
                         properties: { effect: branch, state: { enum: ['pending', 'dispatched', 'completed'] } } } },
+                prune: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['branch', 'number', 'head', 'merge'],
+                        properties: { branch, number: { type: 'integer', minimum: 1 }, head: { type: 'string', pattern: '^[a-f0-9]{40}$' }, merge: { type: 'string', pattern: '^[a-f0-9]{40}$' } } } },
                 rebase: { type: 'object', additionalProperties: false,
                     required: ['branches', 'oldBases', 'originalTips', 'expectedTips', 'originalBranch', 'cursor', 'dispatched', 'authorDate'],
                     properties: { branches: { type: 'array', items: branch, uniqueItems: true }, oldBases: tips, originalTips: tips, expectedTips: tips,
@@ -39,6 +41,12 @@ async function stackAt(path, git) {
         value.pulls.some(pull => !value.branches.includes(pull.branch))) {
         throw new CliError('STACK_INVALID', 'Stack metadata is invalid, inconsistent or belongs to a different origin');
     }
+    const prune = value.pending?.prune;
+    if (prune && (value.pending.action !== 'sync' || new Set(prune.map(item => item.branch)).size !== prune.length ||
+        prune.some(item => !value.branches.includes(item.branch) || !value.pulls.some(pull => pull.branch === item.branch && pull.number === item.number) ||
+            value.pending.steps.filter(step => step.effect === 'prune ' + item.branch).length !== 1))) {
+        throw new CliError('STACK_INVALID', 'Prune checkpoints must describe only the owned stack branches and linked PRs');
+    }
     const rebase = value.pending?.rebase;
     if (rebase) {
         if (rebase.cursor > rebase.branches.length || rebase.branches.some(branch => !value.branches.includes(branch) || !rebase.oldBases[branch]) ||
@@ -53,7 +61,13 @@ async function stackAt(path, git) {
     return value;
 }
 async function ancestor(git, parent, child) {
-    return (await git.run(['merge-base', parent, child])) === await git.tip(parent);
+    return (await git.run(['merge-base', parent, child], [0, 1])) === await git.tip(parent);
+}
+function releaseBranch(state, branch) {
+    state.branches = state.branches.filter(name => name !== branch);
+    state.pulls = state.pulls.filter(pull => pull.branch !== branch);
+    if (state.pending?.prune)
+        state.pending.prune = state.pending.prune.filter(item => item.branch !== branch);
 }
 export async function stackWorkflow(client, identity, action, args, options) {
     const git = await new Git(String(options.workspace), identity.origin, identity.token).workspace();
@@ -107,6 +121,8 @@ export async function stackWorkflow(client, identity, action, args, options) {
     state.remote = remote.name;
     const plans = [];
     const commands = [];
+    const prune = [];
+    const fetchedRefs = [];
     let destination;
     let remove = false;
     let rebase;
@@ -249,21 +265,43 @@ export async function stackWorkflow(client, identity, action, args, options) {
             linked.state = pull.state;
             linked.merged = pull.merged === true;
         }
+        for (const member of [...state.branches]) {
+            if (snapshot.refs.split('\n').some(line => line.startsWith('refs/heads/' + member + ' ')))
+                continue;
+            const pending = before?.pending;
+            const recorded = pending?.prune?.find(item => item.branch === member);
+            const checkpoint = pending?.steps.find(step => step.effect === 'prune ' + member);
+            const linked = state.pulls.find(pull => pull.branch === member);
+            const pull = page.items.find(pull => pull.number === linked?.number);
+            if (!recoveringSync || !recorded || !checkpoint || checkpoint.state === 'pending' || !pull ||
+                pull.number !== recorded.number || pull.state !== 'closed' || pull.merged !== true ||
+                object(pull.head).sha !== recorded.head || pull.merge_commit_sha !== recorded.merge ||
+                !pending.originalTips.split('\n').includes('refs/heads/' + member + ' ' + recorded.head) ||
+                !await git.run(['rev-parse', '--verify', '--quiet', recorded.head + '^{commit}'], [0, 1]) ||
+                !await git.run(['rev-parse', '--verify', '--quiet', recorded.merge + '^{commit}'], [0, 1]) ||
+                !await ancestor(git, recorded.head, recorded.merge)) {
+                throw new CliError('STACK_RECOVERY_REQUIRED', 'An absent owned branch requires its dispatched prune checkpoint and verified merged PR history');
+            }
+            releaseBranch(state, member);
+        }
         const existing = [state.trunk, ...state.branches].filter(name => remoteRefs.split('\n').some(line => line.endsWith('\trefs/heads/' + name)));
+        for (const name of existing)
+            fetchedRefs.push({ ref: 'refs/remotes/' + remote.name + '/' + name,
+                head: remoteRefs.split('\n').find(line => line.endsWith('\trefs/heads/' + name)).split('\t')[0] });
         if (existing.length)
             commands.push(['fetch', '--no-tags', '--', remote.url, ...existing.map(name => 'refs/heads/' + name + ':refs/remotes/' + remote.name + '/' + name)]);
         if (options.prune) {
             for (const member of [...state.branches]) {
                 const linked = state.pulls.find(pull => pull.branch === member);
                 const pull = page.items.find(pull => pull.number === linked?.number);
-                if (!linked || !pull || pull.merged !== true || object(pull.head).sha !== await git.tip('refs/heads/' + member))
+                if (!linked || !pull || pull.state !== 'closed' || pull.merged !== true || object(pull.head).sha !== await git.tip('refs/heads/' + member))
                     continue;
                 if (member === snapshot.branch || snapshot.worktrees.split('\n').includes('branch refs/heads/' + member))
                     continue;
                 const merge = String(pull.merge_commit_sha);
-                if (!/^[a-f0-9]{40}$/.test(merge) || !await git.run(['rev-parse', '--verify', '--quiet', merge + '^{commit}'], [0, 1]) ||
-                    !await ancestor(git, 'refs/heads/' + member, merge))
+                if (!/^[a-f0-9]{40}$/.test(merge))
                     continue;
+                prune.push({ branch: member, number: linked.number, head: linked.head, merge });
                 commands.push(['branch', '-d', member]);
             }
         }
@@ -349,7 +387,7 @@ export async function stackWorkflow(client, identity, action, args, options) {
     const local = 'gitea.local.stack.' + localAction;
     const begin = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'begin', action, args, options: { ...options, preview: undefined, confirm: undefined }, remote,
             ...(recovering ? { recoverLocal: before.pending.confirmations } : {}) } };
-    const finish = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'finish', state, commands, remove, destination } };
+    const finish = { method: 'LOCAL', path: git.cwd, local, payload: { phase: 'finish', state, commands, prune, remove, destination } };
     const steps = [begin];
     const apiResultIndices = [];
     for (const [index, plan] of plans.entries()) {
@@ -374,7 +412,9 @@ export async function stackWorkflow(client, identity, action, args, options) {
                 if (action !== 'rebase')
                     state.pending = { action, confirmations: recovering ? [...before.pending.confirmations] : [],
                         originalBranch: before?.pending?.originalBranch ?? snapshot.branch, originalTips: before?.pending?.originalTips ?? snapshot.refs,
-                        steps: [...plans.map(plan => ({ effect: plan.target, state: 'pending' })), ...commands.map(command => ({ effect: command[0], state: 'pending' }))] };
+                        ...(prune.length ? { prune: structuredClone(prune) } : {}),
+                        steps: [...plans.map(plan => ({ effect: plan.target, state: 'pending' })),
+                            ...commands.map(command => ({ effect: command[0] === 'branch' ? 'prune ' + command[2] : command[0], state: 'pending' }))] };
                 state.pending.confirmations.push(confirmation);
                 await save(path, state);
                 return { state: 'started' };
@@ -452,12 +492,25 @@ export async function stackWorkflow(client, identity, action, args, options) {
             }
             else {
                 for (const [index, command] of commands.entries()) {
+                    if (action === 'sync' && command[0] === 'branch') {
+                        const selected = prune.find(item => item.branch === command[2]);
+                        if (await git.tip('refs/heads/' + selected.branch) !== selected.head)
+                            throw new CliError('CONFIRMATION_MISMATCH', 'A prune candidate changed before deletion');
+                        if (!await git.run(['rev-parse', '--verify', '--quiet', selected.merge + '^{commit}'], [0, 1]) ||
+                            !await ancestor(git, selected.head, selected.merge))
+                            continue;
+                    }
                     state.pending.steps[plans.length + index].state = 'dispatched';
                     await save(path, state);
                     await git.run(command);
+                    if (prune.length && command[0] === 'fetch') {
+                        for (const expected of fetchedRefs) {
+                            if (await git.tip(expected.ref) !== expected.head)
+                                throw new CliError('CONFIRMATION_MISMATCH', 'Fetched branch differs from the confirmed remote graph');
+                        }
+                    }
                     if (action === 'sync' && command[0] === 'branch') {
-                        state.branches = state.branches.filter(name => name !== command[2]);
-                        state.pulls = state.pulls.filter(pull => pull.branch !== command[2]);
+                        releaseBranch(state, command[2]);
                     }
                     state.pending.steps[plans.length + index].state = 'completed';
                     await save(path, state);

package/dist/transport.js

@@ -28,13 +28,14 @@ export class Client {
         this.token = token;
         this.deadline = Date.now() + timeoutMs;
     }
-    async request(path, text = false, mutation) {
+    async request(path, text = false, mutation, signal) {
         canonicalPath(path);
         const url = new URL(path, this.origin);
         if (url.origin !== this.origin || !path.startsWith('/') || path.startsWith('//'))
             throw new CliError('UNSAFE_PATH', 'Request must stay within the selected origin');
         try {
             const form = mutation?.upload ? new FormData() : undefined;
+            const timeout = AbortSignal.timeout(Math.max(1, Math.min(limits.timeoutMs, this.deadline - Date.now())));
             if (form && mutation?.upload)
                 form.set('attachment', new Blob([Buffer.from(mutation.upload.base64, 'base64')], { type: mutation.upload.type }), mutation.upload.name);
             const response = await fetch(url, {
@@ -42,7 +43,7 @@ export class Client {
                 ...(form ? { body: form } : mutation?.payload === undefined ? {} : { body: JSON.stringify(mutation.payload) }),
                 headers: { accept: text ? 'text/plain' : 'application/json', ...(mutation && !form ? { 'content-type': 'application/json' } : {}), ...(this.token ? { authorization: 'token ' + this.token } : {}) },
                 redirect: 'error',
-                signal: AbortSignal.timeout(Math.max(1, Math.min(limits.timeoutMs, this.deadline - Date.now()))),
+                signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
             });
             if (mutation?.sensitive) {
                 await response.body?.cancel();
@@ -87,7 +88,7 @@ export class Client {
             throw new CliError('TRANSPORT_ERROR', 'Gitea request failed (' + transportCause(error) + '); check the selected origin and connection');
         }
     }
-    async get(path) { return (await this.request(path)).data; }
+    async get(path, signal) { return (await this.request(path, false, undefined, signal)).data; }
     async attachment(uuid, expectedType) {
         if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(uuid))
             throw new CliError('UNSAFE_PATH', 'Invalid attachment UUID');

package/dist/writes.js

@@ -3,7 +3,7 @@ import { constants, existsSync } from 'node:fs';
 import { mkdir, open, readdir, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join } from 'node:path';
-import { canonicalPath, collect, effectFor, object, read, validate, validatePayload } from './api.js';
+import { canonicalPath, collect, effectFor, object, read, routeFor, validate, validatePayload } from './api.js';
 import { CliError } from './error.js';
 import { readPrivateFile, writePrivateFile } from './private-file.js';
 import { verifyPull } from './pulls.js';
@@ -11,6 +11,7 @@ import { verifyWorkflow } from './repo-workflows.js';
 import { actionValues, valuePlan, verifyValue } from './action-values.js';
 import { verifyUploads } from './attachments.js';
 import { controlText } from './credentials.js';
+import { writeOutput } from './output.js';
 function canonical(value) {
     if (Array.isArray(value))
         return '[' + value.map(canonical).join(',') + ']';
@@ -53,8 +54,8 @@ export async function reconcile(client, id) {
         throw new CliError('CONFIRMATION_MISMATCH', 'Reconciliation origin differs from the attempted write');
     const observations = await observe(client, receipt.reads);
     controlText(id);
-    return { confirmation: id, operations: receipt.operations, states: receipt.states, observations,
-        help: 'Inspect the exact identity and requested fields in these reads before authorizing any new attempt' };
+    return writeOutput({ confirmation: id, operations: receipt.operations, states: receipt.states, observations,
+        help: 'Inspect the exact identity and requested fields in these reads before authorizing any new attempt' });
 }
 async function observe(client, paths) {
     const observations = [];
@@ -268,8 +269,8 @@ export async function write(client, identity, plan, options, executeLocal) {
         const receipt = { binding, origin: client.origin, reads: plan.reads, states: plan.steps.map(() => 'pending'), operations, attempt, guardVersion: 2,
             ...(plan.steps.every(step => step.local) ? { localTarget: plan.target, localGuards: guards.map(path => path.slice(root.length + 1, -8)) } : {}) };
         await writePrivateFile(join(root, id + '.json'), JSON.stringify(receipt));
-        return { confirmation: id, origin: client.origin, target: plan.target, operations, steps: plan.steps.map(({ upload, ...step }) => ({ ...step, ...(plan.sensitive && step.payload !== undefined ? { payload: '[REDACTED]' } : {}), ...(upload ? { upload: { name: upload.name, type: upload.type, size: upload.size, sha256: upload.sha256 } } : {}) })), preconditions: plan.preconditions,
-            ...(plan.notes ? { notes: plan.notes } : {}), help: controlText('Repeat the same command with --confirm ' + id + ' instead of --preview') };
+        return writeOutput({ confirmation: id, origin: client.origin, target: plan.target, operations, steps: plan.steps.map(({ upload, ...step }) => ({ ...step, ...(plan.sensitive && step.payload !== undefined ? { payload: '[REDACTED]' } : {}), ...(upload ? { upload: { name: upload.name, type: upload.type, size: upload.size, sha256: upload.sha256 } } : {}) })), preconditions: plan.preconditions,
+            ...(plan.notes ? { notes: plan.notes } : {}), help: controlText('Repeat the same command with --confirm ' + id + ' instead of --preview') });
     }
     const id = String(options.confirm);
     if (!/^[a-f0-9-]{36}$/.test(id))
@@ -356,6 +357,19 @@ export async function write(client, identity, plan, options, executeLocal) {
             const result = dispatched.local ? await executeLocal(dispatched, results, id) :
                 (await client.request(dispatched.path, false, { ...dispatched, ...(plan.sensitive ? { sensitive: true } : {}) })).data;
             results.push(result);
+            if (plan.wikiRename) {
+                const original = dispatched.path.split('?')[0];
+                const page = object(validate(original, result));
+                if (typeof page.sub_url !== 'string' || !page.sub_url)
+                    throw new CliError('INVALID_RESPONSE', 'Wiki rename returned no page identity');
+                // Gitea's sub_url is already escaped and may differ from the requested display title.
+                const renamed = original.slice(0, original.lastIndexOf('/') + 1) + page.sub_url;
+                const url = new URL(renamed, client.origin);
+                if (url.origin !== client.origin || url.pathname !== renamed || url.search || url.hash || routeFor(renamed).operation !== 'repoGetWikiPage') {
+                    throw new CliError('INVALID_RESPONSE', 'Wiki rename returned an unsafe page identity');
+                }
+                receipt.reads = [renamed];
+            }
             if (plan.steps.some(step => step.assetParent === index)) {
                 const parent = object(result);
                 if (!Number.isSafeInteger(parent.id) || Number(parent.id) <= 0)
@@ -415,7 +429,7 @@ export async function write(client, identity, plan, options, executeLocal) {
         recovered.states = recovered.states.map(state => state === 'completed' ? state : 'recovered');
         await writePrivateFile(join(root, previous + '.json'), JSON.stringify(recovered));
     }
-    return { confirmation: id, states: receipt.states, results, observations, ...(plan.notes ? { notes: plan.notes } : {}), reconcile: command(id, options) };
+    return writeOutput({ confirmation: id, states: receipt.states, results, observations, ...(plan.notes ? { notes: plan.notes } : {}), reconcile: command(id, options) });
 }
 export async function rawWritePlan(client, method, path, payload) {
     const route = validatePayload(method, path, payload);
@@ -434,7 +448,17 @@ export async function rawWritePlan(client, method, path, payload) {
     if (verification.endsWith('/issues'))
         verification += '?state=all&type=issues';
     const preconditions = await observe(client, [verification]);
-    return { target: path, steps: [{ method, path, ...(payload === undefined ? {} : { payload }) }], reads: [verification], preconditions };
+    let reads = [verification];
+    const wikiRename = route.operation === 'repoEditWikiPage';
+    if (wikiRename)
+        reads = [verification.slice(0, verification.lastIndexOf('/page/')) + '/pages'];
+    if (route.operation === 'repoEdit' && typeof object(payload).name === 'string' && object(payload).name !== '') {
+        const id = object(preconditions[0].data).id;
+        if (!Number.isSafeInteger(id) || Number(id) <= 0)
+            throw new CliError('INVALID_RESPONSE', 'Repository rename requires an immutable repository identity');
+        reads = ['/api/v1/repositories/' + id];
+    }
+    return { target: path, steps: [{ method, path, ...(payload === undefined ? {} : { payload }) }], reads, preconditions, ...(wikiRename ? { wikiRename: true } : {}) };
 }
 const names = (value) => [...new Set(Array.isArray(value) ? value.map(String) : [String(value)])];
 export async function issueLabelPlan(client, operation, base, number, options) {

package/generated/help.txt

@@ -784,7 +784,7 @@ commands[128]:
         description: OWNER/NAME; otherwise a matching local origin remote
       limit:
         type: string
-        description: "Maximum returned records, default 30, maximum 1000"
+        description: "Maximum returned records, default 10, maximum 1000"
       "exclude-drafts":
         type: boolean
       "exclude-pre-releases":

package/generated/host-inventory.json

@@ -1120,7 +1120,7 @@
         },
         "limit": {
           "type": "string",
-          "description": "Maximum returned records, default 30, maximum 1000"
+          "description": "Maximum returned records, default 10, maximum 1000"
         },
         "exclude-drafts": {
           "type": "boolean"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowttl/gitea-axi",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "An agent CLI for Gitea repository workflows",
   "license": "MIT",
   "repository": {