chainlesschain 0.162.176 → 0.162.178

package/src/lib/side-effect-ledger-store.js

@@ -26,41 +26,82 @@ export const _deps = {
   readEvents: storeReadEvents,
 };
 
+export class SideEffectLedgerPersistenceError extends Error {
+  constructor(operation, sessionId, cause) {
+    const detail = cause?.message || String(cause || "unknown persistence error");
+    super(`Side-effect ledger ${operation} failed for ${sessionId}: ${detail}`, {
+      cause,
+    });
+    this.name = "SideEffectLedgerPersistenceError";
+    this.code =
+      operation === "read"
+        ? "SIDE_EFFECT_LEDGER_READ_FAILED"
+        : "SIDE_EFFECT_LEDGER_PERSIST_FAILED";
+    this.operation = operation;
+    this.sessionId = sessionId;
+  }
+}
+
+function persistenceFailure(operation, sessionId, cause, failIfUnavailable) {
+  if (!failIfUnavailable) return false;
+  throw new SideEffectLedgerPersistenceError(operation, sessionId, cause);
+}
+
 /**
- * Append the current ledger as a chained event. Best-effort — a persistence
- * failure must not crash the operation it is guarding.
+ * Append the current ledger as a chained event. This is Critical state:
+ * persistence failures reject by default so the guarded operation cannot run.
+ * Diagnostic callers may explicitly request advisory best-effort behavior.
  *
  * @param {string} sessionId
  * @param {SideEffectLedger|object} ledger
+ * @param {{failIfUnavailable?:boolean}} [opts]
  * @returns {boolean}
  */
-export function persistSideEffectLedger(sessionId, ledger) {
-  if (!sessionId || !ledger) return false;
-  const snapshot =
-    ledger instanceof SideEffectLedger ? ledger.toJSON() : ledger;
-  if (!snapshot || !Array.isArray(snapshot.ops)) return false;
+export function persistSideEffectLedger(sessionId, ledger, opts = {}) {
+  const failIfUnavailable = opts.failIfUnavailable !== false;
+  if (!sessionId || !ledger) {
+    return persistenceFailure(
+      "write",
+      sessionId || "<missing-session>",
+      new TypeError("sessionId and ledger are required"),
+      failIfUnavailable,
+    );
+  }
+
   try {
+    const snapshot =
+      ledger instanceof SideEffectLedger ? ledger.toJSON() : ledger;
+    if (!snapshot || !Array.isArray(snapshot.ops)) {
+      throw new TypeError("ledger snapshot must contain an ops array");
+    }
     _deps.appendEvent(sessionId, SIDE_EFFECT_LEDGER_EVENT, snapshot);
     return true;
-  } catch {
-    return false;
+  } catch (error) {
+    return persistenceFailure("write", sessionId, error, failIfUnavailable);
   }
 }
 
 /**
  * Rebuild the ledger from the LATEST persisted snapshot, or an empty ledger when
- * the session never persisted one (or on read error).
+ * the session never persisted one. Read/corruption errors reject by default.
  *
  * @param {string} sessionId
- * @param {{clock?:Function}} [opts]
+ * @param {{clock?:Function,failIfUnavailable?:boolean}} [opts]
  * @returns {SideEffectLedger}
  */
 export function loadSideEffectLedger(sessionId, opts = {}) {
+  const failIfUnavailable = opts.failIfUnavailable !== false;
   let events = [];
   try {
     events = _deps.readEvents(sessionId) || [];
-  } catch {
-    return new SideEffectLedger(opts);
+  } catch (error) {
+    const fallback = persistenceFailure(
+      "read",
+      sessionId || "<missing-session>",
+      error,
+      failIfUnavailable,
+    );
+    if (fallback === false) return new SideEffectLedger(opts);
   }
   for (let i = events.length - 1; i >= 0; i--) {
     const e = events[i];
@@ -70,7 +111,17 @@ export function loadSideEffectLedger(sessionId, opts = {}) {
       e.data &&
       Array.isArray(e.data.ops)
     ) {
-      return SideEffectLedger.fromJSON(e.data, opts);
+      try {
+        return SideEffectLedger.fromJSON(e.data, opts);
+      } catch (error) {
+        const fallback = persistenceFailure(
+          "read",
+          sessionId || "<missing-session>",
+          error,
+          failIfUnavailable,
+        );
+        if (fallback === false) return new SideEffectLedger(opts);
+      }
     }
   }
   return new SideEffectLedger(opts);

package/src/lib/skill-loader.js

@@ -31,6 +31,7 @@ import { parseSkillMcpServers } from "./skill-mcp.js";
 import { normalizeSkillPaths } from "./skill-path-scope.js";
 import { discoverPluginSkillLayers } from "./plugin-runtime/skills.js";
 import settingsLoader from "./settings-loader.cjs";
+import contextSourceLedger from "./context-source-ledger.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -218,6 +219,40 @@ export function parseSkillMd(content) {
   return { data, body };
 }
 
+/**
+ * Read only enough of SKILL.md to parse its YAML frontmatter. The markdown
+ * body is deliberately not retained during discovery; it is materialized by
+ * CLISkillLoader.materializeSkill() only when a persona or run_skill needs it.
+ */
+function readSkillFrontmatter(skillMd, maxBytes = 256 * 1024) {
+  const fd = fs.openSync(skillMd, "r");
+  const chunks = [];
+  let total = 0;
+  try {
+    while (total < maxBytes) {
+      const chunk = Buffer.allocUnsafe(Math.min(8192, maxBytes - total));
+      const read = fs.readSync(fd, chunk, 0, chunk.length, total);
+      if (read <= 0) break;
+      chunks.push(chunk.subarray(0, read));
+      total += read;
+      const prefix = Buffer.concat(chunks).toString("utf-8").replace(/^\uFEFF/, "");
+      const firstLineEnd = prefix.search(/\r?\n/);
+      if (firstLineEnd >= 0 && prefix.slice(0, firstLineEnd).trim() !== "---") {
+        return {};
+      }
+      const match = prefix.match(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/);
+      if (match) return parseSkillMd(match[0]).data;
+    }
+    return {};
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function estimateSkillTokens(text) {
+  return Math.ceil(String(text || "").length / 4);
+}
+
 /**
  * Substitute $ARGUMENTS / $1 / $2 / ... placeholders in a skill body.
  * Inspired by open-agents substituteArguments.
@@ -290,8 +325,17 @@ export function prepareSkillBody(skill, args) {
  * Multi-layer CLI skill loader
  */
 export class CLISkillLoader {
-  constructor() {
+  constructor({ contextLedger = contextSourceLedger } = {}) {
     this._cache = null;
+    this._bodyCache = new Map();
+    this._contextLedger = contextLedger;
+    this._cacheStats = {
+      descriptorScans: 0,
+      descriptorCacheHits: 0,
+      bodyCacheHits: 0,
+      bodyCacheMisses: 0,
+      bodyLoads: new Map(),
+    };
   }
 
   /**
@@ -449,8 +493,8 @@ export class CLISkillLoader {
         continue;
       }
       try {
-        const content = fs.readFileSync(skillMd, "utf-8");
-        const { data, body } = parseSkillMd(content);
+        const data = readSkillFrontmatter(skillMd);
+        const stat = fs.statSync(skillMd);
 
         out.push({
           id: data.name || entry.name,
@@ -474,12 +518,17 @@ export class CLISkillLoader {
           paths: normalizeSkillPaths(data),
           dirName: entry.name,
           hasHandler: fs.existsSync(path.join(skillDir, "handler.js")),
-          body,
-          // Skill-Embedded MCP: inline server declarations in a
-          // ```mcp-servers fenced code block. Empty array if absent.
-          mcpServers: parseSkillMcpServers(body),
+          isolation: data.isolation === true,
+          // Two-tier loading: discovery retains only the descriptor. The body
+          // and embedded MCP declarations are populated on first use.
+          body: null,
+          bodyLoaded: false,
+          mcpServers: [],
           source: layer,
           skillDir,
+          skillMdPath: skillMd,
+          skillFileBytes: stat.size,
+          skillFileMtimeMs: stat.mtimeMs,
         });
       } catch {
         // Skip malformed skill files
@@ -487,12 +536,149 @@ export class CLISkillLoader {
     }
   }
 
+  /**
+   * Materialize a descriptor's markdown body and embedded MCP declarations.
+   * Cache entries are invalidated by file size/mtime and never include content
+   * in provenance records.
+   */
+  materializeSkill(skill, context = {}) {
+    if (!skill || !skill.skillMdPath) {
+      throw new TypeError("A discovered skill descriptor is required");
+    }
+    const stat = fs.statSync(skill.skillMdPath);
+    const signature = `${stat.size}:${stat.mtimeMs}`;
+    let cached = this._bodyCache.get(skill.skillMdPath);
+    let cacheRead = false;
+    if (cached?.signature === signature) {
+      this._cacheStats.bodyCacheHits += 1;
+      cacheRead = true;
+    } else {
+      const content = fs.readFileSync(skill.skillMdPath, "utf-8");
+      const { body } = parseSkillMd(content);
+      cached = {
+        signature,
+        body,
+        mcpServers: parseSkillMcpServers(body),
+        rawChars: body.length,
+        estimatedTokens: estimateSkillTokens(body),
+      };
+      this._bodyCache.set(skill.skillMdPath, cached);
+      this._cacheStats.bodyCacheMisses += 1;
+    }
+
+    skill.body = cached.body;
+    skill.mcpServers = cached.mcpServers;
+    skill.bodyLoaded = true;
+    skill.skillFileBytes = stat.size;
+    skill.skillFileMtimeMs = stat.mtimeMs;
+
+    const prior = this._cacheStats.bodyLoads.get(skill.skillMdPath) || {
+      id: skill.id,
+      source: skill.source,
+      rawChars: cached.rawChars,
+      estimatedTokens: cached.estimatedTokens,
+      loads: 0,
+      cacheHits: 0,
+      loadedBecause: [],
+    };
+    prior.loads += 1;
+    if (cacheRead) prior.cacheHits += 1;
+    const reason = context.loadedBecause || "explicit";
+    if (!prior.loadedBecause.includes(reason)) prior.loadedBecause.push(reason);
+    this._cacheStats.bodyLoads.set(skill.skillMdPath, prior);
+
+    try {
+      this._contextLedger?.recordRead?.({
+        sessionId: context.sessionId || "unknown",
+        turnId: context.turnId || "unknown",
+        sourceType: "skill",
+        sourceId: skill.id,
+        permissionMode: context.permissionMode || "agent",
+        tokenCount: cached.estimatedTokens,
+        metadata: {
+          source: skill.source,
+          loadedBecause: reason,
+          cacheRead,
+          bodyIncluded: context.bodyIncluded === true,
+        },
+      });
+    } catch {
+      // Context observability must never make a valid skill unloadable.
+    }
+    return skill;
+  }
+
+  /** Record descriptor text that was actually returned to a model/tool caller. */
+  recordDescriptorUse(skills, context = {}) {
+    for (const skill of Array.isArray(skills) ? skills : []) {
+      const descriptorText = `${skill.id}\n${skill.description || ""}\n${skill.category || ""}`;
+      try {
+        this._contextLedger?.recordRead?.({
+          sessionId: context.sessionId || "unknown",
+          turnId: context.turnId || "unknown",
+          sourceType: "skill_descriptor",
+          sourceId: skill.id,
+          permissionMode: context.permissionMode || "agent",
+          tokenCount: estimateSkillTokens(descriptorText),
+          metadata: {
+            source: skill.source,
+            loadedBecause: context.loadedBecause || "list_skills",
+            bodyLoaded: skill.bodyLoaded === true,
+          },
+        });
+      } catch {
+        // Observability only.
+      }
+    }
+  }
+
+  /** Content-free cache/cost snapshot for `cc context --sources`. */
+  getCacheLedger() {
+    const descriptors = Array.isArray(this._cache) ? this._cache : [];
+    const descriptorChars = descriptors.reduce(
+      (sum, skill) =>
+        sum +
+        `${skill.id}\n${skill.displayName}\n${skill.description}\n${skill.category}`.length,
+      0,
+    );
+    const residentPaths = new Set(this._bodyCache.keys());
+    const lazyFileBytes = descriptors.reduce(
+      (sum, skill) =>
+        sum +
+        (residentPaths.has(skill.skillMdPath) ? 0 : skill.skillFileBytes || 0),
+      0,
+    );
+    const bodyLoads = Array.from(this._cacheStats.bodyLoads.values()).map(
+      (entry) => ({ ...entry, loadedBecause: [...entry.loadedBecause] }),
+    );
+    return {
+      descriptors: {
+        resident: descriptors.length,
+        scans: this._cacheStats.descriptorScans,
+        cacheHits: this._cacheStats.descriptorCacheHits,
+        rawChars: descriptorChars,
+        estimatedTokens: estimateSkillTokens(descriptorChars),
+      },
+      bodies: {
+        resident: this._bodyCache.size,
+        cacheHits: this._cacheStats.bodyCacheHits,
+        cacheMisses: this._cacheStats.bodyCacheMisses,
+        entries: bodyLoads,
+      },
+      savings: {
+        lazyFileBytes,
+        estimatedTokensAvoided: estimateSkillTokens(lazyFileBytes),
+      },
+    };
+  }
+
   /**
    * Load all skills from all layers, applying priority override
    * Higher-priority layers override same-name skills from lower layers.
    * @returns {object[]} Resolved skill list
    */
   loadAll(options = {}) {
+    this._cacheStats.descriptorScans += 1;
     // `cc agent --bare` (CC_SKILLS=0): no skill layer loads at all — cache the
     // empty result so getResolvedSkills stays cheap on every call.
     if (allSkillsDisabled(options)) {
@@ -552,7 +738,10 @@ export class CLISkillLoader {
    * @returns {object[]}
    */
   getResolvedSkills() {
-    if (this._cache) return this._cache;
+    if (this._cache) {
+      this._cacheStats.descriptorCacheHits += 1;
+      return this._cache;
+    }
     return this.loadAll();
   }
 
@@ -560,10 +749,16 @@ export class CLISkillLoader {
    * Get auto-activated persona skills
    * @returns {object[]} skills with category "persona" and activation "auto"
    */
-  getAutoActivatedPersonas() {
-    return this.getResolvedSkills().filter(
-      (s) => s.category === "persona" && s.activation === "auto",
-    );
+  getAutoActivatedPersonas(context = {}) {
+    return this.getResolvedSkills()
+      .filter((s) => s.category === "persona" && s.activation === "auto")
+      .map((skill) =>
+        this.materializeSkill(skill, {
+          ...context,
+          loadedBecause: context.loadedBecause || "persona_auto",
+          bodyIncluded: true,
+        }),
+      );
   }
 
   /**
@@ -571,6 +766,14 @@ export class CLISkillLoader {
    */
   clearCache() {
     this._cache = null;
+    this._bodyCache.clear();
+    this._cacheStats = {
+      descriptorScans: 0,
+      descriptorCacheHits: 0,
+      bodyCacheHits: 0,
+      bodyCacheMisses: 0,
+      bodyLoads: new Map(),
+    };
   }
 }
 

package/src/lib/skill-packs/generator.js

@@ -115,6 +115,7 @@ cli-version-hash: "${hash}"
 tags: [${allTags}]
 user-invocable: true
 handler: handler.js
+capabilities: [shell-exec]
 ---
 
 # ${domainDef.displayName}
@@ -176,7 +177,6 @@ export function generateDirectHandler(domainKey, domainDef) {
  * 自动生成 — 请勿手动修改，运行 \`chainlesschain skill sync-cli\` 重新生成
  */
 
-const { spawnSync } = require("child_process");
 
 /** 解析输入字符串为指令+参数数组 */
 function parseInput(input) {
@@ -241,7 +241,7 @@ ${commandGuide}
     const useJson = JSON_SUPPORTED_COMMANDS.has(command) && !cliArgs.includes("--json");
     if (useJson) cliArgs.push("--json");
 
-    // Security: spawnSync uses shell:true (needed to run the chainlesschain.cmd
+    // Security: Broker execution uses shell:true (needed to run the chainlesschain.cmd
     // shim on Windows), which joins cliArgs into a shell command. Reject shell
     // metacharacters so a crafted skill input can't inject commands.
     const unsafeArg = cliArgs.find((a) => /[;&|\`$<>()\\n\\r]/.test(a));
@@ -252,11 +252,16 @@ ${commandGuide}
       };
     }
 
-    // Execute via child process
-    const result = spawnSync("chainlesschain", cliArgs, {
+    const processBroker = context?.processBroker;
+    if (!processBroker || typeof processBroker.runSync !== "function") {
+      return { success: false, error: "Process Broker unavailable for skill execution." };
+    }
+
+    // Execute via the host-scoped Process Broker facade.
+    const result = processBroker.runSync("chainlesschain", cliArgs, {
       encoding: "utf-8",
       shell: true,
-      cwd: context.projectRoot || process.cwd(),
+      cwd: context?.projectRoot || process.cwd(),
       timeout: 30000,
       env: { ...process.env },
     });
@@ -407,7 +412,6 @@ export function generateHybridHandler(domainKey, domainDef) {
  * 自动生成 — 请勿手动修改，运行 \`chainlesschain skill sync-cli\` 重新生成
  */
 
-const { spawnSync } = require("child_process");
 
 const AGENT_ONLY_COMMANDS = new Set([${agentCmds}]);
 const VALID_COMMANDS = new Set(["${commandList}"]);
@@ -470,7 +474,7 @@ const handler = {
     // Direct execution for other commands
     const cliArgs = [...args, "--quiet"];
 
-    // Security: spawnSync uses shell:true (needed to run the chainlesschain.cmd
+    // Security: Broker execution uses shell:true (needed to run the chainlesschain.cmd
     // shim on Windows), which joins cliArgs into a shell command. Reject shell
     // metacharacters so a crafted skill input can't inject commands.
     const unsafeArg = cliArgs.find((a) => /[;&|\`$<>()\\n\\r]/.test(a));
@@ -481,10 +485,15 @@ const handler = {
       };
     }
 
-    const result = spawnSync("chainlesschain", cliArgs, {
+    const processBroker = context?.processBroker;
+    if (!processBroker || typeof processBroker.runSync !== "function") {
+      return { success: false, error: "Process Broker unavailable for skill execution." };
+    }
+
+    const result = processBroker.runSync("chainlesschain", cliArgs, {
       encoding: "utf-8",
       shell: true,
-      cwd: context.projectRoot || process.cwd(),
+      cwd: context?.projectRoot || process.cwd(),
       timeout: 30000,
       env: { ...process.env },
     });

package/src/lib/skill-process-broker.js

@@ -0,0 +1,85 @@
+import executionBroker from "./process-execution-broker/index.js";
+
+const defaultRunSync = executionBroker.spawnSync.bind(executionBroker);
+const defaultRunFileSync = executionBroker.execFileSync.bind(executionBroker);
+const defaultRun = executionBroker.spawn.bind(executionBroker);
+
+function skillIdentity(skill = {}) {
+  const identity = String(
+    skill.id || skill.name || skill.skillName || "unknown",
+  )
+    .trim()
+    .replace(/[^a-zA-Z0-9._:-]+/g, "-")
+    .slice(0, 96);
+  return identity || "unknown";
+}
+
+function declaresShellExecution(skill = {}) {
+  return (
+    Array.isArray(skill.capabilities) &&
+    skill.capabilities.some(
+      (capability) => String(capability).toLowerCase() === "shell-exec",
+    )
+  );
+}
+
+/**
+ * Create the narrow process facade exposed to a skill handler.
+ *
+ * The host, not the handler, owns provenance and permission metadata. Generated
+ * handlers can choose argv and ordinary process options, but cannot relabel the
+ * execution or bypass the Broker boundary.
+ */
+export function createSkillProcessBroker(
+  skill,
+  {
+    run = defaultRun,
+    runSync = defaultRunSync,
+    runFileSync = defaultRunFileSync,
+  } = {},
+) {
+  if (!declaresShellExecution(skill)) return null;
+
+  const identity = skillIdentity(skill);
+  const metadata = Object.freeze({
+    origin: `skill:${identity}`,
+    policy: "allow",
+    scope: "skill",
+    pluginId: skill?.pluginId || skill?.plugin?.id || null,
+    pluginVersion: skill?.pluginVersion || skill?.plugin?.version || null,
+    pluginSource: skill?.pluginSource || skill?.plugin?.source || null,
+  });
+
+  return Object.freeze({
+    run(file, args = [], options = {}) {
+      return run(file, args, {
+        ...options,
+        ...metadata,
+        shell: false,
+      });
+    },
+
+    runSync(file, args = [], options = {}) {
+      return runSync(file, args, {
+        ...options,
+        ...metadata,
+      });
+    },
+
+    runFileSync(file, args = [], options = {}) {
+      return runFileSync(file, args, {
+        ...options,
+        ...metadata,
+        shell: false,
+      });
+    },
+  });
+}
+
+export const _skillProcessDefaults = {
+  run: defaultRun,
+  runSync: defaultRunSync,
+  runFileSync: defaultRunFileSync,
+};
+
+export { declaresShellExecution as skillDeclaresShellExecution };

package/src/lib/slash-commands.js

@@ -21,11 +21,15 @@
 import fsDefault from "node:fs";
 import pathDefault from "node:path";
 import { homedir } from "node:os";
-import { execSync as execSyncDefault } from "node:child_process";
 import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { projectRootBase } from "./project-root.cjs";
+import executionBroker from "./process-execution-broker/index.js";
 
-const _deps = { fs: fsDefault, path: pathDefault, execSync: execSyncDefault };
+const _deps = {
+  fs: fsDefault,
+  path: pathDefault,
+  execSync: (...args) => executionBroker.execSync(...args),
+};
 
 /**
  * Split `--- ... ---` frontmatter from the body and camelCase the keys (so
@@ -191,6 +195,10 @@ function runBangs(text, { cwd, execSync }) {
         encoding: "utf-8",
         timeout: BANG_TIMEOUT_MS,
         stdio: ["ignore", "pipe", "pipe"],
+        origin: "slash-command:bang",
+        policy: "allow",
+        scope: "slash-command",
+        shell: true,
       });
       return String(out).trim();
     } catch (err) {

package/src/lib/status-line.cjs

@@ -13,15 +13,14 @@
  *
  * Best-effort throughout: a missing config, a broken command, or a timeout just
  * yields no status line — it never blocks or breaks the REPL. `_deps` injection
- * (spawnSync / settings reader) for tests.
+ * (process runner / settings reader) for tests.
  */
 
-const cpDefault = require("node:child_process");
 const path = require("node:path");
 const { settingsPaths, readSettingsFile } = require("./settings-loader.cjs");
 
 const _deps = {
-  spawnSync: cpDefault.spawnSync,
+  runProcess: null,
   // injectable so tests don't touch real settings files
   readSettings: (cwd, settingsFile) => {
     const out = [];
@@ -181,7 +180,7 @@ function isStatusLineDisabled({ cwd = process.cwd(), settingsFile } = {}) {
 function renderStatusLine(
   config,
   context = {},
-  { cwd, timeout = 5000, columns, rows } = {},
+  { cwd, timeout = 5000, columns, rows, runProcess } = {},
 ) {
   if (!config || !config.command) return null;
   // Claude-Code parity (2.1.153): hand the command the terminal width/height so
@@ -194,7 +193,9 @@ function renderStatusLine(
   if (rws != null) env.LINES = String(rws);
   let res;
   try {
-    res = _deps.spawnSync(config.command, {
+    const runner = runProcess || _deps.runProcess;
+    if (typeof runner !== "function") return null;
+    res = runner(config.command, [], {
       input: JSON.stringify(context),
       cwd: cwd || process.cwd(),
       env,
@@ -202,6 +203,9 @@ function renderStatusLine(
       timeout,
       shell: true,
       maxBuffer: 1024 * 1024,
+      origin: "status-line:command",
+      policy: "allow",
+      scope: "status-line",
     });
   } catch {
     return null; // spawn failure → no status line
@@ -216,11 +220,28 @@ function renderStatusLine(
 }
 
 /** Convenience: load + render in one call (used by the REPL each turn). */
-function getStatusLine({ cwd, settingsFile, sessionId, model, provider, projectDir, timeout, columns, rows } = {}) {
+function getStatusLine({
+  cwd,
+  settingsFile,
+  sessionId,
+  model,
+  provider,
+  projectDir,
+  timeout,
+  columns,
+  rows,
+  runProcess,
+} = {}) {
   const config = loadStatusLineConfig({ cwd, settingsFile });
   if (!config) return null;
   const context = buildContext({ sessionId, model, provider, cwd, projectDir });
-  return renderStatusLine(config, context, { cwd, timeout, columns, rows });
+  return renderStatusLine(config, context, {
+    cwd,
+    timeout,
+    columns,
+    rows,
+    runProcess,
+  });
 }
 
 module.exports = {