create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/acp/dsh-transcript.js

@@ -0,0 +1,395 @@
+'use strict';
+
+// WP-3 of docs/deepseek-harness-acp-agent-2026-10-28.html (§5 D-8, §5 D-10, §6.4; §9 S-27; §10 T-7, T-9).
+//
+// CTM owns the dsh (DeepSeek Harness) transcript. Every user prompt and every flushed ACP
+// `session/update` becomes ONE Claude-shaped JSONL row with `provider:'dsh'` under
+// `<dataDir>/dsh-transcripts/<acpSessionId>.jsonl`, and that file is then the session's transcript for
+// live Conv, history, search and export — dsh's own zstd log is never read by CTM.
+//
+// Two row-shape rules the code below encodes (§6.4):
+//   * chunk deltas are ACCUMULATED. `agent_thought_chunk` / `agent_message_chunk` group by `messageId`
+//     and kind and become one row when the kind changes, the messageId changes, a `tool_call` arrives or
+//     `flush()` is called — so ten delta chunks for one message are one row (T-7), while a bridge that
+//     sends one chunk per block is unaffected (D-6).
+//   * `usage_update` and `config_option_update` are NOT rows.
+//
+// I/O: the public API stays synchronous-to-call (it returns the row it built), but the writer never does
+// sync fs I/O on CTM's main event loop. Each call builds its row synchronously — uuid / parentUuid /
+// timestamp are assigned in call order — serializes it, and ENQUEUES the line on ONE per-writer promise
+// chain: the first link `fs.promises.mkdir(dir, {recursive:true})`, every later link
+// `fs.promises.appendFile(path, line)`. Order on disk is exactly call order; nothing is ever truncated,
+// renamed or unlinked (D-10, T-9). `whenIdle()` resolves once every queued write has landed (WP-4/WP-5
+// and the tests await it); a failed write is reported once through the injected `log` and never breaks
+// the chain for later rows. `fs` (promises-shaped), `now`, `uuid` and `log` are deps so a test never
+// writes a real transcript (H-7).
+
+const crypto = require('node:crypto');
+const fsPromisesDefault = require('node:fs').promises;
+const path = require('node:path');
+
+const transcriptSource = require('../transcript-source');
+
+const DSH_ROW_VERSION = 'dsh-acp-jsonl-v1';
+const DSH_TURN_INTERRUPTED_TEXT = 'Turn interrupted by CTM restart';
+const TRANSCRIPT_DIR_NAME = 'dsh-transcripts';
+// Enough to hold the last row of any update we write; the tail read only needs its closing line.
+const TAIL_BYTES = 64 * 1024;
+
+// §6.4: the two streaming kinds, and the content type each one flushes to.
+const CHUNK_KINDS = Object.freeze({
+  agent_thought_chunk: 'thinking',
+  agent_message_chunk: 'text',
+});
+
+/** The directory a dsh session's transcript lives in (`<dataDir>/dsh-transcripts`). */
+function dshTranscriptDir(dataDir) {
+  return path.join(String(dataDir || ''), TRANSCRIPT_DIR_NAME);
+}
+
+function _stringOr(value, fallback) {
+  return typeof value === 'string' && value ? value : fallback;
+}
+
+// `content` is `{type:'text', text}` on a chunk and may be a bare string on an exotic bridge.
+function _chunkText(content) {
+  if (typeof content === 'string') return content;
+  if (content && typeof content.text === 'string') return content.text;
+  return '';
+}
+
+// WP-11 (D-20): an image the user attached to a prompt, carried on the user row in the SAME shape a
+// Claude Code JSONL user row encodes one — `{type:'image', source:{type:'base64', media_type, data}}`.
+// That is the shape lib/jsonl-conversation-parser.js / lib/session-stream.js already understand: their
+// `_jsonlContentText` turns it into the compact `[Image #N]` token (the join key
+// lib/session-image-refs.js matches a recorded manifest against) and `stripBase64Blobs` reduces it to a
+// metadata-only `image_ref` block for live Conv. The base64 is what the provider itself was given.
+function _imageContentBlocks(images) {
+  const blocks = [];
+  for (const image of Array.isArray(images) ? images : []) {
+    if (!image || typeof image !== 'object') continue;
+    const data = typeof image.data === 'string' ? image.data : '';
+    if (!data) continue;
+    blocks.push({
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: _stringOr(image.mimeType || image.media_type, 'image/png'),
+        data,
+      },
+    });
+  }
+  return blocks;
+}
+
+// A `tool_call_update`'s content is an array of ACP content blocks
+// (`{type:'content', content:{type:'text', text}}`); join every text it carries into ONE string.
+function _joinedContentText(content) {
+  const parts = [];
+  const walk = (item) => {
+    if (typeof item === 'string') {
+      parts.push(item);
+      return;
+    }
+    if (!item || typeof item !== 'object') return;
+    if (typeof item.text === 'string') {
+      parts.push(item.text);
+      return;
+    }
+    if (item.content !== undefined && item.content !== null) {
+      if (Array.isArray(item.content)) item.content.forEach(walk);
+      else walk(item.content);
+    }
+  };
+  if (Array.isArray(content)) content.forEach(walk);
+  else walk(content);
+  return parts.join('\n');
+}
+
+// The uuid of the file's last row, read through lib/transcript-source.js (the one transcript reader) so
+// a writer that reopens an existing transcript keeps its parentUuid chain unbroken. This seed stays
+// synchronous on purpose: every row's parentUuid must be known the moment the row is BUILT (calls are in
+// order), so an async seed could not feed the synchronous row builders. (The read is a bounded tail read
+// through the transcript-source seam, not a raw fs call.)
+function _lastRowUuid(filePath) {
+  try {
+    const view = transcriptSource.statTranscriptSync(filePath);
+    if (!view || !view.exists || !view.size) return null;
+    const start = Math.max(0, view.size - TAIL_BYTES);
+    const tail = transcriptSource.readTranscriptRangeSync(filePath, start, view.size).toString('utf8');
+    const lines = tail.split('\n').filter((line) => line.trim() !== '');
+    if (!lines.length) return null;
+    const row = JSON.parse(lines[lines.length - 1]);
+    return _stringOr(row && row.uuid, null);
+  } catch (error) {
+    // expected: a missing, unreadable or half-written tail — a fresh chain is the safe answer and the
+    // append itself will surface a real write problem.
+    return null;
+  }
+}
+
+/**
+ * WP-5 (§9 S-42, D-9). Is this transcript's last turn still OPEN?
+ *
+ * The row shapes (§6.4) make this a one-line question: a turn is open exactly when the LAST
+ * turn-bearing row is a `user` row — either a prompt whose assistant never answered, or a
+ * `tool_result` whose follow-up assistant row never came. Every terminal row closes it: an ordinary
+ * `assistant` row, the WP-7d `dsh_turn_failed` / `dsh_turn_interrupted` rows (now also `assistant`
+ * rows), and — for transcripts written before WP-7d — the older `system`-typed variant of those two
+ * rows. PURE: it reads no file and writes none; the caller passes the already-parsed rows (or raw
+ * JSON lines) it read off-thread.
+ *
+ * @param {Array<object|string>} rows  parsed rows, or raw JSON lines (malformed ones are skipped)
+ * @returns {{open: true, uuid: string|null, clientMessageId: string|null, timestamp: string|null}|null}
+ */
+function findOpenDshTurn(rows) {
+  if (!Array.isArray(rows) || !rows.length) return null;
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    let row = rows[i];
+    if (typeof row === 'string') {
+      try { row = JSON.parse(row); } catch (error) { void error; continue; } // expected: a half-written tail line is not a row
+    }
+    if (!row || typeof row !== 'object') continue;
+    if (row.type === 'user') {
+      return {
+        open: true,
+        uuid: _stringOr(row.uuid, null),
+        clientMessageId: _stringOr(row.clientMessageId, null),
+        timestamp: _stringOr(row.timestamp, null),
+      };
+    }
+    // An assistant row (including the WP-7d `dsh_turn_failed` / `dsh_turn_interrupted` rows) or a
+    // legacy `system` row is terminal: the turn that preceded it is closed.
+    if (row.type === 'assistant' || row.type === 'system') return null;
+  }
+  return null;
+}
+
+/**
+ * One writer per CTM dsh session (D-2: one child, one transcript).
+ *
+ * @param {object} opts
+ * @param {string} opts.dataDir                              // lib/data-dir.js's getDataDir()
+ * @param {string} opts.acpSessionId                         // the ACP session id (the file's name)
+ * @param {string} [opts.cwd]
+ * @param {() => string} [opts.now]                          // timestamp for a row
+ * @param {() => string} [opts.uuid]                         // row uuid
+ * @param {{mkdir: Function, appendFile: Function}} [opts.fs] // promises-shaped fs for tests
+ * @param {(message: string) => void} [opts.log]             // write-failure sink (default no-op)
+ * @returns {{
+ *   path: string,
+ *   appendUserPrompt: (prompt: {text?: string, clientMessageId?: string}) => object,
+ *   onUpdate: (update: object) => object|null,
+ *   flush: () => object|null,
+ *   appendTurnFailed: (message?: string) => object,
+ *   appendTurnInterrupted: () => object,
+ *   setModel: (id?: string|null) => string|null,
+ *   whenIdle: () => Promise<void>,
+ * }}
+ */
+function createDshTranscriptWriter(opts = {}) {
+  const dataDir = String(opts.dataDir || '');
+  const acpSessionId = String(opts.acpSessionId || '');
+  if (!dataDir || !acpSessionId) {
+    throw new TypeError('createDshTranscriptWriter requires dataDir and acpSessionId');
+  }
+  const cwd = opts.cwd || '';
+  const now = typeof opts.now === 'function' ? opts.now : () => new Date().toISOString();
+  const uuid = typeof opts.uuid === 'function' ? opts.uuid : () => crypto.randomUUID();
+  const fs = opts.fs || fsPromisesDefault;
+  const log = typeof opts.log === 'function' ? opts.log : () => {};
+  const dirPath = dshTranscriptDir(dataDir);
+  const filePath = path.join(dirPath, `${acpSessionId}.jsonl`);
+
+  let parentUuid = _lastRowUuid(filePath);
+  let model = null;
+  let pending = null; // { kind: 'thinking'|'text', messageId, text }
+  let dirEnsured = false;
+  // Serialized async write chain: one link per appended line, executed in call order. `tail` is always a
+  // settled-or-pending promise that never rejects (a failed write is logged, then swallowed) so a single
+  // bad append cannot stall or break the rows that follow it.
+  let tail = Promise.resolve();
+
+  async function _appendLine(line) {
+    if (!dirEnsured) {
+      await fs.mkdir(dirPath, { recursive: true });
+      dirEnsured = true;
+    }
+    await fs.appendFile(filePath, line);
+  }
+
+  // Build the row synchronously (uuid/parentUuid/timestamp in call order) and enqueue its serialized line.
+  function _write(row) {
+    const rowUuid = uuid();
+    const line = {
+      ...row,
+      provider: 'dsh',
+      version: DSH_ROW_VERSION,
+      sessionId: acpSessionId,
+      uuid: rowUuid,
+      parentUuid,
+      cwd,
+      timestamp: now(),
+    };
+    parentUuid = rowUuid;
+    tail = tail.then(() => _appendLine(`${JSON.stringify(line)}\n`)).catch((error) => {
+      log(`[dsh-transcript] write failed: ${error && error.message ? error.message : error}`);
+    });
+    return line;
+  }
+
+  function _flushPending() {
+    if (!pending) return null;
+    const { kind, messageId, text } = pending;
+    pending = null;
+    const content = kind === 'thinking'
+      ? [{ type: 'thinking', thinking: text }]
+      : [{ type: 'text', text }];
+    return _write({ type: 'assistant', message: { id: messageId, role: 'assistant', model, content } });
+  }
+
+  function _chunk(kind, update) {
+    const messageId = _stringOr(update.messageId, '');
+    if (!messageId) return null;
+    if (pending && (pending.kind !== kind || pending.messageId !== messageId)) _flushPending();
+    if (!pending) pending = { kind, messageId, text: '' };
+    pending.text += _chunkText(update.content);
+    return null;
+  }
+
+  function _toolCall(update) {
+    // A tool call ends the chunk group that precedes it (§6.4/D-6).
+    _flushPending();
+    const toolCallId = _stringOr(update.toolCallId, '');
+    if (!toolCallId) return null;
+    const rawInput = update.rawInput && typeof update.rawInput === 'object' && !Array.isArray(update.rawInput)
+      ? update.rawInput
+      : {};
+    return _write({
+      type: 'assistant',
+      message: {
+        id: `tool-${toolCallId}`,
+        role: 'assistant',
+        model,
+        content: [{ type: 'tool_use', id: toolCallId, name: _stringOr(update.title, ''), input: rawInput }],
+      },
+    });
+  }
+
+  function _toolCallUpdate(update) {
+    const status = _stringOr(update.status, '');
+    if (status !== 'completed' && status !== 'failed') return null; // in_progress/pending are not rows
+    const toolCallId = _stringOr(update.toolCallId, '');
+    if (!toolCallId) return null;
+    return _write({
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: toolCallId,
+          content: _joinedContentText(update.content),
+          is_error: status === 'failed',
+        }],
+      },
+    });
+  }
+
+  return {
+    path: filePath,
+
+    /**
+     * CTM sent `session/prompt` (§6.4 row 1). WP-4 calls this; the writer never prompts itself.
+     *
+     * WP-11 (D-20): `images` are the images the prompt carried (`{mimeType, data}`), written as the
+     * Claude-shaped content blocks below the text block — exactly how a Claude user row encodes its
+     * images — so the EXISTING Conv parsers and the manifest join work on a dsh row unchanged and a
+     * reload shows the same thumbnails a Claude session would.
+     */
+    appendUserPrompt(prompt = {}) {
+      _flushPending();
+      const content = [{ type: 'text', text: typeof prompt.text === 'string' ? prompt.text : '' }];
+      content.push(..._imageContentBlocks(prompt.images));
+      return _write({
+        type: 'user',
+        clientMessageId: _stringOr(prompt.clientMessageId, null),
+        message: { role: 'user', content },
+      });
+    },
+
+    /** One ACP `session/update` `update` object. Returns null for updates that are not rows. */
+    onUpdate(update) {
+      if (!update || typeof update !== 'object') return null;
+      const kind = CHUNK_KINDS[update.sessionUpdate];
+      if (kind) return _chunk(kind, update);
+      if (update.sessionUpdate === 'tool_call') return _toolCall(update);
+      if (update.sessionUpdate === 'tool_call_update') return _toolCallUpdate(update);
+      return null; // usage_update, config_option_update, plan, diff, … are not rows
+    },
+
+    /** Turn end: flush the chunk group still open. WP-4 calls this when the prompt settles. */
+    flush() {
+      return _flushPending();
+    },
+
+    /**
+     * A rejected prompt (§6.4 row 6), e.g. "Insufficient Balance".
+     *
+     * WP-7d: this row is written in the shape Claude Code itself writes for a failed turn — an
+     * `assistant` row with `isApiErrorMessage` — because that is the only shape both Conv lanes
+     * (`lib/transcript-store.js` ingest, `lib/jsonl-conversation-parser.js`) already render as an
+     * assistant message. A `system` row would be invisible in Conv.
+     */
+    appendTurnFailed(message) {
+      _flushPending();
+      const text = typeof message === 'string' ? message : String(message === undefined || message === null ? '' : message);
+      return _write({
+        type: 'assistant',
+        isApiErrorMessage: true,
+        error: 'dsh_turn_failed',
+        message: {
+          role: 'assistant',
+          model: '<synthetic>',
+          content: [{ type: 'text', text: `API Error: ${text || 'turn failed'}` }],
+        },
+      });
+    },
+
+    /** The boot sweep's one row for a turn that died with the CTM process (D-9). WP-7d: assistant-shaped so Conv renders it. */
+    appendTurnInterrupted() {
+      _flushPending();
+      return _write({
+        type: 'assistant',
+        isApiErrorMessage: true,
+        error: 'dsh_turn_interrupted',
+        message: {
+          role: 'assistant',
+          model: '<synthetic>',
+          content: [{ type: 'text', text: DSH_TURN_INTERRUPTED_TEXT }],
+        },
+      });
+    },
+
+    /** D-12: the session's current model id, stamped on every assistant row from here on (default null). */
+    setModel(id) {
+      model = _stringOr(id, null);
+      return model;
+    },
+
+    /**
+     * Resolves once every write queued so far has landed on disk (in call order). Never rejects: a
+     * failed write is reported through `log` and swallowed, so the chain always drains.
+     */
+    whenIdle() {
+      return tail;
+    },
+  };
+}
+
+module.exports = {
+  createDshTranscriptWriter,
+  findOpenDshTurn,
+  dshTranscriptDir,
+  DSH_ROW_VERSION,
+  DSH_TURN_INTERRUPTED_TEXT,
+};

package/template/coding-task-manager/lib/acp/dsh-usage-log.js

@@ -0,0 +1,162 @@
+'use strict';
+
+// WP-9 step 2 — the DeepSeek Harness per-request usage rows (design
+// docs/deepseek-harness-acp-agent-2026-10-28.html §5 D-19, §6.7 `appendDshUsageRow`, §9b L-1/L-2,
+// T-20).
+//
+// A dsh session talks to its model through CTM's model proxy with a per-session LEAD token minted by
+// `prepareDshRoute` (lib/acp/dsh-route-patch.js). ACP carries no per-request token usage — the wire has
+// `usage_update {used,size}` only (context occupancy, not billed tokens) — so CTM's usage ledger, which
+// is fed by transcript ingest, never saw dsh spend. The proxy is the one place that sees every
+// response's `usage` block, so it appends ONE row per completed request here.
+//
+// Contract (the seam with the ledger-side parser, lib/usage-ledger/dsh-parse.js — do NOT change it):
+//
+//   <dataDir>/dsh-usage/<ctmSessionId>.jsonl
+//   {"ts":"<ISO-8601 UTC>","requestId":"…","model":"…","input_tokens":N,"output_tokens":N,
+//    "cache_read_input_tokens":N,"cache_creation_input_tokens":N}
+//
+//   * one JSON object per line, UTF-8, `\n`-terminated;
+//   * exactly those seven fields — never a token, key, header, prompt or response text;
+//   * all four counts are non-negative integers, 0 when the upstream omitted one;
+//   * directory 0700 (created on first write), file 0600;
+//   * `ctmSessionId` is validated against `/^[A-Za-z0-9_-]{1,128}$/` BEFORE it becomes a file name, so
+//     no caller value can traverse out of the directory.
+//
+// Async fs only (the main-thread lint forbids sync fs under lib/), one append per call, and appends are
+// serialized per file through an in-process promise chain so two concurrent requests can never
+// interleave partial lines.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// The exact file-name grammar. A `/`, `.` or NUL can never reach path.join.
+const CTM_SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+const USAGE_DIR_NAME = 'dsh-usage';
+const DIR_MODE = 0o700;
+const FILE_MODE = 0o600;
+// A bounded opaque string (the proxy's own request id, or the downstream id it was answered with).
+const MAX_OPAQUE_LEN = 200;
+// The row's wire model id is a deployment id; the proxy's grammar caps it well below this.
+const MAX_MODEL_LEN = 200;
+
+/** @type {Map<string, Promise<void>>} one serialization chain per absolute file path */
+const _chains = new Map();
+
+function _count(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.round(n);
+}
+
+function _boundedString(value, max) {
+  return typeof value === 'string' ? value.slice(0, max) : '';
+}
+
+function _message(error) {
+  return String((error && error.message) || error || '').slice(0, 200);
+}
+
+/**
+ * The directory a dsh session's usage rows live in: `<dataDir>/dsh-usage`.
+ * @param {string} dataDir
+ * @returns {string}
+ */
+function dshUsageDir(dataDir) {
+  return path.join(dataDir, USAGE_DIR_NAME);
+}
+
+/**
+ * The ONE file a dsh session's usage rows live in: `<dataDir>/dsh-usage/<ctmSessionId>.jsonl`.
+ * `ctmSessionId` must already have passed the file-name grammar.
+ * @param {string} dataDir
+ * @param {string} ctmSessionId
+ * @returns {string}
+ */
+function dshUsagePath(dataDir, ctmSessionId) {
+  return path.join(dshUsageDir(dataDir), `${ctmSessionId}.jsonl`);
+}
+
+/**
+ * Build the exact contract row from a caller's (possibly richer) row object. Every field is
+ * whitelisted and coerced here: an extra key on the input can never reach the file, and a missing or
+ * malformed count becomes 0 rather than surfacing as `null`/`undefined`/NaN on the line.
+ *
+ * @param {object} row
+ * @returns {{ts:string, requestId:string, model:string, input_tokens:number, output_tokens:number,
+ *   cache_read_input_tokens:number, cache_creation_input_tokens:number}}
+ */
+function buildDshUsageRow(row) {
+  const input = row && typeof row === 'object' && !Array.isArray(row) ? row : {};
+  return {
+    ts: typeof input.ts === 'string' && input.ts ? input.ts : new Date().toISOString(),
+    requestId: _boundedString(input.requestId, MAX_OPAQUE_LEN),
+    model: _boundedString(input.model, MAX_MODEL_LEN),
+    input_tokens: _count(input.input_tokens),
+    output_tokens: _count(input.output_tokens),
+    cache_read_input_tokens: _count(input.cache_read_input_tokens),
+    cache_creation_input_tokens: _count(input.cache_creation_input_tokens),
+  };
+}
+
+// Serialize per file: the previous append for this path always settles before the next one starts, so
+// two concurrent calls produce two whole lines in call order. The stored chain never rejects (the
+// caller's own promise is `next`, below), so a failed append cannot poison the ones that follow.
+function _serialize(filePath, task) {
+  const previous = _chains.get(filePath) || Promise.resolve();
+  const next = previous.then(task, task);
+  const guard = next.then(() => {}, () => {});
+  _chains.set(filePath, guard);
+  guard.then(() => {
+    if (_chains.get(filePath) === guard) _chains.delete(filePath);
+  });
+  return next;
+}
+
+async function _appendLine(filePath, line) {
+  const dir = path.dirname(filePath);
+  await fs.promises.mkdir(dir, { recursive: true, mode: DIR_MODE });
+  // `mode` applies only at CREATION (and is masked by umask), so re-assert both bits: the directory
+  // holds a session's spend and the file is never group/world readable.
+  await fs.promises.chmod(dir, DIR_MODE);
+  await fs.promises.appendFile(filePath, line, { encoding: 'utf8', mode: FILE_MODE });
+  await fs.promises.chmod(filePath, FILE_MODE);
+}
+
+/**
+ * Append ONE contract row for a completed dsh lead request. Never throws: every failure is returned as
+ * `{ok:false, reason}` so the proxy can report it without breaking a response that has already gone out.
+ *
+ * @param {{ dataDir: string, ctmSessionId: string, row: object }} opts
+ * @returns {Promise<{ok:true}|{ok:false, reason:string, error?:string}>}
+ */
+function appendDshUsageRow({ dataDir, ctmSessionId, row } = {}) {
+  if (typeof dataDir !== 'string' || !dataDir) return Promise.resolve({ ok: false, reason: 'data_dir_required' });
+  if (typeof ctmSessionId !== 'string' || !CTM_SESSION_ID_RE.test(ctmSessionId)) {
+    // Refuse BEFORE the id is ever joined into a path: `../x`, an empty string, a 200-character id and
+    // anything else outside the grammar write NOTHING.
+    return Promise.resolve({ ok: false, reason: 'invalid_ctm_session_id' });
+  }
+  if (!row || typeof row !== 'object' || Array.isArray(row)) return Promise.resolve({ ok: false, reason: 'invalid_row' });
+  const filePath = dshUsagePath(dataDir, ctmSessionId);
+  const line = `${JSON.stringify(buildDshUsageRow(row))}\n`;
+  return _serialize(filePath, async () => {
+    try {
+      await _appendLine(filePath, line);
+      return { ok: true };
+    } catch (error) {
+      // REPORT: the caller surfaces the bounded reason through the proxy's own log line; the module
+      // itself stays silent and never throws into a response path.
+      return { ok: false, reason: 'write_failed', error: _message(error) };
+    }
+  });
+}
+
+module.exports = {
+  CTM_SESSION_ID_RE,
+  USAGE_DIR_NAME,
+  dshUsageDir,
+  dshUsagePath,
+  buildDshUsageRow,
+  appendDshUsageRow,
+};