@narumitw/pi-subagents 3.3.2 → 3.4.0

package/src/rpc-line-decoder.ts

@@ -0,0 +1,61 @@
+const MAX_EVENT_LINE_BYTES = 256 * 1024;
+
+/** Frame RPC output by LF bytes before strict UTF-8 decoding, so one bad line cannot lose later events. */
+export class JsonLineDecoder {
+  private fragments: Buffer[] = [];
+  private bytes = 0;
+  private dropping = false;
+  private readonly decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+
+  constructor(
+    private readonly onValue: (value: unknown) => void,
+    private readonly onMalformed: () => void,
+  ) {}
+
+  push(chunk: Buffer | string): void {
+    const data = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    let offset = 0;
+    while (offset < data.length) {
+      const newline = data.indexOf(0x0a, offset);
+      const end = newline < 0 ? data.length : newline;
+      const fragment = data.subarray(offset, end);
+      if (!this.dropping) {
+        if (this.bytes + fragment.length > MAX_EVENT_LINE_BYTES) {
+          this.clear();
+          this.dropping = true;
+          this.onMalformed();
+        } else if (fragment.length > 0) {
+          // Copy only the bounded partial frame, not its possibly much larger source chunk.
+          this.fragments.push(Buffer.from(fragment));
+          this.bytes += fragment.length;
+        }
+      }
+      if (newline < 0) return;
+      this.complete();
+      offset = newline + 1;
+    }
+  }
+
+  finish(): void {
+    this.complete();
+  }
+
+  private complete(): void {
+    const dropping = this.dropping;
+    const line = Buffer.concat(this.fragments, this.bytes);
+    this.clear();
+    this.dropping = false;
+    if (dropping || line.length === 0) return;
+    try {
+      const text = this.decoder.decode(line);
+      if (text.trim()) this.onValue(JSON.parse(text));
+    } catch {
+      this.onMalformed();
+    }
+  }
+
+  private clear(): void {
+    this.fragments = [];
+    this.bytes = 0;
+  }
+}

package/src/runtime.ts

@@ -29,7 +29,9 @@ interface InternalJob extends JobSummary {
   resolveTerminal: () => void;
   task?: Promise<void>;
   taskText: string;
+  modelOverrides: SubagentModelOverrides;
   thinkingLevel: SubagentThinkingLevel;
+  defaultThinkingLevel: SubagentThinkingLevel;
   stopRequest?: StopRequest;
   control?: ChildControl;
   controlReady: Promise<ChildControl>;
@@ -39,7 +41,6 @@ interface InternalJob extends JobSummary {
   result?: string;
   error?: string;
   limitations: string[];
-  deliverySent: boolean;
   generation: number;
 }
 
@@ -48,11 +49,18 @@ export interface RuntimeDependencies {
   now?: () => number;
 }
 
-export interface ActiveJobDisplay {
+/** Resolved IDs that differ from the effective parent pair captured at spawn. */
+export interface SubagentModelOverrides {
+  provider?: string;
+  model?: string;
+}
+
+export interface ActiveJobDisplay extends SubagentModelOverrides {
   jobId: string;
   task: string;
   state: Extract<SubagentJobState, "queued" | "running">;
   thinkingLevel: SubagentThinkingLevel;
+  defaultThinkingLevel: SubagentThinkingLevel;
   elapsedMs: number;
   timeout?: number;
   tools: string[];
@@ -64,8 +72,11 @@ export interface StartJobInput {
   skills: string[];
   extensions: ExtensionAttachment[];
   toolSources: Record<string, string[]>;
+  provider: string;
   model: string;
+  modelOverrides?: SubagentModelOverrides;
   thinkingLevel: SubagentThinkingLevel;
+  defaultThinkingLevel: SubagentThinkingLevel;
   cwd: string;
   timeout?: number;
   projectTrusted: boolean;
@@ -77,7 +88,6 @@ export class SubagentRuntime {
   private readonly now: () => number;
   private counter = 0;
   private generation = 0;
-  private deliveryEnabled = false;
   private sessionActive = false;
   private omittedJobs = 0;
   private readonly jobListeners = new Set<() => void>();
@@ -96,7 +106,6 @@ export class SubagentRuntime {
     this.generation++;
     this.jobs.clear();
     this.omittedJobs = 0;
-    this.deliveryEnabled = true;
     this.sessionActive = true;
     this.notifyJobsChanged();
   }
@@ -119,7 +128,9 @@ export class SubagentRuntime {
         jobId: job.jobId,
         task: job.taskText,
         state: job.state,
+        ...job.modelOverrides,
         thinkingLevel: job.thinkingLevel,
+        defaultThinkingLevel: job.defaultThinkingLevel,
         elapsedMs: Math.max(0, now - (job.startedAt ?? job.createdAt)),
         ...(job.timeout !== undefined ? { timeout: job.timeout } : {}),
         tools: [...job.tools],
@@ -136,6 +147,7 @@ export class SubagentRuntime {
     if (active >= MAX_ACTIVE_JOBS) {
       throw new Error(`Active subagent job limit reached (${MAX_ACTIVE_JOBS}).`);
     }
+    const { provider, model } = input;
     const jobId = `job_${this.now().toString(36)}_${(++this.counter).toString(36)}`;
     const communication = this.broker.issueCredentials({
       jobId,
@@ -162,7 +174,9 @@ export class SubagentRuntime {
       controller,
       tools: effectiveTools,
       taskText: input.task,
+      modelOverrides: { ...input.modelOverrides },
       thinkingLevel: input.thinkingLevel,
+      defaultThinkingLevel: input.defaultThinkingLevel,
       terminal,
       resolveTerminal,
       controlReady,
@@ -170,7 +184,6 @@ export class SubagentRuntime {
       rejectControl,
       sendQueue: Promise.resolve(),
       limitations: [],
-      deliverySent: false,
       generation: this.generation,
     };
     this.jobs.set(jobId, job);
@@ -197,7 +210,8 @@ export class SubagentRuntime {
           toolSources: Object.fromEntries(
             Object.entries(input.toolSources).map(([tool, sources]) => [tool, [...sources]]),
           ),
-          model: input.model,
+          provider,
+          model,
           thinkingLevel: input.thinkingLevel,
           cwd: input.cwd,
           timeout: input.timeout,
@@ -355,7 +369,6 @@ export class SubagentRuntime {
 
   async shutdown(): Promise<void> {
     if (!this.sessionActive) return;
-    this.deliveryEnabled = false;
     this.sessionActive = false;
     const active = [...this.jobs.values()].filter((job) => !isTerminal(job.state));
     await Promise.allSettled(
@@ -414,8 +427,7 @@ export class SubagentRuntime {
   }
 
   private deliver(job: InternalJob): void {
-    if (!this.deliveryEnabled || job.deliverySent || job.generation !== this.generation) return;
-    job.deliverySent = true;
+    if (!this.sessionActive || job.generation !== this.generation) return;
     const payload = this.waitResult(job, false);
     try {
       this.pi.sendMessage(

package/src/settings.ts

@@ -11,8 +11,8 @@ export interface SubagentSettings {
 
 export const DEFAULT_SUBAGENT_SETTINGS: Readonly<SubagentSettings> = Object.freeze({
   showWidget: true,
-  showJobId: true,
-  showTools: true,
+  showJobId: false,
+  showTools: false,
   showTiming: true,
 });
 

package/src/subagents.ts

@@ -8,7 +8,7 @@ import {
   subagentSettingsPath,
 } from "./settings.js";
 import { registerSubagentTools, type SubagentToolsDependencies } from "./tools.js";
-import { createSubagentWidgetController } from "./widget.js";
+import { createSubagentWidgetController, type SubagentCyclePhase } from "./widget.js";
 
 export interface SubagentsDependencies extends SubagentToolsDependencies {
   settingsStore?: Pick<SubagentSettingsStore, "userPath" | "load" | "save" | "flush">;
@@ -24,9 +24,20 @@ export default function subagents(pi: ExtensionAPI, dependencies: SubagentsDepen
   let owner = new AbortController();
   let ready = false;
   let menuOpen = false;
+  let cyclePhase: SubagentCyclePhase = "idle";
   let settings: SubagentSettings = { ...DEFAULT_SUBAGENT_SETTINGS };
   const menuTasks = new Set<Promise<void>>();
-  const ownsSession = (ctx: ExtensionContext) => ctx.sessionManager === activeContext?.sessionManager;
+  const ownsSession = (ctx: ExtensionContext) =>
+    activeContext !== undefined && ctx.sessionManager === activeContext.sessionManager;
+
+  const joinCleanup = async (steps: (() => void | Promise<void>)[], errors: unknown[] = []): Promise<void> => {
+    const results = await Promise.allSettled(steps.map(async (step) => step()));
+    for (const result of results) {
+      if (result.status === "rejected") errors.push(result.reason);
+    }
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, "Subagents session cleanup failed");
+  };
 
   const openSettings = async (
     ctx: ExtensionCommandContext,
@@ -79,7 +90,7 @@ export default function subagents(pi: ExtensionAPI, dependencies: SubagentsDepen
       menuOpen = true;
       const generation = sessionGeneration;
       const signal = owner.signal;
-      const isCurrent = () => generation === sessionGeneration && ownsSession(ctx) && !signal.aborted;
+      const isCurrent = () => generation === sessionGeneration && !signal.aborted && ownsSession(ctx);
       const task = (async () => {
         if (route === "settings") {
           await openSettings(ctx, signal, isCurrent);
@@ -101,6 +112,7 @@ export default function subagents(pi: ExtensionAPI, dependencies: SubagentsDepen
             await tools.runtime.cancel(jobId);
           },
           showSettings: (actionSignal) => openSettings(ctx, actionSignal, isCurrent),
+          widget: widget.controls(ctx),
         });
       })();
       menuTasks.add(task);
@@ -118,24 +130,39 @@ export default function subagents(pi: ExtensionAPI, dependencies: SubagentsDepen
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    const previousContext = activeContext;
+    const generation = ++sessionGeneration;
+    ready = false;
+    menuOpen = false;
     owner.abort();
-    if (activeContext) widget.shutdown(activeContext);
     owner = new AbortController();
+    const signal = owner.signal;
     activeContext = ctx;
-    ready = false;
-    menuOpen = false;
-    const generation = ++sessionGeneration;
-    const isCurrent = () => generation === sessionGeneration && ownsSession(ctx) && !owner.signal.aborted;
-    // Stop old children and broker delivery before waiting for slow UI storage work.
-    await tools.startSession();
-    if (!isCurrent()) return;
-    await Promise.allSettled([...menuTasks]);
+    cyclePhase = ctx.signal === undefined ? "idle" : "running";
+    const isCurrent = () => generation === sessionGeneration && !signal.aborted && ownsSession(ctx);
+    const errors: unknown[] = [];
+    try {
+      if (previousContext) widget.shutdown(previousContext);
+    } catch (error) {
+      errors.push(error);
+    }
+    // A failed UI handoff must still stop old children, menus, and pending saves.
+    // Do not initialize another runtime or widget after that failure.
+    const failedHandoff = errors.length > 0;
+    await joinCleanup(
+      [
+        () => (failedHandoff ? tools.shutdown() : tools.startSession()),
+        ...[...menuTasks].map((task) => () => task),
+        ...(failedHandoff ? [() => store.flush()] : []),
+      ],
+      errors,
+    );
     if (!isCurrent()) return;
     const loaded = await store.load();
     if (!isCurrent()) return;
     settings = { ...loaded.settings };
+    widget.start(ctx, settings, cyclePhase);
     ready = true;
-    widget.start(ctx, settings);
     if (loaded.diagnostics.length > 0) {
       const message = sanitizeSubagentDisplayText(`Subagent settings: ${loaded.diagnostics.join(" ")}`);
       if (ctx.hasUI) ctx.ui.notify(message, "warning");
@@ -143,16 +170,81 @@ export default function subagents(pi: ExtensionAPI, dependencies: SubagentsDepen
     }
   });
 
-  pi.on("session_shutdown", async (_event, ctx) => {
+  pi.on("before_agent_start", (_event, ctx) => {
     if (!ownsSession(ctx)) return;
+    cyclePhase = "preparing";
+    if (ready) widget.preparing(ctx);
+  });
+  pi.on("session_before_compact", (event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    if (event.reason === "manual") {
+      cyclePhase = "maintenance";
+      if (ready) widget.maintenance(ctx);
+    } else {
+      if (cyclePhase !== "running") cyclePhase = "auto-preparing";
+      if (ready) widget.automaticCompaction(ctx);
+    }
+  });
+  pi.on("session_before_tree", (_event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    cyclePhase = "maintenance";
+    if (ready) widget.maintenance(ctx);
+  });
+  pi.on("input", (_event, ctx) => {
+    // Discard a canceled maintenance/preparation guard before a new idle prompt.
+    // Do not count input as a consumed user message.
+    if (!ownsSession(ctx) || !ctx.isIdle()) return;
+    cyclePhase = "idle";
+    if (ready) widget.clearCycle(ctx);
+  });
+  pi.on("agent_start", (_event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    cyclePhase = "running";
+    if (ready) widget.agentStarted(ctx);
+  });
+  pi.on("message_start", (event, ctx) => {
+    // Input submission is not consumption. Extension-generated user messages count too.
+    if (ready && ownsSession(ctx) && event.message.role === "user") widget.userMessage(ctx);
+  });
+  pi.on("turn_end", (event, ctx) => {
+    if (ready && ownsSession(ctx) && event.message.role === "assistant")
+      widget.turnEnded(ctx, event.message.stopReason);
+  });
+  pi.on("agent_settled", (event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    cyclePhase = "idle";
+    if (ready) widget.settled(ctx, event.aborted);
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    cyclePhase = "maintenance";
+    if (!ready) return;
     sessionGeneration++;
+    ready = false;
+    menuOpen = false;
     owner.abort();
+    owner = new AbortController();
+    widget.start(ctx, settings, cyclePhase);
+    ready = true;
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    if (!ownsSession(ctx)) return;
+    sessionGeneration++;
     ready = false;
     menuOpen = false;
     activeContext = undefined;
-    widget.shutdown(ctx);
-    const results = await Promise.allSettled([tools.shutdown(), ...menuTasks, store.flush()]);
-    const failed = results.find((result) => result.status === "rejected");
-    if (failed?.status === "rejected") throw failed.reason;
+    cyclePhase = "idle";
+    owner.abort();
+    const errors: unknown[] = [];
+    try {
+      widget.shutdown(ctx);
+    } catch (error) {
+      errors.push(error);
+    }
+    await joinCleanup(
+      [() => tools.shutdown(), ...[...menuTasks].map((task) => () => task), () => store.flush()],
+      errors,
+    );
   });
 }

package/src/tools.ts

@@ -1,19 +1,20 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { assertChildBootstrapCapacity } from "./broker-credentials.js";
-import { CHILD_COMMUNICATION_TOOL_NAMES } from "./child-communication-tools.js";
+import { assertChildBootstrapCapacity, MAX_BOOTSTRAP_BYTES } from "./broker-credentials.js";
 import {
   type BrokerInboundMessage,
   MAX_IDENTIFIER_LENGTH,
   MAX_MESSAGE_BYTES,
   MessageBroker,
+  optionalIdentifier,
+  requiredIdentifier,
   sanitizeTerminalText,
   validateMessage,
 } from "./message-broker.js";
 import { BROKER_MESSAGE_TYPE } from "./message-renderers.js";
 import { modelVisibleJson, requireBoundedModelText } from "./model-output.js";
-import { assertChildCommandCapacity } from "./process.js";
+import { assertChildCommandCapacity, selectedChildTools } from "./process.js";
 import {
   MAX_ATTACHED_EXTENSIONS,
   MAX_ATTACHED_SKILLS,
@@ -22,7 +23,7 @@ import {
   MAX_SELECTED_TOOLS,
   resolveResourceAttachments,
 } from "./resource-attachments.js";
-import { type RuntimeDependencies, SubagentRuntime } from "./runtime.js";
+import { type RuntimeDependencies, type SubagentModelOverrides, SubagentRuntime } from "./runtime.js";
 import { prepareTimeoutArguments, resolveTimeoutMs } from "./timeout.js";
 import {
   CHILD_CORE_TOOL_NAMES,
@@ -42,6 +43,21 @@ const SpawnParameters = Type.Object(
       description: "Self-contained task, constraints, and expected result. Maximum 50 KiB.",
       maxLength: MAX_TASK_BYTES,
     }),
+    provider: Type.Optional(
+      Type.String({
+        description: "Exact child provider ID. Defaults to the main agent's effective provider at spawn time.",
+        minLength: 1,
+        maxLength: MAX_BOOTSTRAP_BYTES,
+      }),
+    ),
+    model: Type.Optional(
+      Type.String({
+        description:
+          "Exact model ID within the selected provider. Defaults independently to the main agent's effective model ID at spawn time. Unlisted models fail without fallback.",
+        minLength: 1,
+        maxLength: MAX_BOOTSTRAP_BYTES,
+      }),
+    ),
     tools: Type.Optional(
       Type.Array(
         StringEnum(CHILD_CORE_TOOL_NAMES, {
@@ -209,23 +225,25 @@ export function registerSubagentTools(
       if (ctx.cwd !== cwd || ctx.isProjectTrusted() !== projectTrusted) {
         throw new Error("Subagent spawn context changed during attachment validation; retry the request.");
       }
-      if (tools.includes("codemode") || attachments.extensions.length > 0) {
-        assertChildBootstrapCapacity([...new Set([...attachments.effectiveTools, ...CHILD_COMMUNICATION_TOOL_NAMES])]);
-      }
-      const model = resolveChildModel(ctx, attachments.extensions.length > 0);
-      const thinkingLevel = resolveThinkingLevel(params.thinkingLevel ?? ctx.thinkingLevel ?? pi.getThinkingLevel());
+      const { provider, model, modelOverrides } = resolveChildModel(ctx, params, attachments.extensions.length > 0);
+      const defaultThinkingLevel = resolveThinkingLevel(ctx.thinkingLevel ?? pi.getThinkingLevel());
+      const thinkingLevel = resolveThinkingLevel(params.thinkingLevel ?? defaultThinkingLevel);
       resolveTimeoutMs(params.timeout);
       assertChildCommandCapacity(
         {
           tools,
           skills: attachments.skills,
           extensions: attachments.extensions,
-          model,
           thinkingLevel,
           projectTrusted,
         },
         dependencies.platform,
       );
+      assertChildBootstrapCapacity(selectedChildTools({ tools, extensions: attachments.extensions }), {
+        provider,
+        model,
+        thinkingLevel,
+      });
       throwIfAborted(signal, "Subagent spawn was cancelled");
       return toolResult(
         runtime.start({
@@ -234,8 +252,11 @@ export function registerSubagentTools(
           skills: attachments.skills,
           extensions: attachments.extensions,
           toolSources: attachments.toolSources,
+          provider,
           model,
+          modelOverrides,
           thinkingLevel,
+          defaultThinkingLevel,
           cwd,
           timeout: params.timeout,
           projectTrusted,
@@ -388,19 +409,62 @@ function resolveTools(value: unknown): string[] {
   return tools;
 }
 
-function resolveChildModel(ctx: ExtensionContext, hasAttachedExtensions: boolean): string {
-  const model = ctx.model;
-  if (!model) throw new Error("Subagent model is unavailable because no main-agent model is selected.");
-  const provider = sanitizeTerminalText(model.provider).slice(0, 128);
-  if (!hasAttachedExtensions && ctx.modelRegistry.getRegisteredProviderIds().includes(model.provider)) {
-    throw new Error(`Subagent model provider ${provider} is unavailable because children disable parent extensions.`);
+function resolveChildModel(
+  ctx: ExtensionContext,
+  overrides: Pick<SpawnArguments, "provider" | "model">,
+  hasAttachedExtensions: boolean,
+): { provider: string; model: string; modelOverrides: SubagentModelOverrides } {
+  // Read the effective parent pair once, after asynchronous attachment preflight.
+  const parent = ctx.model;
+  if (!parent && (overrides.provider === undefined || overrides.model === undefined)) {
+    throw new Error("Subagent model is unavailable because no main-agent model is selected.");
+  }
+  const provider = validateModelIdentifier(
+    overrides.provider === undefined ? parent?.provider : overrides.provider,
+    "provider",
+  );
+  const model = validateModelIdentifier(overrides.model === undefined ? parent?.id : overrides.model, "model");
+  const displayProvider = sanitizeTerminalText(provider).slice(0, 128);
+  if (!hasAttachedExtensions && ctx.modelRegistry.getRegisteredProviderIds().includes(provider)) {
+    throw new Error(
+      `Subagent model provider ${displayProvider} is unavailable because children disable parent extensions.`,
+    );
   }
-  if (ctx.modelRegistry.getProviderAuthStatus(model.provider).source === "runtime") {
+  if (ctx.modelRegistry.getProviderAuthStatus(provider).source === "runtime") {
     throw new Error(
-      `Subagent model provider ${provider} uses a process-local runtime API key. Configure stored or environment credentials that child processes can read.`,
+      `Subagent model provider ${displayProvider} uses a process-local runtime API key. Configure stored or environment credentials that child processes can read.`,
     );
   }
-  return `${model.provider}/${model.id}`;
+  return {
+    provider,
+    model,
+    modelOverrides: {
+      ...(provider !== parent?.provider ? { provider } : {}),
+      ...(model !== parent?.id ? { model } : {}),
+    },
+  };
+}
+
+function validateModelIdentifier(value: unknown, field: "provider" | "model"): string {
+  // Each ID must fit the shared bootstrap before character scans or sanitization.
+  if (
+    typeof value === "string" &&
+    (value.length > MAX_BOOTSTRAP_BYTES || Buffer.byteLength(value, "utf8") > MAX_BOOTSTRAP_BYTES)
+  ) {
+    throw new Error(`Subagent ${field} exceeds the ${MAX_BOOTSTRAP_BYTES}-byte child bootstrap size limit.`);
+  }
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    [...value].some((character) => {
+      const codePoint = character.codePointAt(0) ?? 0;
+      return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+    }) ||
+    sanitizeTerminalText(value) !== value
+  ) {
+    throw new Error(`Subagent ${field} must be a non-empty exact ID without control characters.`);
+  }
+  return value;
 }
 
 function resolveThinkingLevel(value: unknown): SubagentThinkingLevel {
@@ -430,29 +494,11 @@ function resolveMainSendArguments(params: SendArguments): MainSendSelection {
     : { kind: "response", requestId: requestId ?? "", message: params.message };
 }
 
-function optionalIdentifier(value: unknown, field: string): string | undefined {
-  return value === undefined ? undefined : requiredIdentifier(value, field);
-}
-
 function requiredString(value: unknown, field: string): string {
   if (typeof value !== "string" || !value.trim()) throw new Error(`Subagent ${field} is required.`);
   return value.trim();
 }
 
-function requiredIdentifier(value: unknown, field: string): string {
-  const identifier = requiredString(value, field);
-  if (
-    identifier.length > MAX_IDENTIFIER_LENGTH ||
-    [...identifier].some((character) => {
-      const codePoint = character.codePointAt(0) ?? 0;
-      return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
-    })
-  ) {
-    throw new Error(`Subagent ${field} is invalid.`);
-  }
-  return identifier;
-}
-
 function assertNotNested(): void {
   if ((Number.parseInt(process.env.PI_SUBAGENT_DEPTH ?? "0", 10) || 0) > 0) {
     throw new Error("Nested subagents are not supported by pi-subagents.");

package/src/types.ts

@@ -60,6 +60,7 @@ export interface ChildRequest {
   skills: string[];
   extensions: ExtensionAttachment[];
   toolSources: Record<string, string[]>;
+  provider: string;
   model: string;
   thinkingLevel: SubagentThinkingLevel;
   cwd: string;