@lmctl-ai/lmctl 0.2.20 → 0.2.21

package/dist/cli/seed-flight.d.ts

@@ -0,0 +1,2 @@
+export declare function seedInProgress(teamfile: string, alias: string): boolean;
+export declare function beginSeedFlight(teamfile: string, alias: string): () => void;

package/dist/providers/adapters/agy-adapter.d.ts

@@ -1,5 +1,5 @@
 import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
+import type { SeedOptions, SeedResult } from "../adapter.js";
 export declare function createAgyAdapter(opts?: {
     agyDir?: string;
 }): AgyAdapter;
@@ -8,6 +8,7 @@ declare class AgyAdapter extends BaseProviderAdapter {
         agyDir?: string;
     });
     protected seedArgsFor(opts?: SeedOptions): string[];
+    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
     manualSeedHint(sessiondir: string): {
         launchCommand: string;
         postLaunchNote: string;

package/dist/providers/base-adapter.d.ts

@@ -36,6 +36,8 @@ export interface BaseAdapterConfig {
     binary: string;
     /** Args for seeding a new session with the explicit seed instruction. */
     seedArgs: string[];
+    /** Process timeout for the one-shot seed command. */
+    seedTimeoutMs?: number;
     /** If seed input should be sent via stdin instead of args. */
     seedStdin?: string;
     /** Default resume command template. {{session_id}} is replaced. */
@@ -54,6 +56,7 @@ export declare class BaseProviderAdapter implements ProviderAdapter {
     protected provider: SessionProvider;
     protected binary: string;
     protected seedArgs: string[];
+    protected seedTimeoutMs: number;
     protected seedStdin?: string;
     protected resumeTemplate: string;
     protected startTemplate: string;

package/dist/providers/config/model-selection-lint.d.ts

@@ -32,4 +32,3 @@ export declare function catalogModelWarnings(members: MemberConfig[], opts?: {
 export declare function catalogModelErrors(members: MemberConfig[], opts?: {
     snapshot?: CatalogSnapshot;
 }): Promise<TeamValidationError[]>;
-export declare function resolveModelSelectionDocPathFromHere(here: string): string;

package/dist/providers/index.d.ts

@@ -335,6 +335,8 @@ export interface ListSessionsOptions {
  * ```
  */
 export declare function listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
+/** Delete one native session from a known provider. */
+export declare function deleteSession(provider: ProviderName, sessionId: string, registry?: ProviderRegistry): Promise<boolean>;
 /**
  * Options for `countTokens()`.
  */

package/dist/providers/ratelimit/agy.d.ts

@@ -0,0 +1,21 @@
+type CommandResult = {
+    status: number | null;
+    stdout?: string;
+    error?: NodeJS.ErrnoException;
+};
+type CommandRunner = (timeoutMs: number, env: NodeJS.ProcessEnv) => CommandResult;
+type HttpResult = {
+    status: number;
+    body: string;
+};
+type HttpRunner = (url: string, headers: Record<string, string>, timeoutMs: number) => Promise<HttpResult>;
+/** Test seam; production callers should use readAgy. */
+export declare function _setAgyDepsForTests(deps: {
+    command?: CommandRunner;
+    http?: HttpRunner;
+} | null): void;
+export declare function readAgy(options: {
+    timeoutSeconds: number;
+    env: NodeJS.ProcessEnv;
+}): Promise<Record<string, unknown>>;
+export {};

package/dist/providers/ratelimit/claude.d.ts

@@ -0,0 +1,5 @@
+export interface ClaudeReadOptions {
+    timeoutSeconds: number;
+    env: NodeJS.ProcessEnv;
+}
+export declare function readClaude({ timeoutSeconds, env }: ClaudeReadOptions): Promise<Record<string, unknown>>;

package/dist/providers/ratelimit/codex.d.ts

@@ -0,0 +1,6 @@
+type JsonObject = Record<string, unknown>;
+export declare function readCodex(options: {
+    timeoutSeconds: number;
+    env: NodeJS.ProcessEnv;
+}): Promise<JsonObject>;
+export {};

package/dist/providers/ratelimit/kimi.d.ts

@@ -0,0 +1,5 @@
+export interface KimiReadOptions {
+    timeoutSeconds: number;
+    env: NodeJS.ProcessEnv;
+}
+export declare function readKimi({ timeoutSeconds, env }: KimiReadOptions): Promise<Record<string, unknown>>;

package/dist/providers/ratelimit/schema.d.ts

@@ -0,0 +1,14 @@
+/** Wire format shared by the in-process subscription quota readers. */
+export declare const SCHEMA_URL = "https://lmctl.com/schemas/lmratelimit-v1.json";
+export declare function clampFraction(value: unknown): number | null;
+export declare function toFraction(value: unknown, scale: 'fraction' | 'percent'): number | null;
+export declare function isoFromEpoch(value: unknown): string | null;
+export declare function epochFromIso(value: unknown): number | null;
+export declare function windowTypeFromMinutes(value: unknown): string;
+export declare function windowTypeFromLabel(value: unknown): string;
+export declare function windowSuffix(type: string): string;
+export declare function redact(value: unknown, secrets?: Iterable<string | null | undefined>): string;
+export declare function makeBucket(fields: Record<string, unknown>): Record<string, unknown>;
+export declare function makeReading(provider: string, status: string, fields?: Record<string, unknown>): Record<string, unknown>;
+export declare function errorReading(provider: string, status: string, reason: string, detail?: unknown, source?: string, secrets?: Iterable<string | null | undefined>, retryAfterSeconds?: number | null): Record<string, unknown>;
+export declare function parseRetryAfter(headers: Headers): number | null;

package/dist/providers/ratelimit-readings.d.ts

@@ -1,19 +1,4 @@
 export declare const VALID_RATELIMIT_TARGETS: readonly ["all", "codex", "agy", "claude", "kimi"];
-export interface RatelimitRunResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    signal?: string | null;
-    error?: (Error & {
-        code?: string;
-    }) | undefined;
-}
-export type RatelimitRunner = (bin: string, args: string[], timeoutMs: number) => RatelimitRunResult;
-export interface RatelimitFsDeps {
-    exists(path: string): boolean;
-}
-export declare function _setRatelimitRunnerForTests(fn: RatelimitRunner | null): void;
-export declare function _setRatelimitFsDepsForTests(deps: Partial<RatelimitFsDeps> | null): void;
 export interface RatelimitReadingsOptions {
     providers?: string[];
     targets?: string[];
@@ -29,4 +14,4 @@ export type RatelimitReadingsResult = {
     error: string;
     readings: [];
 };
-export declare function queryRatelimitReadings(options?: RatelimitReadingsOptions): RatelimitReadingsResult;
+export declare function queryRatelimitReadings(options?: RatelimitReadingsOptions): Promise<RatelimitReadingsResult>;

package/examples/book-team.lmctl

@@ -1,18 +1,22 @@
 # Book Team
 
-# Use this team for long-form writing projects. Lead keeps the outline and
-# acceptance criteria current, then coordinates drafting, editing, and factual
-# checks. Keep chapter plans and decisions in durable-memory/ so refreshed
-# sessions can recover the book state.
-# Suggested flow:
-#   lmctl chat book-team.lmctl Lead "Draft chapter 1 from durable-memory/outline.md"
+# Use this team for long-form writing projects. A suggested way to USE it: keep
+# the outline and acceptance criteria in durable-memory/, then prompt members in
+# turn for drafting, editing and factual checks. Keep chapter plans and
+# decisions in durable-memory/ so refreshed sessions can recover the book state.
+# You drive that sequence -- prompt each member:
+#   lmctl prompt book-team.lmctl Drafter "Draft chapter 1 from durable-memory/outline.md"
 #
-# lmctl chat is synchronous but does not always wait for a reply: when the
-# receiver is free the message is delivered and chat blocks for the reply; when
-# the receiver is BUSY the message is enqueued and chat returns immediately.
-# Both cases exit 0, so exit code alone cannot tell you a reply arrived.
-# Check with --json: status="ok" is a delivered reply (with replyText),
-# status="enqueued" means it was queued. lmctl status shows pending lanes.
+# ALIASES ARE NAMES, NOT CAPABILITIES. Every alias below is a label you chose.
+# lmctl gives none of them any power the others lack, and a seeded member is
+# told only to establish its session -- it does not know lmctl exists or that
+# the other members are there. The difference between them is how YOU use them.
+# To let one send prompts to others, paste that guidance into its session
+# yourself; give the same text to any other member and it can do it too.
+#
+# lmctl prompt blocks until the member replies. If the member is already running
+# a turn you get "<alias> is busy; wait and retry" -- nothing is held for you,
+# so retrying is the caller's job.
 #
 # For async, lmctl is foreground/background agnostic: wrap the same command in
 # your provider or host runtime's native background facility (e.g. Claude

package/examples/research-team.lmctl

@@ -1,18 +1,22 @@
 # Research Team
 
-# Use this team when the operator needs a researched answer with clear caveats.
-# Lead owns the final answer. Delegate independent passes to the researchers,
-# ask Critic to identify weak evidence or contradictions, then have Synthesizer
-# merge the strongest findings into a concise response.
-# Suggested flow:
-#   lmctl chat research-team.lmctl Lead "Research <question>"
+# Use this team when you need a researched answer with clear caveats. A
+# suggested way to USE it: ask each researcher for an independent pass, ask
+# Critic to find weak evidence or contradictions, then ask Synthesizer to merge
+# the strongest findings. You drive that sequence -- prompt each member:
+#   lmctl prompt research-team.lmctl Researcher1 "Research <question>"
+#   lmctl prompt research-team.lmctl Critic "Find weak evidence in <path>"
 #
-# lmctl chat is synchronous but does not always wait for a reply: when the
-# receiver is free the message is delivered and chat blocks for the reply; when
-# the receiver is BUSY the message is enqueued and chat returns immediately.
-# Both cases exit 0, so exit code alone cannot tell you a reply arrived.
-# Check with --json: status="ok" is a delivered reply (with replyText),
-# status="enqueued" means it was queued. lmctl status shows pending lanes.
+# ALIASES ARE NAMES, NOT CAPABILITIES. Every alias below is a label you chose.
+# lmctl gives none of them any power the others lack, and a seeded member is
+# told only to establish its session -- it does not know lmctl exists or that
+# the other members are there. The difference between them is how YOU use them.
+# To let one send prompts to others, paste that guidance into its session
+# yourself; give the same text to any other member and it can do it too.
+#
+# lmctl prompt blocks until the member replies. If the member is already running
+# a turn you get "<alias> is busy; wait and retry" -- nothing is held for you,
+# so retrying is the caller's job.
 #
 # For async, lmctl is foreground/background agnostic: wrap the same command in
 # your provider or host runtime's native background facility (e.g. Claude

package/examples/review-team.lmctl

@@ -1,18 +1,23 @@
 # Review Team
 
-# Use this team for implementation tasks that need independent review. Lead
-# sends implementation work to Author, asks Reviewer1 and Reviewer2 for separate
-# reviews, asks SecurityReviewer for trust-boundary concerns when relevant, and
-# routes findings back to Author before final signoff.
-# Suggested flow:
-#   lmctl chat review-team.lmctl Lead "Implement <task> and get review signoff"
+# Use this team for implementation tasks that need independent review. A
+# suggested way to USE it: send implementation work to Author, ask Reviewer1 and
+# Reviewer2 for separate reviews, ask SecurityReviewer about trust boundaries
+# when relevant, then send the findings back to Author before signoff.
+# You drive that sequence -- prompt each member yourself:
+#   lmctl prompt review-team.lmctl Author "Implement <task>"
+#   lmctl prompt review-team.lmctl Reviewer1 "Review the change in <path>"
 #
-# lmctl chat is synchronous but does not always wait for a reply: when the
-# receiver is free the message is delivered and chat blocks for the reply; when
-# the receiver is BUSY the message is enqueued and chat returns immediately.
-# Both cases exit 0, so exit code alone cannot tell you a reply arrived.
-# Check with --json: status="ok" is a delivered reply (with replyText),
-# status="enqueued" means it was queued. lmctl status shows pending lanes.
+# ALIASES ARE NAMES, NOT CAPABILITIES. Every alias below is a label you chose.
+# lmctl gives none of them any power the others lack, and a seeded member is
+# told only to establish its session -- it does not know lmctl exists or that
+# the other members are there. The difference between them is how YOU use them.
+# To let one send prompts to others, paste that guidance into its session
+# yourself; give the same text to any other member and it can do it too.
+#
+# lmctl prompt blocks until the member replies. If the member is already running
+# a turn you get "<alias> is busy; wait and retry" -- nothing is held for you,
+# so retrying is the caller's job.
 #
 # For async, lmctl is foreground/background agnostic: wrap the same command in
 # your provider or host runtime's native background facility (e.g. Claude

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmctl-ai/lmctl",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "A provider-agnostic control plane for teams of AI coding agents — across providers, with independent review and durable memory.",
   "type": "module",
   "homepage": "https://lmctl.com",
@@ -21,7 +21,6 @@
     "dist/**/*.d.ts",
     "dist/cli/schema.sql",
     "dist/config/",
-    "durable-memory/model_selection.md",
     "data/price-data.json",
     "data/price-aliases.json",
     "workflows/",
@@ -38,7 +37,7 @@
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "staging"
   },
   "dependencies": {},
   "optionalDependencies": {}