@lmctl-ai/lmctl 0.1.342 → 0.2.3

package/dist/cli/self-identity.d.ts

@@ -0,0 +1,25 @@
+import type { Dal } from '../db/index.js';
+export type SelfIdentityInference = {
+    ok: true;
+    identity: string;
+} | {
+    ok: false;
+    reason: 'unset' | 'not-found';
+};
+export type ResolvedSelfIdentity = {
+    ok: true;
+    identity: string;
+    source: 'session';
+} | {
+    ok: false;
+    reason: 'unset' | 'not-found';
+};
+export declare function manualInvocationMessage(command: string): string;
+export declare function unmatchedSelfSessionMessage(command: string): string;
+export declare function removedFromOptionMessage(command: string): string;
+export declare function extractSelfIdentityArg(args: string[], command: string): {
+    args: string[];
+    error?: string;
+};
+export declare function resolveSelfIdentity(env: NodeJS.ProcessEnv, dal: Pick<Dal, 'getRootTeam' | 'listRootTeams'>): ResolvedSelfIdentity;
+export declare function inferSelfIdentityFromEnv(env: NodeJS.ProcessEnv, dal: Pick<Dal, 'getRootTeam' | 'listRootTeams'>): SelfIdentityInference;

package/dist/cli/session-idle.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Session-idle availability override for delivery decisions.
+ *
+ * Operator (2026-07-22): *"also check the last update of session (from
+ * sessionid), if it is been idle for 10 minute, then it is available (this
+ * does not change terminal pid)."*
+ *
+ * THRESHOLD: 60 minutes, NOT the 10 initially requested. Do not "fix" this
+ * back to 10 without re-running the numbers below.
+ *
+ * A misfire is not benign: the reclaim force-steals a lease from a LIVE holder
+ * and starts a second turn on the same sessionid — the concurrent-resume abort
+ * `b85c5a1` exists to prevent. So the threshold has to clear real turn
+ * durations. Measured over completed chat turns, SPLIT BY OUTCOME — the split
+ * is the whole point, an unsplit number is misleading in both directions:
+ *
+ *   SELECT status, COUNT(*), SUM(CASE WHEN m>60 THEN 1 END), MAX(m)
+ *   FROM (SELECT status, (julianday(ended_at)-julianday(started_at))*1440 AS m
+ *         FROM tracked_invocation WHERE ended_at IS NOT NULL AND kind='chat')
+ *   GROUP BY status;
+ *
+ *   status='done'   n=2056   >60min: 0     longest: 51.8 min
+ *   status='error'  n=1054   >60min: 191   longest: 2709 min (~45h)
+ *   status='busy'   n=727    >60min: 0
+ *
+ * NO SUCCESSFULLY-COMPLETED CHAT TURN HAS EVER EXCEEDED 60 MINUTES. The longest
+ * was 51.8 min, so 60min sits ~16% above the worst observed healthy turn. Every
+ * one of the 191 turns past 60min ended in `error` — hung, aborted, abandoned:
+ * exactly the population this feature exists to reclaim.
+ *
+ * Beware the unsplit figure: "5.0% of all turns exceed 60min" is arithmetically
+ * true and materially misleading, because it counts already-failed turns as if
+ * they were healthy ones at risk of a wrongful steal. Exposure among healthy
+ * turns is zero in the observed record. (Turn DURATION is also only an upper
+ * bound — the trigger needs a >60min GAP BETWEEN WRITES, and a turn making tool
+ * calls keeps `modifiedAt` fresh.) 60min also still beats the 8h inflight TTL
+ * by ~8x, which is the actual complaint being solved.
+ *
+ * Re-run the query rather than trusting these figures; if you retune, split by
+ * status or the number will mislead you.
+ * See `backlog/DESIGN-session-idle-availability-scope.md`.
+ *
+ * THE PROBLEM. An `in-flight` lease taken by `lmctl prompt`/relay delivery keeps
+ * a receiver unreachable until the holder releases it or the 8h TTL expires.
+ * A hung turn therefore blocks that receiver for hours. Holder-pid liveness
+ * alone cannot detect this: the process is alive, it is just not progressing.
+ *
+ * THE SIGNAL. `SessionDetail.modifiedAt` — the provider's own session file
+ * mtime, i.e. real conversation activity. Deliberately NOT the chat/terminal
+ * heartbeat (`tracked_invocation.last_heartbeat_at`), which a timer in the
+ * holder process refreshes every 30s whether the turn is working OR wedged.
+ * The heartbeat distinguishes process-alive (already covered by the pid
+ * check), not stuck-vs-working, so it cannot detect a hung turn at all.
+ *
+ * FAILS CLOSED, ALWAYS. Every failure path returns `false` = "not idle, keep
+ * treating as busy". A false "available" lets two deliveries resume the same
+ * held session and collide; a false "busy" only means the message waits
+ * longer. Those costs are not symmetric, so the ambiguous cases (session not
+ * found, ambiguous provider, read error, unresolvable member) all resolve to
+ * busy. Same lesson as the reboot/pid-reuse work: never fail open on a
+ * liveness question.
+ *
+ * SCOPE. This is an ADDITIVE override consulted only at the synchronous
+ * chat delivery decision point (`chat-exec`) and only for the `in-flight`
+ * busy reason. `terminal-held` is NEVER overridden at any idle duration — see
+ * `isInflightButSessionIdle` below for why. It does not touch
+ * `getReceiverBusyState`, the terminal lock, or any pid.
+ */
+import type { Dal } from '../db/index.js';
+/**
+ * Threshold override, matching the existing staleness-window convention in
+ * this codebase (`LMCTL_INFLIGHT_TTL_MS`, `LMCTL_TERMINAL_LOCK_STALE_MS`):
+ * ignore unset/blank/non-finite/non-positive values and fall back to the
+ * 60-minute default.
+ */
+export declare function sessionIdleTimeoutMsFromEnv(env?: NodeJS.ProcessEnv): number;
+/**
+ * Has this receiver's underlying provider session been quiet for at least
+ * `thresholdMs`?
+ *
+ * `true` ONLY when the session was found and its last activity is at or past
+ * the threshold. Anything else — including every error — is `false`.
+ */
+export declare function isReceiverIdleTimedOut(dal: Pick<Dal, 'getRootTeam' | 'listRootTeams'>, teamfile: string, alias: string, thresholdMs?: number): Promise<boolean>;
+/**
+ * How long has this receiver's session been quiet, in ms? `null` when that
+ * cannot be established for ANY reason — the fail-closed signal, and also what
+ * the reclaim log reports so a steal can be judged after the fact.
+ */
+export declare function sessionIdleMs(dal: Pick<Dal, 'getRootTeam' | 'listRootTeams'>, teamfile: string, alias: string): Promise<number | null>;
+/**
+ * The delivery-side question, in one call: given the busy state we already
+ * computed synchronously, may we deliver anyway because the session is idle?
+ *
+ * SCOPE — `in-flight` ONLY. Operator (2026-07-22): *"terminal-held is alway
+ * regarded as busy, no matter how long idle is. session idle is only for
+ * non-terminal session, that is through lmctl prompt."*
+ *
+ * `terminal-held` is NEVER overridden, at any idle duration. That case is a
+ * human's interactive terminal — including a live codex/opencode TUI with a
+ * persistent process attached — and declaring it available on a timestamp
+ * would reintroduce exactly the concurrent-resume collision `b85c5a1`
+ * ("Protect held sessions from stale lease steals") was written to prevent.
+ * A quiet terminal is someone thinking, not an absent holder.
+ *
+ * `in-flight`, by contrast, is a lease taken by `lmctl prompt`/relay delivery:
+ * bounded, ephemeral, non-interactive work. A live pid there with no session
+ * file activity for the full window is most plausibly a hung turn, so it
+ * is a reasonable reclaim target — the same spirit as the existing dead-pid
+ * reclaim, adding long-idle-with-live-pid as a second trigger on the
+ * chat-invoked path only.
+ *
+ * See `backlog/DESIGN-session-idle-availability-scope.md`.
+ */
+export declare function isInflightButSessionIdle(dal: Pick<Dal, 'getRootTeam' | 'listRootTeams'>, busy: {
+    busy: boolean;
+    reason?: string;
+}, teamfile: string, alias: string, thresholdMs?: number): Promise<boolean>;

package/dist/cli/status.d.ts

@@ -0,0 +1,22 @@
+import { type CliIo } from './common.js';
+/**
+ * Path to the rolling intent log written by `status` (and, in future, by
+ * other verbs that want a breadcrumb trail). Plain JSONL — one event per
+ * line — so a troubleshooting bundle can ship it verbatim. Override via
+ * `LMCTL_INTENT_LOG` for tests / non-default homes.
+ */
+export declare function resolveIntentLogPath(): string;
+/**
+ * Append a single intent record to the rolling log. Failures are
+ * swallowed — the log is best-effort breadcrumbs, never load-bearing.
+ */
+export declare function appendIntent(record: {
+    verb: string;
+    args: ReadonlyArray<string>;
+    cwd?: string;
+    ts?: string;
+}): void;
+export declare function runStatus(args: string[], io: CliIo): Promise<number>;
+export declare function formatDuration(ms: number): string;
+export declare function formatAge(iso: string): string;
+export declare function shortIdentity(identity: string): string;

package/dist/cli/tail.d.ts

@@ -0,0 +1,18 @@
+import type { ConversationMessage } from '../providers/types.js';
+import { type CliIo } from './common.js';
+export declare function runTail(args: string[], io?: CliIo): Promise<number>;
+/** Plain renderer (no chalk/ANSI per design R3). Indents continuation
+ *  lines so multi-line messages remain visually grouped. */
+export declare function renderMessage(msg: ConversationMessage): string;
+export declare function applyMaxBytes(output: string, maxBytes: number): string;
+/**
+ * Same grammar as status.ts's parseStatusSince parser: a relative
+ * duration (<n>s|m|h|d) or an absolute ISO8601
+ * timestamp. Unlike status's version, `undefined` here means "no filter"
+ * (tail's existing default is unchanged), not a default window.
+ */
+export declare function parseTailSince(value: string | undefined): {
+    date: Date | undefined;
+} | {
+    error: string;
+};

package/dist/cli/target-resolver.d.ts

@@ -0,0 +1,139 @@
+import type { Dal } from '../db/index.js';
+/**
+ * Usage-class error for target-resolution failures (ported verbatim from
+ * lmctl0 resolve-target.ts:32-37). The filesystem-backed resolvers throw
+ * this; callers exit 2 on catch. The pure `classifyTarget` does NOT
+ * throw — it returns an `{ mode: 'error' }` discriminated variant.
+ */
+export declare class ChatTargetError extends Error {
+    constructor(message: string);
+}
+/**
+ * Valid alias grammar (letter-initial, then alphanumerics + `_`/`-`).
+ * Matches lmctl-next's team-config alias grammar and lmctl0
+ * resolve-target.ts:84 verbatim. Permissive enough for `researcher1`,
+ * `backend-fixer`; strict enough to reject `./foo.lmctl:Coder;ls`.
+ */
+export declare const ALIAS_RE: RegExp;
+/** True iff `arg` is a UUID- or `ses_`-shaped native session id.
+ *  (lmctl0 resolve-target.ts:86-88) */
+export declare function looksLikeSessionId(arg: string): boolean;
+/** Same alias validation surface as the colon parser. (lmctl0 :120-122) */
+export declare function isValidAlias(arg: string): boolean;
+/**
+ * Detect the `<teamfile>:<alias>` shape WITHOUT touching the disk.
+ * Returns the split parts if `arg` matches `<*.lmctl>:<alias>` with a
+ * valid alias, else null. Splits on the LAST `:` so a Windows-style
+ * absolute path like `C:\path\to\team.lmctl:Coder` still parses.
+ * (lmctl0 resolve-target.ts:103-113, ported verbatim.)
+ */
+export declare function parseTeamfileColonAlias(arg: string): {
+    teamfile: string;
+    alias: string;
+} | null;
+/** Concrete result of resolving `<teamfile> <alias>` (or the colon
+ *  shorthand) against a teamfile on disk. Mirrors lmctl0's `ResolvedMember`
+ *  shape (`session` → `sessionid`). */
+export interface ResolvedMember {
+    /** Absolute path to the teamfile that contained the alias. */
+    teamfile: string;
+    /** Canonical alias casing as recorded in the teamfile. */
+    alias: string;
+    provider: string;
+    sessionid: string;
+    sessiondir: string;
+    /** True when the concrete provider turn is a Lead session. */
+    isLead: boolean;
+    /** Model override from the concrete member line, if set. */
+    model?: string;
+    /** Effort / variant override from the concrete member line, if set. */
+    effort?: string;
+}
+/**
+ * Resolve `<teamfile>:<alias>` / `<teamfile> <alias>` against a real
+ * teamfile and return the member's session coordinates. Throws
+ * `ChatTargetError` on every usage failure (caller exits 2). Adapted
+ * from lmctl0 resolve-target.ts:163-225: team-config import swapped, the
+ * lmctl-next `TeamConfig.parseErrors` surface is honored (the copied
+ * parser reports parse failures as a field, not by throwing — mirror
+ * `src/cli/chat.ts:111`), and `member.session`/`member.sessiondir` are
+ * optional in lmctl-next's `MemberConfig`.
+ */
+export declare function resolveTeamMember(teamfileArg: string, aliasArg: string, dal?: Pick<Dal, 'getRootTeam' | 'listRootTeams'>): ResolvedMember;
+/**
+ * Smart-target dispatch for sessionid-scoped commands. Accepts the same
+ * three input shapes the verbs advertise. Throws `ChatTargetError` on
+ * usage failure. Ported from lmctl0 resolve-target.ts:249-276 (import
+ * adapted via `resolveTeamMember` above).
+ */
+export declare function resolveSessionTarget(command: string, target: string, alias: string | undefined): {
+    sessionid: string;
+    providerOverride?: string;
+};
+/** Per-verb acceptance rules (preserve lmctl0's per-verb behavior). */
+export interface VerbCaps {
+    /** Verb name, used verbatim in error messages. */
+    name: string;
+    /** A bare `<path>.lmctl` (no alias) is meaningful for this verb
+     *  (e.g. `info` team rollup). When false a bare teamfile is a usage
+     *  error (terminal/chat/tail require an alias). */
+    allowsBareTeamfile: boolean;
+    /** A bare `<sessionid>` (AI-team raw) is accepted (tail/info/chat).
+     *  `terminal` is teamfile-only (lmctl0 terminal-cmd.ts:64-69). */
+    supportsRaw: boolean;
+}
+/** The classifier's input — the verb's already-split positionals + the
+ *  managed/legacy flags. No disk state is consulted. */
+export interface TargetInput {
+    /** First positional (teamfile / teamfile:alias / sessionid), if any. */
+    target?: string;
+    /** Second positional (the two-positional `<teamfile> <alias>` form). */
+    alias?: string;
+    flags: {
+        /** Managed selectors (NET-NEW vs lmctl0). */
+        run?: string;
+        project?: string;
+        workflow?: string;
+        /** Legacy raw form back-compat (lmctl0 `--session`/`--provider`). */
+        session?: string;
+        provider?: string;
+    };
+}
+export type ClassifiedTarget = {
+    mode: 'managed';
+    run?: string;
+    project?: string;
+    workflow?: string;
+} | {
+    mode: 'ai-team';
+    teamfile: string;
+    alias?: string;
+} | {
+    mode: 'ai-team-raw';
+    sessionid: string;
+    provider?: string;
+} | {
+    mode: 'error';
+    message: string;
+};
+/**
+ * Classify `(flags, target?, alias?)` into exactly one of the 3 modes,
+ * per design §0.1 precedence (verbatim):
+ *
+ *   1. managed flag (`--run`/`--project`/`--workflow`) present → MANAGED,
+ *      mutually exclusive with a positional target (both ⇒ error).
+ *   2. positional target present:
+ *      2a. parseTeamfileColonAlias matches            → AI-TEAM
+ *      2b. target ends ".lmctl":
+ *           - second positional alias present         → AI-TEAM
+ *           - no alias, verb allows bare-teamfile      → AI-TEAM (rollup)
+ *           - no alias, verb requires alias            → error
+ *      2c. looksLikeSessionId & verb.supportsRaw       → AI-TEAM RAW
+ *           (else error: bare sessionid unsupported)
+ *      2d. none of the above                           → error (can't infer)
+ *   3. no positional, legacy --session set             → AI-TEAM RAW
+ *   4. nothing                                         → error (usage)
+ *
+ * Pure: no I/O, deterministic, never throws.
+ */
+export declare function classifyTarget(verb: VerbCaps, input: TargetInput): ClassifiedTarget;

package/dist/cli/team-status.d.ts

@@ -0,0 +1,91 @@
+import type { Dal } from '../db/index.js';
+import type { SessionLimitState } from '../providers/session-limit.js';
+import type { SessionDetail } from '../providers/types.js';
+import { type CliIo } from './common.js';
+export declare function formatTokens(n: number): string;
+export interface GitWorkingStatus {
+    uncommittedTracked: number | null;
+    untracked: number | null;
+}
+export type GitProgress = {
+    kind: 'unavailable';
+    teamDir: string;
+    reason: 'no-repo' | 'no-commits';
+} | {
+    kind: 'repo';
+    teamDir: string;
+    since: Date;
+    commits: Array<{
+        ref: string;
+        timestamp: Date;
+    }>;
+    working: GitWorkingStatus;
+};
+export interface MemberLiveness {
+    state: 'idle' | 'busy';
+    reason: 'terminal-held' | 'in-flight' | null;
+    inFlight: {
+        senderTeamfile: string;
+        senderAlias: string;
+        startedAt: string;
+        activeCount: number;
+        holderPid: number | null;
+    } | null;
+    terminalLock: {
+        startedAt: string;
+        lastHeartbeat: string;
+        holderPid: number;
+        holderHost: string;
+    } | null;
+    terminalInvocation: {
+        id: number;
+        startedAt: string;
+        lastHeartbeat: string | null;
+        holderPid: number | null;
+        holderHost: string | null;
+    } | null;
+    reclaimable: {
+        source: 'terminal-lock' | 'terminal-invocation' | 'in-flight';
+        holderPid: number | null;
+        holderHost: string | null;
+        reason: 'dead-pid' | 'stale';
+    } | null;
+}
+export interface TeamHealthTarget {
+    teamfile: string;
+    alias: string;
+    reportPath: string;
+    provider: string;
+    /** Null for an unseeded member (planned but never seeded) -- the roster
+     *  keeps the entry so `status <teamfile>` shows it explicitly as
+     *  not-seeded; only session probing is gated on a sessionid existing. */
+    sessionid: string | null;
+    /** The teamfile's DECLARED model= for this member -- what was asked for,
+     *  read straight from config with no live probe. Distinct from (and can
+     *  disagree with) the OBSERVED model a live session probe reports, which
+     *  is what the provider actually used -- real incident, 2026-09-29
+     *  (math.lmctl differential test): agy/codex sessions running on models
+     *  their teamfiles do not declare. Null when the member has no model=. */
+    model: string | null;
+}
+/** Task #232: the most recent tracked_invocation for this target that
+ * actually recorded a config-drop -- `ORDER BY started_at DESC LIMIT 1`
+ * scoped to rows where config_warnings is set, so a later CLEAN turn
+ * doesn't shadow an earlier drop the operator still needs to see, and a
+ * config-drop from days ago doesn't look like it just happened. */
+export declare function latestConfigWarnings(io: CliIo, target: {
+    teamfile: string;
+    alias: string;
+}): Promise<string[] | undefined>;
+export declare function collectHealthTargets(teamfileArg: string, dal: Dal, seen: Set<string>, prefix: string[]): TeamHealthTarget[];
+export declare function loadTeamLiveness(io: CliIo, targets: TeamHealthTarget[]): Promise<Map<string, MemberLiveness>>;
+export declare function memberKey(teamfile: string, alias: string): string;
+export declare function idleLiveness(reclaimable?: MemberLiveness['reclaimable']): MemberLiveness;
+export declare function livenessLabel(value: MemberLiveness): string;
+export declare function formatSessionLimitReset(value: SessionLimitState): string;
+export declare function formatKnownNumber(value: number | undefined | null): string;
+export declare function formatProviderRollupNumber(value: number | null | undefined | 'n/a'): string;
+export declare function formatOptionalProviderNumber(value: number | undefined, loaded: boolean, format?: (value: number) => string): string;
+export declare function readGitProgress(teamfile: string): GitProgress;
+export declare function countMessagesSince(detail: SessionDetail, since: Date): number;
+export declare function cumulativeSessionTokens(detail: SessionDetail | null): number | null;

package/dist/cli/teamfile-compat.d.ts

@@ -0,0 +1,71 @@
+import { type AgyModelsRunResult, type CodexModelsRunResult } from '../providers/config/model-selection-lint.js';
+import type { CatalogSnapshot } from '../providers/pricing.js';
+import { type OpenCodeAcpConfigProbeOptions, type OpenCodeAcpConfigProbeResult } from '../providers/transports/acp.js';
+import type { ProviderName } from '../providers/types.js';
+import type { Dal, RootTeamInput, RootTeamRow } from '../db/index.js';
+export declare const GEMINI_PROVIDER_NOTICE = "notice: member \"%s\" uses provider=gemini \u2014 the Gemini CLI requires an API/enterprise Google account; personal Google subscriptions should use provider=agy (Antigravity).";
+export interface TeamfileCliIo {
+    stdout: {
+        write(chunk: string): unknown;
+    };
+    stderr: {
+        write(chunk: string): unknown;
+    };
+    dal?: Dal;
+    env?: NodeJS.ProcessEnv;
+}
+type SeedFn = (opts: {
+    provider: ProviderName;
+    cwd: string;
+    model?: string;
+    effort?: string;
+    prompt?: string;
+}) => Promise<{
+    sessionId?: string;
+    error?: string;
+    warnings?: string[];
+}>;
+type OpenCodeConfigProbeFn = (opts: OpenCodeAcpConfigProbeOptions) => Promise<OpenCodeAcpConfigProbeResult>;
+interface LintSessiondirFsOps {
+    existsSync(path: string): boolean;
+    statSync(path: string): {
+        isDirectory(): boolean;
+    };
+    accessSync(path: string, mode: number): unknown;
+}
+/** Test-only seam: inject a fixed lmprice catalog snapshot so lint/seed
+ * catalog-resolution tests never touch the network/cache/bundled data.
+ * `null` restores the real loader (loadCatalogSnapshot). */
+export declare function _setCatalogSnapshotForTests(snapshot: CatalogSnapshot | null): void;
+/** Test-only seam: inject a fake `agy models` result so lint/seed tests
+ * don't depend on the real `agy` binary being installed/authenticated (or
+ * on its live catalog staying stable). `null` restores the real command. */
+export declare function _setAgyModelsRunnerForTests(fn: (() => AgyModelsRunResult) | null): void;
+/** Test-only seam: inject a fake `codex debug models` result, same
+ * rationale as `_setAgyModelsRunnerForTests` above. */
+export declare function _setCodexModelsRunnerForTests(fn: (() => CodexModelsRunResult) | null): void;
+export declare function _setTeamfileSeedForTests(fn: SeedFn | null): void;
+export declare function _setLintSessiondirFsOpsForTests(ops: Partial<LintSessiondirFsOps> | null): void;
+export declare function _setLintOpenCodeConfigProbeForTests(fn: OpenCodeConfigProbeFn | null): void;
+export declare function runLint(args: string[], io?: TeamfileCliIo): Promise<number>;
+export declare function runSeed(args: string[], io?: TeamfileCliIo): Promise<number>;
+export interface RootTeamRegistrationInput {
+    teamfilePath: string;
+    name: string | null;
+    rawText: string;
+    now: string;
+}
+export declare function sha256Text(text: string): string;
+export declare function buildRootTeamRegistrationRow(existing: RootTeamRow | null, input: RootTeamRegistrationInput): RootTeamInput;
+export declare function registerRootTeam(dal: Dal, input: RootTeamRegistrationInput): RootTeamInput;
+/**
+ * Shared member-spec validation for surfaces that build _MEMBER_ lines from
+ * user input (`lmctl plan --member`, the plan wizard): alias shape + known
+ * provider name. Returns an error message, or undefined when the spec is
+ * valid.
+ */
+export declare function validateMemberSpec(spec: {
+    alias: string;
+    provider: string;
+}): string | undefined;
+export {};

package/dist/cli/teamfile-store.d.ts

@@ -0,0 +1,18 @@
+import type { Dal } from '../db/index.js';
+import { type TeamConfig } from '../providers/config/team-config.js';
+type TeamfileLookupDal = Pick<Dal, 'getRootTeam' | 'listRootTeams'>;
+type TeamfileStoreDal = Pick<Dal, 'getRootTeam' | 'listRootTeams' | 'upsertRootTeam'>;
+type TeamfileRegistrationWarning = (warning: string) => void;
+export declare function canonicalTeamfileKey(teamfile: string, dal?: TeamfileLookupDal): string;
+export declare function parseStoredTeamConfig(rawText: string, teamfileKey: string): TeamConfig;
+export declare function readTeamConfigFromStore(teamfile: string, dal?: TeamfileStoreDal | Pick<Dal, 'getRootTeam'>, warn?: TeamfileRegistrationWarning): TeamConfig;
+/**
+ * Registration-time ownership guard for provider sessions.
+ *
+ * A session id identifies one concrete provider conversation, so two live
+ * registered teamfiles must never claim it as different members. Registry
+ * rows whose files have been renamed/deleted are inert and deliberately
+ * excluded: re-seeding the same team at its new path must remain possible.
+ */
+export declare function assertNoForeignSessionidOwnership(dal: TeamfileLookupDal, key: string, config: TeamConfig): void;
+export {};

package/dist/cli/teamfile-template.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Teamfile construction primitives for `lmctl plan`:
+ * member-spec parsing (`Alias:provider[:model]`), the 1/2/3 member patterns,
+ * the canonical teamfile renderer, and the session-key stripper used by
+ * `--from` template mode. Kept free of I/O so both the flags path and the
+ * wizard render byte-identical documents.
+ */
+export interface MemberSpec {
+    alias: string;
+    provider: string;
+    model?: string;
+}
+/** Named and numeric patterns → member alias lists. Pattern 1 is Lead-only. */
+export declare const MEMBER_PATTERNS: Record<string, string[]>;
+export declare const PATTERN_USAGE = "1|2|3|lead|lead-reviewer|lead-coder-reviewer";
+export declare function resolvePattern(value: string): string[] | undefined;
+/**
+ * Parse one `--member Alias:provider[:model]` value. Validation matches the
+ * shared member-spec rules (validateMemberSpec in teamfile-compat.ts).
+ */
+export declare function parseMemberSpec(raw: string): {
+    spec?: MemberSpec;
+    error?: string;
+};
+export declare function renderMemberLine(member: MemberSpec): string;
+/**
+ * Render the canonical starter teamfile. The header carries the no-timeout
+ * rule INLINE (not only as a skill-doc link) so a new Lead's first read
+ * already has it; the wording is association-first on purpose (a diagnosis
+ * to reach for after a dispatch dies, not a prohibition stated in advance).
+ * Session ids are never generated here — that is `lmctl seed`'s job.
+ */
+export declare function renderTeamfile(opts: {
+    teamName: string;
+    members: MemberSpec[];
+}): string;
+/** Strip sessionid= and sessiondir= from _MEMBER_ lines (template mode). */
+export declare function stripSessionKeys(text: string): string;
+/** Read the member roster back out of teamfile text (reporting / --json). */
+export declare function parseMembersFromTeamfile(text: string): MemberSpec[];

package/dist/cli/template-env.d.ts

@@ -0,0 +1,25 @@
+export interface TemplateEnvContext {
+    workdir: string;
+    teamfile: string;
+    date: string;
+}
+declare const TEMPLATE_ENV_REGISTRY: {
+    workdir: (ctx: TemplateEnvContext) => string;
+    teamfile: (ctx: TemplateEnvContext) => string;
+    teamname: (ctx: TemplateEnvContext) => string;
+    home: () => string;
+    date: (ctx: TemplateEnvContext) => string;
+};
+export type TemplateEnvName = keyof typeof TEMPLATE_ENV_REGISTRY;
+export interface TemplateEnvSubstitution {
+    text: string;
+    unknownNames: string[];
+}
+export declare function substituteTemplateEnv(text: string, ctx: TemplateEnvContext): TemplateEnvSubstitution;
+export declare function templateEnvContext(input: {
+    workdir: string;
+    teamfile: string;
+    date: Date;
+}): TemplateEnvContext;
+export declare function formatTemplateDate(date: Date): string;
+export {};

package/dist/cli/terminal-lock.d.ts

@@ -0,0 +1,25 @@
+import type { TerminalLockRecord } from '../db/terminal-lock.js';
+export type TerminalLockLiveness = {
+    live: true;
+    reason: 'local-pid-alive' | 'remote-heartbeat-fresh';
+} | {
+    live: false;
+    reason: 'dead-pid' | 'stale-heartbeat';
+};
+export declare function createTerminalLockRecord(input: {
+    teamfile: string;
+    alias: string;
+    now?: Date;
+    pid?: number;
+    host?: string;
+    ips?: string[];
+}): TerminalLockRecord;
+export declare function terminalLockHeartbeatMsFromEnv(env?: NodeJS.ProcessEnv): number;
+export declare function terminalLockStaleMsFromEnv(env?: NodeJS.ProcessEnv): number;
+export declare function evaluateTerminalLockLiveness(lock: TerminalLockRecord, opts?: {
+    now?: Date;
+    localHost?: string;
+    staleMs?: number;
+    isProcessAlive?: (pid: number) => boolean;
+}): TerminalLockLiveness;
+export declare function terminalHeldMessage(lock: TerminalLockRecord): string;

package/dist/cli/terminal.d.ts

@@ -0,0 +1,23 @@
+import { type CliIo } from './common.js';
+/** Operator-decided non-blocking guide/trip-wire (design §4.3 / §10.A).
+ *  NEVER gates or auto-acts — informational only. */
+export declare const SIZE_WARN_EST_TOKENS = 200000;
+export declare function runTerminal(args: string[], io: CliIo): Promise<number>;
+/**
+ * Local, provider-agnostic token ESTIMATE (design §4.2). Σ message
+ * content chars (preferred) ÷ 4, else file bytes ÷ 4. NEVER a provider
+ * round-trip / `tokens` call. The /4 ("~4 chars/token") is the
+ * widely-cited BPE midpoint; this is a trip-wire, not a billing meter
+ * (bias documented in --help).
+ */
+export declare function estimateTokens(detail: {
+    messages?: Array<{
+        content?: string;
+    }>;
+    filePath?: string;
+} | null): {
+    chars: number;
+    est: number;
+    messages: number | null;
+    bytes: number | null;
+};

package/dist/cli/time-filter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared `--since`/`--until` grammar: a relative duration (`<n>s|m|h|d`,
+ * e.g. `24h`) or an absolute ISO8601 timestamp. One parser so `tail` and
+ * `session` (and anything else that grows a time filter) can't drift.
+ */
+export declare function parseSinceUntil(value: string | undefined, flagName: string): {
+    date: Date | undefined;
+} | {
+    error: string;
+};

package/dist/cli/update-notifier.d.ts

@@ -0,0 +1,11 @@
+import type { CliIo } from './common.js';
+interface UpdateNotifierDeps {
+    now?: () => number;
+    currentVersion?: () => string;
+    cachePath?: string;
+    fetchLatest?: () => Promise<string>;
+}
+export declare function compareSemver(a: string, b: string): number;
+export declare function shouldSkipUpdateNotifier(args: string[], io: CliIo): boolean;
+export declare function maybeNotifyUpdate(io: CliIo, args?: string[], deps?: UpdateNotifierDeps): Promise<void>;
+export {};

package/dist/cli/version-util.d.ts

@@ -0,0 +1,2 @@
+/** Resolve the package.json version of lmctl-next, with a safe fallback. */
+export declare function readLmctlNextVersion(): string;

package/dist/config/seed_templates.d.ts

@@ -0,0 +1 @@
+export declare const DURABLE_MEMORY_INSTRUCTION_BLOCK = "---\n\n# Durable memory \u2014 how to use it\n\nThis project has a durable-memory directory at `<project>/durable-memory/` (or DB-backed if durable_memory_mode='db' \u2014 same logical surface).\n\nON EVERY NEW TASK:\n1. Read `durable-memory/index.md` first. It lists project knowledge by topic.\n2. Pull only the chapters relevant to your current task. Don't load everything.\n3. If you learn something durable (a project convention, a decision, a fact worth preserving), write it back: create/update `<project>/durable-memory/<descriptive-name>.md` with YAML frontmatter (name/description/type) + body. The engine syncs the write automatically.\n\nDon't dump all of durable-memory into your context. The pattern is index-first, chapter-on-demand.";