@lmctl-ai/lmctl 0.2.10 → 0.2.12

package/dist/providers/adapter.d.ts

@@ -162,8 +162,14 @@ export interface TurnResult {
     /** "ok" (default/omitted) = normal completion.
      *  "stalled" = idle timeout fired — provider went silent for the
      *  configured duration. The child process is still alive. The text
-     *  field contains whatever was produced before the stall. */
-    status?: "ok" | "stalled";
+     *  field contains whatever was produced before the stall.
+     *  "empty" = ACP transports only (see transport-wrappers.ts's
+     *  emptyTurnStatus): the provider's own protocol reported a normal
+     *  completion, but produced no text and no observed activity -- almost
+     *  always an upstream failure (rate limit, quota, auth) that the
+     *  provider's ACP layer swallowed instead of surfacing as an error.
+     *  Never set for non-ACP transports (stream-json, codex-app-server). */
+    status?: "ok" | "stalled" | "empty";
     /** When status === "stalled": how long the provider was idle (ms). */
     stalledAfterMs?: number;
     /** Human-readable strings when this turn's provider silently dropped a

package/dist/providers/bundle.d.ts

@@ -70,6 +70,12 @@ export interface BundleTurnResult {
      * provider configuration is applied once at open, not per spawn.
      */
     warnings?: string[];
+    /**
+     * ACP bundle sessions only (see AcpOutputProcessorResult.sawActivity) --
+     * whether this turn saw any real agent activity, as opposed to a clean
+     * but empty completion. Omitted for non-ACP bundle implementations.
+     */
+    sawActivity?: boolean;
 }
 export interface BundleSession {
     /** Provider key this session serves (e.g. "opencode"). */

package/dist/providers/index.d.ts

@@ -124,7 +124,7 @@ export interface ChatResult {
     durationMs: number;
     stopReason?: string;
     numTurns?: number;
-    status?: "ok" | "stalled";
+    status?: "ok" | "stalled" | "empty";
     stalledAfterMs?: number;
     /** Human-readable strings when this turn's provider silently dropped a
      * declared model=/effort= (task #232). Omitted when nothing was dropped. */

package/dist/providers/parsers/acp.d.ts

@@ -9,11 +9,19 @@ export interface AcpResult {
      * rejection the turn proceeded past anyway. Omitted when nothing was
      * dropped. */
     warnings?: string[];
+    /** See AcpOutputProcessorResult.sawActivity. */
+    sawActivity: boolean;
 }
 export interface AcpOutputProcessorResult {
     result: string;
     sessionId: string;
     stopReason: string;
+    /** Whether THIS turn saw any real agent activity (message/thought text,
+     *  a tool call or its result, a plan) -- as opposed to pure session
+     *  bookkeeping (session_info_update, current_mode_update,
+     *  config_option_update, available_commands_update, usage_update,
+     *  user_message_chunk) or nothing at all. See ACP_MEANINGFUL_UPDATE_KINDS. */
+    sawActivity: boolean;
 }
 export interface AcpOutputProcessor {
     setSessionId(sessionId: string): void;
@@ -32,6 +40,22 @@ export interface AcpOutputProcessor {
 export declare function isolateGeminiLatestAgentMessage(text: string): string;
 export declare function acpSessionIdFromResponse(response: Record<string, unknown>, fallback?: string): string;
 export declare function acpStopReasonFromResponse(response: Record<string, unknown>): string;
+/**
+ * `sessionUpdate` kinds that represent real agent work, grounded in actual
+ * production ACP traffic (checked against a full day's ~/.lmctl/debug-*.log,
+ * 2026-09-29) plus the ACP spec's own "plan" kind (Zed and friends). Every
+ * OTHER kind seen in that traffic -- session_info_update, current_mode_
+ * update, config_option_update, available_commands_update, usage_update,
+ * user_message_chunk (an echo of the user's OWN input, not agent work) -- is
+ * pure session bookkeeping, and any future/unrecognized kind is treated the
+ * same conservative way: NOT activity. This is a whitelist, not a blacklist,
+ * on purpose -- the failure mode of missing a real silent-failure turn is
+ * bad, but the failure mode of flagging a legitimate turn as broken is
+ * worse (it would fire fleet-wide, for every provider, on every genuinely
+ * empty-but-fine turn), so activity only counts when there is positive
+ * evidence of it.
+ */
+export declare const ACP_MEANINGFUL_UPDATE_KINDS: Set<string>;
 export declare function createAcpOutputProcessor(opts?: {
     tool?: string;
     onDelta?: (text: string) => void;

package/dist/providers/transports/acp.d.ts

@@ -155,6 +155,8 @@ export interface AcpSessionTurnResult {
      * profile's sessionSetup runs once at open, not per spawn.
      */
     warnings?: string[];
+    /** See AcpOutputProcessorResult.sawActivity. */
+    sawActivity: boolean;
 }
 /**
  * An open ACP bundle session: one provider process serving many prompts.

package/dist/script/lmscript.d.ts

@@ -413,7 +413,29 @@ export declare class Environment {
     readonly id: number;
     private readonly values;
     readonly parent?: Environment;
-    constructor(parent?: Environment);
+    /**
+     * True only for the environment a function CALL creates (invokeNamed's
+     * fnEnv) -- never for a plain nested block (if/while/for body). Marks
+     * where `set()`'s upward search for an EXISTING binding must stop.
+     *
+     * Real incident, 2026-09-29 (operator finding): `fn f(x) { outer = 1; }`
+     * silently mutated an outer/global `outer` whenever one already existed,
+     * purely because the name collided -- "dynamic scoping with implicit
+     * global mutation," math's words, and no `local`/`my`/`let` to defend
+     * against it (a *working* `let` already existed in the grammar, but was
+     * entirely undocumented, which is why it went unnoticed). A name that
+     * happens to already exist as a global is not evidence the function
+     * meant to reference it. `set()` now treats a name not yet bound WITHIN
+     * the current function's own scope chain as a fresh function-local,
+     * matching every language cited for comparison (Perl's `my`, JS's
+     * function/`let` scoping, Python's function-scope-by-default) --
+     * without this flag, an if/while/for block's `set()` calls would ALSO
+     * stop at their own Environment, breaking ordinary control flow (e.g.
+     * `if (true) { x = 2; }` updating a `x` declared earlier in the SAME
+     * function must keep working).
+     */
+    readonly isFunctionBoundary: boolean;
+    constructor(parent?: Environment, isFunctionBoundary?: boolean);
     resolveBinding(name: string): {
         env: Environment;
         name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmctl-ai/lmctl",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "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",