@kici-dev/orchestrator 0.4.0 → 0.6.0

package/dist/cli/commands/held-run.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Held-run commands for kici-admin.
+ *
+ * Subcommand namespace: `kici-admin held-run <list|approve|reject>`.
+ *
+ * The local answer to a held run, for an orchestrator that has no Platform.
+ * Every other release surface is Platform-relayed — the dashboard approval
+ * queue, `kici approve` / `kici reject`, and the developer MCP tools all reach
+ * the applier over the control-plane connection — and the one surface that is
+ * not, a `/kici approve` pull-request comment, releases the `security` queue
+ * only. So on an independent orchestrator an approval-queue hold had no answer
+ * at all and could only expire.
+ *
+ * These verbs are therefore the mirror image of `trust-policy set`: they work
+ * only where no Platform is attached, and the route refuses with 409 wherever
+ * one is. That refusal is surfaced verbatim rather than reworded here, so the
+ * CLI cannot drift from what the server actually said.
+ *
+ * A hold is named the same way `kici approve` names one — `--job` / `--step` /
+ * `--hold-type` / `--hold`, resolved by the shared `resolveHeldRunId` — so an
+ * operator disambiguating a doubly-held job types the same flags on either
+ * surface. That sharing is the point: a job gated by BOTH a reviewer hold and a
+ * security hold writes two pending rows requiring two decisions, and a second
+ * resolver would be free to disagree about which one `--job` means.
+ */
+import type { Command } from 'commander';
+import { ApprovalDecision, type HeldRunSummary } from '@kici-dev/engine';
+import type { AdminApiClient } from '../api-client.js';
+/** One held-run row as the admin route reports it, with the clause list it adds. */
+type AdminHeldRunSummary = HeldRunSummary & {
+    /** Approver clauses the hold's requirement carries; `[]` when it names nobody. */
+    clauses?: Array<{
+        team: string;
+    } | {
+        user: string;
+    }>;
+};
+/** The decision response the admin route returns. */
+interface DecisionResponse {
+    status: string;
+    remainingClauses?: number;
+}
+/**
+ * Render the pending holds for a run.
+ *
+ * Per-entry rather than a count: "which hold do I answer, and who may answer
+ * it" is the question this command exists to answer, and the hold id it prints
+ * is the `--hold <id>` disambiguator the resolver hands back when nothing else
+ * separates two holds.
+ */
+export declare function formatHeldRuns(res: {
+    heldRuns: AdminHeldRunSummary[];
+}, format: string): string;
+/** Say what the applier did, in the vocabulary `ApplyDecisionResult.status` uses. */
+export declare function formatDecision(res: DecisionResponse, decision: ApprovalDecision): string;
+export declare function registerHeldRunCommands(program: Command, getClient: () => AdminApiClient): void;
+export {};
+//# sourceMappingURL=held-run.d.ts.map

package/dist/cli/commands/runs.d.ts

@@ -9,6 +9,7 @@
  *   runs list                          List execution runs (table or JSON)
  *   runs show <runId>                  Show run detail with jobs and steps
  *   runs jobs <runId>                  List jobs for a run (optional steps)
+ *   runs logs <runId> --job <jobId>    Print a page of one step's log lines
  *   runs ephemeral-key <runId>         Show scrub status of the run's key
  *   runs secret-outputs <runId>        List secret outputs (masked / reveal)
  *

package/dist/cli/commands/trust-policy.d.ts

@@ -1,26 +1,47 @@
 /**
  * Org trust-policy commands for kici-admin.
  *
- * Subcommand namespace: `kici-admin trust-policy <show|set>`.
+ * Subcommand namespace:
+ * `kici-admin trust-policy <show|set|directory|directory-set|directory-remove>`.
  *
  * Talks to the orchestrator admin API directly (not the Platform dashboard
  * proxy), so the CLI stays operable even when Platform is unavailable. Backed
  * by `packages/orchestrator/src/routes/admin-trust-policy.ts`.
  *
- * `set` only works on an independent orchestrator. Wherever a Platform is
- * attached the Platform owns the policy and the route refuses with 409; the
- * message is surfaced verbatim rather than reworded here, so the CLI cannot
- * drift from what the server actually said.
+ * `show` and `directory` read, in every mode. `set`, `directory-set`, and
+ * `directory-remove` write, and only work on an independent orchestrator:
+ * wherever a Platform is attached it owns both the policy and the approval
+ * directory, and the route refuses with 409. That message is surfaced verbatim
+ * rather than reworded here, so the CLI cannot drift from what the server
+ * actually said.
+ *
+ * The two directory writers live in this namespace rather than one of their
+ * own because they are the same org-trust concept as the policy, gated by the
+ * same mode rule against the same `--customer-id`, and reached through the same
+ * admin route file. Splitting them out would put half of "who may approve" in a
+ * second top-level command with its own copy of that story. They are siblings
+ * of the `directory` reader rather than subcommands under it, because turning
+ * that leaf into a group would break `kici-admin trust-policy directory` for
+ * anyone already running it.
  */
 import type { Command } from 'commander';
-import { TrustPolicyEnforcement } from '../../security/trust-policy-gate.js';
 import type { AdminApiClient } from '../api-client.js';
 /**
  * The policy shape the admin route returns.
  *
- * The four policy fields are OPTIONAL because the route omits them under
- * `enforcement: 'legacy'` — there they would be values nothing enforces, and
- * printing them is the false assurance this feature exists to remove.
+ * The four policy fields are OPTIONAL because a **v0.5.0 independent**
+ * orchestrator omits them: there, and only there, no policy row and no attached
+ * Platform meant no policy was resolved at all, and it reported
+ * `enforcement: 'legacy'` with the fields absent. A v0.5.0 Platform-attached
+ * orchestrator with no row still sent the fail-closed values. This build's route
+ * always sends them in every mode, so the `unknown` fallbacks below — and the
+ * `no policy stored` provenance wording — render only against that older
+ * independent orchestrator.
+ *
+ * The route also sends a deprecated `enforcement` field. Nothing here reads it —
+ * on this build it is always `policy` — so it is absent from this shape;
+ * `--format json` stringifies the parsed policy object, so the field still
+ * reaches the operator verbatim.
  */
 export interface TrustPolicyView {
     customerId: string;
@@ -28,15 +49,39 @@ export interface TrustPolicyView {
     unknownContributorPolicy?: string;
     workflowChangePolicy?: string;
     approvalExpiryHours?: number;
-    /** `policy` = the values below are enforced; `legacy` = only the legacy rule. */
-    enforcement?: TrustPolicyEnforcement;
+    /**
+     * The authoritative hold window. Absent from any orchestrator that predates
+     * it, in which case `approvalExpiryHours` is the only window on offer.
+     */
+    approvalExpirySeconds?: number;
     source: string | null;
     updatedAt: string | null;
     effectiveDefault?: boolean;
     platformManaged?: boolean;
 }
-/** Render the policy as an aligned table, or as JSON when asked. */
+/**
+ * Render the policy as an aligned table, or as JSON when asked.
+ *
+ * The two deprecated arms are deliberately absent from the table: no dispatch
+ * decision reads either one, so a row claiming `Unknown contributor policy:
+ * hold` would assert an enforcement that is not happening. They are still
+ * stored and still echoed back, and `--format json` prints the policy object the
+ * route returned, so the values remain reachable for anyone who needs them.
+ */
 export declare function formatPolicy(policy: TrustPolicyView, format: string): string;
+/**
+ * Render the enforced hold window.
+ *
+ * A whole number of hours still prints as `72 h`, exactly as it always did, so
+ * no existing policy's output moves. Anything finer prints in seconds, because
+ * the hours spelling cannot express it and rounding would report a window the
+ * orchestrator is not applying.
+ *
+ * A policy carrying neither field is an orchestrator old enough to have
+ * resolved no policy at all (see {@link TrustPolicyView}); one carrying only
+ * hours is an orchestrator that predates the seconds window.
+ */
+export declare function formatExpiry(policy: TrustPolicyView): string;
 /**
  * Turn CLI flags into a PATCH body, exiting on an unknown value.
  *
@@ -44,5 +89,65 @@ export declare function formatPolicy(policy: TrustPolicyView, format: string): s
  * clear local message naming the accepted values instead of a 400 from the API.
  */
 export declare function buildPolicyPatch(opts: Record<string, string | undefined>): Record<string, string | number>;
+/**
+ * Warn when a patch names both spellings of the hold window.
+ *
+ * The route resolves this deterministically — the more specific seconds value
+ * wins — but an operator who passed both asked for two different things, so the
+ * one that is not applied is named rather than dropped in silence.
+ *
+ * Returns the lines rather than printing them so the check is unit-testable,
+ * matching `policyDeprecationWarnings` below.
+ */
+export declare function policyExpiryWarnings(patch: Record<string, string | number>): string[];
+/**
+ * Warn about deprecated flags and deprecated values in an already-built patch.
+ *
+ * Every one of these still PATCHes through unchanged — the orchestrator stores
+ * what it is given, and an older Platform or CLI keeps seeing the value it
+ * expects. The warning says what the value does now, which for all three is
+ * nothing the fork switch reads.
+ *
+ * Returns the lines rather than printing them so the check is unit-testable,
+ * matching `unpairedEvalTimeoutWarnings` in `cluster-settings.ts`.
+ */
+export declare function policyDeprecationWarnings(patch: Record<string, string | number>): string[];
+/** One identity link as the directory route reports it. */
+interface DirectoryIdentityLink {
+    userId: string;
+    provider: string;
+    providerUsername: string;
+    providerUserId?: string | null;
+}
+/** One operator-defined team as the directory route reports it. */
+interface DirectoryTeam {
+    teamName: string;
+    memberUserIds: string[];
+}
+/** The cached approval directory as the admin route returns it. */
+export interface TrustDirectoryView {
+    customerId: string;
+    identityLinks: DirectoryIdentityLink[];
+    memberCiTrustLevels: Record<string, string>;
+    teamMemberships: DirectoryTeam[];
+    updatedAt: string;
+}
+interface DirectoryResponse {
+    directory: TrustDirectoryView | null;
+    platformManaged: boolean;
+    /** Present on `directory-remove`: false when the member held nothing. */
+    removed?: boolean;
+}
+/**
+ * Render the stored approval directory, or say why there is nothing to render.
+ *
+ * The directory is what `/kici approve` is resolved against: a commenter is
+ * matched to a KiCI user through the identity links, that user's CI trust level
+ * decides whether the approval counts, and a `{team}` clause is matched against
+ * the team memberships. So the listing is per-entry rather than a set of counts
+ * — "who can approve right now" is the question this command exists to answer.
+ */
+export declare function formatDirectory(res: DirectoryResponse, format: string): string;
 export declare function registerTrustPolicyCommands(program: Command, getClient: () => AdminApiClient): void;
+export {};
 //# sourceMappingURL=trust-policy.d.ts.map

package/dist/cli/kici-admin.d.ts

@@ -10,6 +10,16 @@
  *   --token / -t  Admin API token (env: KICI_ADMIN_TOKEN, required)
  */
 import { Command } from 'commander';
+/**
+ * The version `kici-admin --version` reports.
+ *
+ * `scripts/build-service.mjs` defines `KICI_PKG_VERSION` for every orchestrator
+ * build entry, `cli.js` included, so a shipped binary reports the package
+ * version it was built from. The fallback covers a source run (tests, `tsx`),
+ * where no bundler substituted the constant — the same shape `server.ts` and
+ * `standalone.ts` use for `ORCHESTRATOR_VERSION`.
+ */
+export declare const CLI_VERSION: string;
 /**
  * Build the kici-admin Commander program with every command group registered.
  * Exported so the surface registry can walk the real command tree without