@event4u/agent-config 16.0.0 → 16.1.0

package/dist/scripts/_lib/installed_tools.js

@@ -0,0 +1,460 @@
+/**
+ * Project-scope installed-tools manifest at `agents/installed-tools.lock`.
+ *
+ * Ported from the retired Python `src/scripts/_lib/installed_tools.py` (ADR-200 — Python→TS
+ * migration, Phase 2 / Wave 2a). Public API mirrors the Python module exactly
+ * (snake_case kept deliberately — fidelity over TS idiom), including the
+ * byte-exact YAML wire format the `_render` golden tests pin.
+ *
+ * Phase 3 of road-to-global-first-install (ADR-008). Committed
+ * bill-of-materials for AI tooling a project depends on. Sibling to the
+ * global lockfile (`installed_lock.ts`) but architecturally distinct:
+ *
+ * - `installed_lock` lives in `~/.event4u/agent-config/` and tracks the
+ *   user-scope environment (a single `agent_config_version` and a flat
+ *   `tools[]` list).
+ * - `installed_tools` lives in `agents/` and tracks **per-project** tooling
+ *   with richer per-entry metadata (`scope`, `bridge_marker`, `installed_at`).
+ *
+ * The file is machine-managed: `init` appends / merges; `sync` replays;
+ * `validate` drift-checks. Schema is YAML; the Python reference uses `pyyaml`
+ * when available and otherwise a constrained manual parser. This port has no
+ * YAML library dependency — it always uses the manual parser, which handles
+ * the documented schema (no anchors, no flow style, single-level nesting under
+ * `tools`).
+ *
+ * Divergence candidate (flagged, not fixed): the Python reader prefers
+ * `pyyaml` and only falls back to the manual parser when it is absent or the
+ * YAML is malformed. This port has no YAML dependency, so it always takes the
+ * manual-parser path. For the canonical schema both paths agree; for v2
+ * manifests with nested `files` / `merged_keys` arrays the manual path
+ * silently drops those nested fields (documented degraded read in the Python
+ * source). A consumer relying on `pyyaml`-backed full-v2 fidelity would see a
+ * behavior change here. See ADR-200 § intentional-divergence.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as fsPath from "node:path";
+import { write_atomic } from "./fs_atomic.js";
+export const MANIFEST_ENV = "AGENT_CONFIG_INSTALLED_TOOLS";
+export const DEFAULT_MANIFEST_RELATIVE = fsPath.join("agents", "installed-tools.lock");
+export const SCHEMA_VERSION = 2;
+/**
+ * Schema versions older writers may have emitted. Reading any of these
+ * succeeds; writing always produces {@link SCHEMA_VERSION}.
+ */
+export const SCHEMA_VERSIONS_SUPPORTED = [1, 2];
+const _VALID_SCOPES = ["global", "project"];
+/**
+ * Permitted values for `files[].kind` (P1.1, road-to-multi-package-
+ * coexistence). `bridge` = team-pointer marker (e.g. `.cursorrules`);
+ * `deployed` = bundle content we wrote (e.g. `.augment/rules/*.md`);
+ * `marker` = one-off sentinel (e.g. `claude-desktop` install marker).
+ */
+export const FILE_KINDS = new Set(["bridge", "deployed", "marker"]);
+/**
+ * Stable known deploy roots — directories under which the doctor command
+ * surveys for foreign files. Writers may extend the live `deploy_roots` field
+ * per project; this constant is the canonical default the installer seeds.
+ */
+export const DEFAULT_DEPLOY_ROOTS = [
+    ".augment/rules",
+    ".augment/skills",
+    ".augment/commands",
+    ".cursor/rules",
+    ".claude/skills",
+    ".claude/commands",
+    ".clinerules",
+    ".windsurf/rules",
+];
+/** Expand a leading `~` like Python's `Path.expanduser()`. */
+function expanduser(p) {
+    if (p === "~") {
+        return os.homedir();
+    }
+    if (p.startsWith("~/") || (process.platform === "win32" && p.startsWith("~\\"))) {
+        return fsPath.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+/** Return the active manifest path, honoring the env override. */
+export function manifest_path(project_root, env) {
+    const env_map = env ?? process.env;
+    const override = env_map[MANIFEST_ENV];
+    if (override) {
+        return expanduser(override);
+    }
+    return fsPath.join(project_root, DEFAULT_MANIFEST_RELATIVE);
+}
+// ---------------------------------------------------------------------------
+// Read
+// ---------------------------------------------------------------------------
+const _TOP_KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+const _LIST_DASH_RE = /^\s*-\s*(.+?)\s*$/;
+const _INDENT_KEY_RE = /^\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+/**
+ * Parse the manifest into a dict; return `null` if absent.
+ *
+ * Tolerates partial / malformed files: missing keys yield missing dict entries
+ * rather than throwing, so a corrupted file does not brick `init`. v1 and v2
+ * wire formats both return the same shape — v2 optional fields (`deploy_roots`,
+ * per-tool `files` / `merged_keys`) default to empty lists when absent, so
+ * callers can iterate without `?? []` boilerplate (P1.2).
+ */
+export function read_manifest(path) {
+    let text;
+    try {
+        text = require_read_text(path);
+    }
+    catch {
+        return null;
+    }
+    // This port has no YAML dependency — always use the manual parser. See the
+    // module-level divergence note.
+    const data = _parse_manual(text);
+    return _normalise_v2_shape(data);
+}
+/** Read a file as UTF-8 text, throwing on any error (caller catches). */
+function require_read_text(path) {
+    return fs.readFileSync(path, { encoding: "utf-8" });
+}
+/**
+ * Backfill v2 optional fields so consumers can iterate uniformly.
+ *
+ * Idempotent: calling on an already-normalised dict is a no-op. Does not
+ * mutate input lists — replaces missing keys with fresh empties.
+ */
+export function _normalise_v2_shape(data) {
+    if (data["tools"] === undefined || data["tools"] === null) {
+        data["tools"] = [];
+    }
+    if (data["deploy_roots"] === undefined || data["deploy_roots"] === null) {
+        data["deploy_roots"] = [];
+    }
+    const tools = data["tools"];
+    for (const tool of tools) {
+        if (typeof tool !== "object" || tool === null) {
+            continue;
+        }
+        const t = tool;
+        if (t["files"] === undefined || t["files"] === null) {
+            t["files"] = [];
+        }
+        if (t["merged_keys"] === undefined || t["merged_keys"] === null) {
+            t["merged_keys"] = [];
+        }
+    }
+    return data;
+}
+/**
+ * Strict v1 manual parser; v2 nested fields are skipped, not raised.
+ *
+ * Handles the canonical v1 wire format (top-level scalars + `tools` array with
+ * single-level key:value entries). For v2 manifests it still extracts the
+ * top-level scalars and the per-tool scalar fields, but silently drops nested
+ * arrays (`files`, `merged_keys`) and top-level `deploy_roots`.
+ */
+export function _parse_manual(text) {
+    const data = { tools: [] };
+    const tools = data["tools"];
+    let in_tools = false;
+    let current = null;
+    // When the current tool entry opened a nested array (`files:` or
+    // `merged_keys:`), suppress recognition of the deeper `- key` lines as new
+    // tools until the indent climbs back to the per-tool level (4 spaces).
+    let skip_until_outdent = false;
+    for (const raw of splitlines(text)) {
+        const stripped = raw.trim();
+        if (!stripped || stripped.startsWith("#")) {
+            continue;
+        }
+        if (stripped === "tools:") {
+            in_tools = true;
+            current = null;
+            skip_until_outdent = false;
+            continue;
+        }
+        if (in_tools) {
+            const indent = raw.length - lstrip_spaces(raw).length;
+            if (skip_until_outdent && indent > 4) {
+                continue;
+            }
+            skip_until_outdent = false;
+            const m = _LIST_DASH_RE.exec(raw);
+            if (m && indent === 2) {
+                const first = m[1];
+                current = {};
+                tools.push(current);
+                const inline = _TOP_KEY_RE.exec(first);
+                if (inline) {
+                    current[inline[1]] = inline[2];
+                }
+                continue;
+            }
+            const mk = _INDENT_KEY_RE.exec(raw);
+            if (mk && current !== null && indent === 4) {
+                const key = mk[1];
+                const val = mk[2];
+                if ((key === "files" || key === "merged_keys") && !val) {
+                    skip_until_outdent = true;
+                    continue;
+                }
+                current[key] = val;
+                continue;
+            }
+        }
+        const m_top = _TOP_KEY_RE.exec(raw);
+        if (m_top) {
+            const key = m_top[1];
+            const value = m_top[2];
+            if (key === "deploy_roots" && !value) {
+                // Top-level v2 array — skip until next top-level scalar.
+                in_tools = false;
+                current = null;
+                skip_until_outdent = true;
+                continue;
+            }
+            if (key === "schema_version") {
+                const parsed = parse_int_strict(value);
+                data[key] = parsed === null ? value : parsed;
+            }
+            else {
+                data[key] = value;
+            }
+            in_tools = false;
+            current = null;
+            skip_until_outdent = false;
+        }
+    }
+    return data;
+}
+/** `str.splitlines()` — split on `\n`, dropping a trailing empty segment. */
+function splitlines(text) {
+    const parts = text.split("\n");
+    if (parts.length > 0 && parts[parts.length - 1] === "") {
+        parts.pop();
+    }
+    return parts;
+}
+/** Left-strip only spaces, mirroring Python's `lstrip(" ")`. */
+function lstrip_spaces(s) {
+    let i = 0;
+    while (i < s.length && s[i] === " ") {
+        i += 1;
+    }
+    return s.slice(i);
+}
+/** Parse a base-10 int the way Python's `int(value)` does; null on failure. */
+function parse_int_strict(value) {
+    if (!/^[+-]?\d+$/.test(value.trim())) {
+        return null;
+    }
+    return Number.parseInt(value, 10);
+}
+// ---------------------------------------------------------------------------
+// Write
+// ---------------------------------------------------------------------------
+function _render(version, tools, options = {}) {
+    const deploy_roots = options.deploy_roots ?? null;
+    const lines = [
+        `schema_version: ${SCHEMA_VERSION}`,
+        `agent_config_version: "${version}"`,
+    ];
+    if (deploy_roots && deploy_roots.length > 0) {
+        lines.push("deploy_roots:");
+        for (const root of deploy_roots) {
+            lines.push(`  - ${root}`);
+        }
+    }
+    lines.push("tools:");
+    for (const tool of tools) {
+        lines.push(`  - name: ${String(tool["name"])}`);
+        lines.push(`    scope: ${String(tool["scope"])}`);
+        lines.push(`    bridge_marker: ${String(tool["bridge_marker"])}`);
+        lines.push(`    installed_at: "${String(tool["installed_at"])}"`);
+        const status = tool["status"];
+        if (status) {
+            lines.push(`    status: ${String(status)}`);
+        }
+        let files = tool["files"] ?? [];
+        if (files.length > 0) {
+            // Sort by path ascending — deterministic output for golden-file tests
+            // and stable team diffs (P1.3).
+            files = stable_sort(files, (f) => [String(f["path"])]);
+            lines.push("    files:");
+            for (const entry of files) {
+                lines.push(`      - path: ${String(entry["path"])}`);
+                lines.push(`        kind: ${String(entry["kind"])}`);
+                const sha = entry["sha256"];
+                if (sha === null || sha === undefined) {
+                    lines.push("        sha256: null");
+                }
+                else {
+                    lines.push(`        sha256: "${String(sha)}"`);
+                }
+            }
+        }
+        let merged = tool["merged_keys"] ?? [];
+        if (merged.length > 0) {
+            // Sort by (file, json_pointer) ascending — deterministic output
+            // regardless of insertion order (P1.3).
+            merged = stable_sort(merged, (e) => [
+                String(e["file"]),
+                String(e["json_pointer"]),
+            ]);
+            lines.push("    merged_keys:");
+            for (const entry of merged) {
+                lines.push(`      - file: ${String(entry["file"])}`);
+                lines.push(`        json_pointer: "${String(entry["json_pointer"])}"`);
+                const vh = entry["value_hash"];
+                if (vh !== null && vh !== undefined) {
+                    lines.push(`        value_hash: "${String(vh)}"`);
+                }
+            }
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Stable sort by a tuple key, mirroring Python's tuple-comparison `sorted`.
+ * Compares each component lexicographically; ties keep input order.
+ */
+function stable_sort(items, key) {
+    return items
+        .map((item, index) => ({ item, index, k: key(item) }))
+        .sort((a, b) => {
+        const len = Math.max(a.k.length, b.k.length);
+        for (let i = 0; i < len; i += 1) {
+            const av = a.k[i] ?? "";
+            const bv = b.k[i] ?? "";
+            if (av < bv)
+                return -1;
+            if (av > bv)
+                return 1;
+        }
+        return a.index - b.index;
+    })
+        .map((entry) => entry.item);
+}
+/**
+ * Atomically write the manifest; return the path written.
+ *
+ * Delegates to {@link write_atomic} so the crash-safety guarantees (fsync
+ * file, atomic rename, fsync parent dir) are shared with every other v2
+ * writer.
+ *
+ * `deploy_roots` is the optional top-level v2 field listing directories the
+ * doctor command surveys for foreign files. When omitted, the field is not
+ * emitted (callers may rely on {@link DEFAULT_DEPLOY_ROOTS} for the survey
+ * scope).
+ */
+export function write_manifest(path, version, tools, options = {}) {
+    const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
+    return write_atomic(path, rendered);
+}
+// ---------------------------------------------------------------------------
+// Mutation helpers
+// ---------------------------------------------------------------------------
+/** Raised when an existing manifest entry conflicts with the new scope. */
+export class ScopeMismatchError extends Error {
+    name_;
+    recorded_scope;
+    new_scope;
+    constructor(name, recorded_scope, new_scope) {
+        super(`tool '${name}' is committed as scope=${recorded_scope}; ` +
+            `refusing to change it to scope=${new_scope} without --force`);
+        this.name = "ScopeMismatchError";
+        this.name_ = name;
+        this.recorded_scope = recorded_scope;
+        this.new_scope = new_scope;
+    }
+}
+/**
+ * Return a new tools list with `name` added or refreshed.
+ *
+ * Idempotency rules from ADR-008 §Lifecycle:
+ * - Same name, same scope → no-op (timestamp preserved).
+ * - Same name, different scope → throw {@link ScopeMismatchError} unless
+ *   `force=true`, in which case the entry is rewritten.
+ * - New name → appended in install order (not alphabetised).
+ *
+ * `files` / `merged_keys` are the v2 per-tool inventories (P1.4). When
+ * provided, they replace whatever was previously recorded on the entry — the
+ * installer is authoritative for the set of artefacts it just wrote. When
+ * `null`/omitted, existing values are preserved on the idempotent path and
+ * absent on first-write.
+ */
+export function upsert_tool(existing, options) {
+    const { name, scope, bridge_marker, installed_at = null, force = false, files = null, merged_keys = null, } = options;
+    if (!_VALID_SCOPES.includes(scope)) {
+        throw new ValueError(`scope must be one of ${_VALID_SCOPES.join(",")}: '${scope}'`);
+    }
+    const stamp = installed_at || _today();
+    const _build = (prior = null) => {
+        const entry = {
+            name,
+            scope,
+            bridge_marker,
+            installed_at: stamp,
+        };
+        if (files !== null) {
+            entry["files"] = [...files];
+        }
+        else if (prior !== null && Array.isArray(prior["files"]) && prior["files"].length > 0) {
+            entry["files"] = [...prior["files"]];
+        }
+        if (merged_keys !== null) {
+            entry["merged_keys"] = [...merged_keys];
+        }
+        else if (prior !== null &&
+            Array.isArray(prior["merged_keys"]) &&
+            prior["merged_keys"].length > 0) {
+            entry["merged_keys"] = [...prior["merged_keys"]];
+        }
+        return entry;
+    };
+    const result = [];
+    let found = false;
+    for (const entry of existing) {
+        if (entry["name"] === name) {
+            found = true;
+            const recorded = String(entry["scope"] ?? "");
+            if (recorded === scope) {
+                if (files === null && merged_keys === null) {
+                    // Idempotent no-op — preserve original entry.
+                    result.push(entry);
+                }
+                else {
+                    // Refresh inventories, preserve installed_at.
+                    const refreshed = _build(entry);
+                    refreshed["installed_at"] = entry["installed_at"] ?? stamp;
+                    result.push(refreshed);
+                }
+                continue;
+            }
+            if (!force) {
+                throw new ScopeMismatchError(name, recorded, scope);
+            }
+            result.push(_build(entry));
+            continue;
+        }
+        result.push(entry);
+    }
+    if (!found) {
+        result.push(_build());
+    }
+    return result;
+}
+/** Thrown for invalid-argument conditions, mirroring Python's `ValueError`. */
+export class ValueError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValueError";
+    }
+}
+function _today() {
+    // UTC date in YYYY-MM-DD — matches Python's
+    // `datetime.now(timezone.utc).strftime("%Y-%m-%d")`.
+    return new Date().toISOString().slice(0, 10);
+}
+//# sourceMappingURL=installed_tools.js.map

package/dist/scripts/_lib/lean_projection_mode.js

@@ -11,8 +11,9 @@
  *
  * So each side supplies the raw string from its own reader and this module
  * decides what it means. Anything unrecognised — absent key, typo, `null`,
- * a non-string — is `eager-all`, today's shipped behaviour: a mode nobody can
- * spell must never silently thin the standing corpus.
+ * a non-string — is `eager-all`: the parser fallback, which is NOT the value
+ * the template ships (see the type below), because a mode nobody can spell
+ * must never silently thin the standing corpus.
  */
 export const DEFAULT_LEAN_PROJECTION_MODE = 'eager-all';
 /** Map a raw settings value onto a mode. Unrecognised → `eager-all`. */

package/dist/scripts/_lib/settings_renamed_keys.js

@@ -0,0 +1,78 @@
+/**
+ * Settings keys this package has RENAMED, old path -> new path.
+ *
+ * Distinct from `REMOVED_KEYS` in the one way that matters to a user: a
+ * removed key's value is DISCARDED, and a renamed key's value is CARRIED.
+ * Putting a rename in the removed map would silently return an installed
+ * `false` to the shipped default, which is the opposite of accepting the old
+ * key — so the two maps stay separate even though both warn once.
+ *
+ * An entry is dropped one minor after it lands. The new key always wins when
+ * one layer carries both: a reader who has already migrated is not overridden
+ * by a stale line they forgot to delete.
+ *
+ * Its own module rather than more lines in `agent_settings.ts`, which sits
+ * three lines under the 1500-line source ceiling — a sixty-line addition there
+ * is sixty units of ratchet, and here it is none.
+ */
+export const RENAMED_KEYS = new Map([
+    ['planning.challenge_on_create', 'planning.closure_pass'],
+]);
+/** Keys already warned about in THIS process — the "once per run" dedupe. */
+const _warned = new Set();
+/** Read a dotted path out of a settings tree. `undefined` when absent. */
+function _read(tree, dotted) {
+    let cur = tree;
+    for (const part of dotted.split('.')) {
+        if (cur === null || typeof cur !== 'object' || Array.isArray(cur))
+            return undefined;
+        cur = cur[part];
+    }
+    return cur;
+}
+/** Write a dotted path into a settings tree, creating the intermediate maps. */
+function _write(tree, dotted, value) {
+    const parts = dotted.split('.');
+    let cur = tree;
+    for (const part of parts.slice(0, -1)) {
+        const next = cur[part];
+        if (next === null || typeof next !== 'object' || Array.isArray(next))
+            cur[part] = {};
+        cur = cur[part];
+    }
+    cur[parts[parts.length - 1]] = value;
+}
+/**
+ * Carry every renamed key's value onto its new path within ONE layer, and
+ * return that layer.
+ *
+ * Per LAYER, before the merge, and that ordering is the whole contract: the
+ * shipped template already carries the new key, so a rename applied to the
+ * MERGED tree would always find the target "already set" and drop the user's
+ * value on the floor. Applied per layer, the old key becomes the new key
+ * inside the layer that wrote it, and ordinary precedence does the rest.
+ *
+ * Mutates and returns `layer` so it can wrap an existing merge call without
+ * adding a statement. Never throws: a layer that cannot be walked is a layer
+ * with nothing to migrate.
+ */
+export function applyRenamedKeys(layer) {
+    for (const [oldKey, newKey] of RENAMED_KEYS) {
+        const oldValue = _read(layer, oldKey);
+        if (oldValue === undefined)
+            continue;
+        if (_read(layer, newKey) === undefined)
+            _write(layer, newKey, oldValue);
+        if (_warned.has(oldKey))
+            continue;
+        _warned.add(oldKey);
+        process.stderr.write(`⚠️  settings: \`${oldKey}\` was renamed to \`${newKey}\`. The old key still ` +
+            `works for one minor; rename it in your .agent-settings.yml.\n`);
+    }
+    return layer;
+}
+/** Test seam — the once-per-process warning dedupe is process state. */
+export function _resetRenameWarnings() {
+    _warned.clear();
+}
+//# sourceMappingURL=settings_renamed_keys.js.map

package/dist/server/routes/install.js

@@ -77,12 +77,20 @@ const FileEntrySchema = z.object({
     kind: FileKindSchema,
     sha256: z.string().nullable(),
 });
+// Input type is `unknown` rather than `ConflictEntry`: `ownership` carries a
+// `.default()`, so the parsed OUTPUT always has the field while the accepted
+// INPUT may omit it (older clients on an apply round-trip).
 const ConflictEntrySchema = z.object({
     path: z.string().min(1),
     kind: FileKindSchema,
     plannedSha256: z.string().nullable(),
     existingSha256: z.string().nullable(),
     mergeable: z.boolean(),
+    // Additive (Phase 5.1). `default` keeps apply round-trips from older
+    // clients parsing — they omit the field and get the pre-hash answer.
+    ownership: z
+        .enum(['recorded-unchanged', 'recorded-modified', 'unknown'])
+        .default('unknown'),
 });
 /**
  * Wire-shape of {@link InstallPlan} — Sets serialise as arrays over JSON,

package/dist/server/routes/wizard.js

@@ -17,6 +17,7 @@ import { detectRtk, rtkInstallCommands, RTK_UPSTREAM_REPO } from '../../install/
 import { readSelectedTools, readSelectedPacks, writeSelectedTools } from '../../install/selectedTools.js';
 import { detectAgentSwitch, AGENT_SWITCH_INSTALL_COMMAND, AGENT_SWITCH_REPO } from '../../install/agentSwitchDetection.js';
 import { readDismissedRecommendations, dismissRecommendation } from '../../install/wizardDismissals.js';
+import { installCompleted, installDoneSummary } from '../../install/preserve.js';
 import { apiOnQuotaView } from '../../scripts/ai_council/transport_resolver.js';
 const STATE_REL = join('state', 'wizard-state.json');
 const SETTINGS_REL = join('settings', '.agent-settings.yml');
@@ -1067,6 +1068,7 @@ export function wizardRoute(opts) {
             let written = 0;
             let total = 0;
             let sawTerminal = false;
+            let conflictCount = 0;
             try {
                 await fs.writeFile(tmpPath, JSON.stringify(payload), { mode: 0o600 });
                 const result = await streamInstaller(scriptPath, ['--apply-payload', tmpPath], (obj) => {
@@ -1082,9 +1084,12 @@ export function wizardRoute(opts) {
                             total,
                         });
                     }
+                    else if (t === 'conflicts') {
+                        conflictCount = typeof obj.count === 'number' ? obj.count : conflictCount;
+                    }
                     else if (t === 'done') {
                         sawTerminal = true;
-                        writeFrame(reply, { type: 'done', summary: { written, total } });
+                        writeFrame(reply, { type: 'done', summary: installDoneSummary(obj, written, total) });
                     }
                     else if (t === 'error') {
                         sawTerminal = true;
@@ -1099,8 +1104,9 @@ export function wizardRoute(opts) {
                 // install.py exited without a terminal frame (crash / kill): emit
                 // one so the UI never hangs waiting for `done`/`error`.
                 if (!sawTerminal) {
-                    if (result.exitCode === 0) {
-                        writeFrame(reply, { type: 'done', summary: { written, total } });
+                    if (installCompleted(result.exitCode)) {
+                        const c = { conflicts: result.exitCode === 0 ? 0 : conflictCount };
+                        writeFrame(reply, { type: 'done', summary: installDoneSummary(c, written, total) });
                     }
                     else {
                         writeFrame(reply, {