dsh-desktop-kit 2.1.4 → 2.2.1

package/index.js

@@ -15,6 +15,13 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  readManifest,
+  readBaseline,
+  syncSkills,
+  loadSkillState,
+  STATE_FILE,
+} from "./lib/skills-sync.js";
 
 import * as gkbRuUi from "./plugins/dsh-gkb-ru-ui/lib/index.js";
 import * as peakGuard from "./plugins/dsh-peak-guard/index.js";
@@ -25,6 +32,13 @@ import * as tokenLab from "./plugins/dsh-token-lab/lib/index.js";
 import * as skillAutopilot from "./plugins/dsh-skill-autopilot/index.js";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
+const KIT_VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(here, "package.json"), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
 
 const parts = [
   ["dsh-gkb-ru-ui", gkbRuUi],
@@ -39,32 +53,73 @@ const parts = [
 /** The kit itself needs no service; each child declares its own. */
 export const inject = [];
 
-/** Copy bundled skills that the DSH home does not have yet. */
-export function installSkills(logger) {
-  const home = process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+const runtimeState = {
+  kitVersion: KIT_VERSION,
+  startedAt: new Date().toISOString(),
+  skills: null,
+  mountErrors: [],
+  mounted: [],
+};
+
+function skillsHome() {
+  return process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+}
+
+/**
+ * Synchronise bundled skills without ever overwriting a user edit.
+ * Unchanged skills update; modified skills stay and are reported.
+ */
+export function installSkills(logger, options = {}) {
+  const home = skillsHome();
   const source = path.join(here, "skills");
   const target = path.join(home, "skills");
-  if (!fs.existsSync(source)) return 0;
-  fs.mkdirSync(target, { recursive: true });
-  let added = 0;
-  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const destination = path.join(target, entry.name);
-    if (fs.existsSync(destination)) continue;
-    fs.cpSync(path.join(source, entry.name), destination, { recursive: true });
-    added += 1;
+  if (!fs.existsSync(source)) return null;
+  const manifest = readManifest(here);
+  const baseline = readBaseline(here);
+  const result = syncSkills({
+    source,
+    target,
+    kitVersion: KIT_VERSION,
+    manifest,
+    baseline,
+    force: options.force === true,
+    logger,
+  });
+  runtimeState.skills = result;
+  if (result.conflicts.length > 0) {
+    logger?.warn?.(`[dsh-desktop-kit] local edits kept for: ${result.conflicts.join(", ")} (see /kit conflicts)`);
+  }
+  return result;
+}
+
+function kitStatusText() {
+  const home = skillsHome();
+  const state = loadSkillState(path.join(home, "skills"));
+  const skills = runtimeState.skills;
+  const tracked = Object.keys(state.skills).length;
+  const conflicts = Object.keys(state.conflicts).length;
+  const lines = [
+    `DSH Desktop Kit ${KIT_VERSION}`,
+    `Плагины: ${runtimeState.mounted.length}/${parts.length} смонтированы${runtimeState.mountErrors.length > 0 ? `, ошибок: ${runtimeState.mountErrors.length}` : ""}`,
+    `Навыки: пакетных ${tracked} · конфликтов ${conflicts} · состояние ${state.updatedAt || "ещё не записано"}`,
+  ];
+  if (skills) {
+    lines.push(`Последняя синхронизация: +${skills.added.length} ~${skills.updated.length} · конфликтов: ${skills.conflicts.length}`);
+    if (skills.conflicts.length > 0) lines.push(`Конфликты (сохранены ваши правки): ${skills.conflicts.join(", ")}`);
   }
-  if (added > 0) {
-    logger?.info?.(`[dsh-desktop-kit] installed ${added} bundled skills into ${target}`);
+  if (runtimeState.mountErrors.length > 0) {
+    for (const error of runtimeState.mountErrors.slice(0, 5)) lines.push(`Ошибка ${error.name}: ${error.message}`);
   }
-  return added;
+  lines.push(`Состояние: ${path.join(home, "skills", STATE_FILE)}`);
+  lines.push("Команды: /kit status | sync | conflicts | force (перезаписать правки)");
+  return lines.join("\n");
 }
 
 export function apply(ctx) {
   try {
     installSkills(ctx.logger);
   } catch (error) {
-    ctx.logger?.warn?.(`[dsh-desktop-kit] skill install skipped: ${String(error)}`);
+    ctx.logger?.warn?.(`[dsh-desktop-kit] skill sync skipped: ${String(error)}`);
   }
 
   for (const [name, namespace] of parts) {
@@ -75,10 +130,59 @@ export function apply(ctx) {
       } else if (typeof plugin.apply === "function") {
         plugin.apply(ctx);
       }
+      runtimeState.mounted.push(name);
       ctx.logger?.debug?.(`[dsh-desktop-kit] mounted ${name}`);
     } catch (error) {
+      runtimeState.mountErrors.push({ name, message: error instanceof Error ? error.message : String(error) });
       ctx.logger?.warn?.(`[dsh-desktop-kit] ${name} failed to mount: ${String(error)}`);
       console.error(`[dsh-desktop-kit] ${name} failed to mount`, error);
     }
   }
+
+  /* Optional diagnostics command: useful after a DSH/package update. */
+  try {
+    ctx.inject(["commands"], (commandCtx) => {
+      try {
+        const dispose = commandCtx.commands.register({
+          name: "kit",
+          description: "DSH Desktop Kit: состояние, синхронизация навыков, конфликты",
+          input: { hint: "status | sync | conflicts | force" },
+          recordInput: false,
+          handler: ({ rawInput }) => {
+            const command = String(rawInput ?? "").trim().toLowerCase();
+            try {
+              if (command === "sync" || command === "force") {
+                const force = command === "force";
+                const result = installSkills(ctx.logger, { force });
+                return {
+                  kind: "success",
+                  text: result
+                    ? `${force ? "Принудительная синхронизация" : "Синхронизация"}: добавлено ${result.added.length}, обновлено ${result.updated.length}, конфликтов ${result.conflicts.length}.\n${kitStatusText()}`
+                    : "Каталог навыков пакета не найден.",
+                };
+              }
+              if (command === "conflicts") {
+                const skills = runtimeState.skills;
+                if (!skills || skills.conflicts.length === 0) return { kind: "success", text: "Конфликтов нет: все навыки принадлежат пакету." };
+                const lines = skills.conflicts.map((name) => {
+                  const conflict = skills.state?.conflicts?.[name];
+                  return `- ${name}: ${conflict?.reason ?? "изменён пользователем"} — ваша версия сохранена`;
+                });
+                return { kind: "success", text: `Конфликты (${lines.length}):\n${lines.join("\n")}\nОбновить принудительно: /kit force (ваши версии уйдут в бэкап)"` };
+              }
+              return { kind: "success", text: kitStatusText() };
+            } catch (error) {
+              return { kind: "error", text: `DSH Desktop Kit: ${error instanceof Error ? error.message : String(error)}` };
+            }
+          },
+        });
+        ctx.effect(() => dispose, "dsh-desktop-kit: /kit command");
+      } catch (error) {
+        ctx.logger?.warn?.(`[dsh-desktop-kit] /kit command skipped: ${String(error)}`);
+      }
+    });
+  } catch (error) {
+    ctx.logger?.debug?.(`[dsh-desktop-kit] commands service unavailable: ${String(error)}`);
+  }
 }
+

package/install.ps1

@@ -0,0 +1,99 @@
+#requires -Version 5.1
+<#
+.SYNOPSIS
+  Install dsh-desktop-kit into a DeepSeek Harness profile.
+
+.DESCRIPTION
+  Copies nothing into the profile outside pnpm's own dependency install:
+  the kit is linked from this repository, the bundle is added to
+  dsh.profile.bundles, and the DSH launcher is asked to run pnpm.
+  Skills are copied by the kit itself on its first start.
+
+.PARAMETER Profile
+  DSH profile name, default "desktop".
+
+.PARAMETER DshHome
+  DSH home; defaults to $env:DSH_HOME or %USERPROFILE%\.dsh.
+
+.PARAMETER RepoPath
+  Repository root; defaults to this script's folder.
+#>
+param(
+  [string]$Profile = "desktop",
+  [string]$DshHome = "",
+  [string]$RepoPath = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+function Write-Step([string]$Text) {
+  Write-Host ""
+  Write-Host "==> $Text" -ForegroundColor Cyan
+}
+
+if ([string]::IsNullOrWhiteSpace($RepoPath)) { $RepoPath = $PSScriptRoot }
+if (-not (Test-Path (Join-Path $RepoPath "package.json"))) {
+  throw "package.json not found in $RepoPath"
+}
+if ([string]::IsNullOrWhiteSpace($DshHome)) {
+  if ($env:DSH_HOME) { $DshHome = $env:DSH_HOME } else { $DshHome = Join-Path $env:USERPROFILE ".dsh" }
+}
+
+$profileDir = Join-Path $DshHome "profiles\$Profile"
+$profileJson = Join-Path $profileDir "package.json"
+
+Write-Step "Checking the DSH environment"
+$dsh = $null
+$command = Get-Command dsh -ErrorAction SilentlyContinue
+if ($command) { $dsh = $command.Source }
+if (-not $dsh) {
+  $fallback = Join-Path ${env:LOCALAPPDATA} "Programs\DeepSeek Harness\resources\runtime\cli\bin\dsh.cmd"
+  if (Test-Path $fallback) { $dsh = $fallback }
+}
+if (-not $dsh) { throw "dsh CLI not found. Install DeepSeek Harness, run it once, then retry." }
+if (-not (Test-Path $profileJson)) {
+  throw "Profile '$Profile' does not exist ($profileDir). Start DSH once, close it, then retry."
+}
+
+Write-Host "dsh:        $dsh"
+Write-Host "DSH home:   $DshHome"
+Write-Host "Profile:    $Profile"
+Write-Host "Repository: $RepoPath"
+
+$running = Get-Process -Name "DeepSeek Harness" -ErrorAction SilentlyContinue
+if ($running) {
+  Write-Host "DSH is running. Close it before installing so the profile is not written twice." -ForegroundColor Yellow
+}
+
+Write-Step "Backing up the profile manifest"
+$stamp = Get-Date -Format "yyyyMMdd-HHmmss"
+$backupDir = Join-Path $profileDir ("backup-kit-" + $stamp)
+New-Item -ItemType Directory -Path $backupDir -Force | Out-Null
+Copy-Item $profileJson (Join-Path $backupDir "package.json") -Force
+$patchFile = Join-Path $profileDir "cordis.patch.yml"
+if (Test-Path $patchFile) { Copy-Item $patchFile (Join-Path $backupDir "cordis.patch.yml") -Force }
+Write-Host "Backup: $backupDir"
+
+Write-Step "Installing the package through the DSH launcher (pnpm)"
+& $dsh plugin --profile $Profile add $RepoPath
+if ($LASTEXITCODE -ne 0) {
+  throw "dsh plugin add exited with code $LASTEXITCODE. See the output above."
+}
+
+Write-Step "Enabling the bundle in the profile manifest"
+$json = Get-Content -Path $profileJson -Raw | ConvertFrom-Json
+if ($null -eq $json.dsh) { $json | Add-Member -NotePropertyName dsh -NotePropertyValue ([pscustomobject]@{}) }
+if ($null -eq $json.dsh.profile) { $json.dsh | Add-Member -NotePropertyName profile -NotePropertyValue ([pscustomobject]@{}) }
+$bundles = @()
+if ($json.dsh.profile.bundles) { $bundles = @($json.dsh.profile.bundles) }
+if ($bundles -notcontains "dsh-desktop-kit") { $bundles += "dsh-desktop-kit" }
+$json.dsh.profile | Add-Member -NotePropertyName bundles -NotePropertyValue $bundles -Force
+$jsonText = $json | ConvertTo-Json -Depth 20
+[System.IO.File]::WriteAllText($profileJson, $jsonText, (New-Object System.Text.UTF8Encoding($false)))
+
+Write-Step "Done"
+Write-Host "1. Start DeepSeek Harness (restart it if it was running)." -ForegroundColor Green
+Write-Host "2. Settings -> Plugins: 'dsh-desktop-kit' is enabled." -ForegroundColor Green
+Write-Host "3. The kit copies missing skills into $DshHome\skills on first start." -ForegroundColor Green
+Write-Host ""
+Write-Host "Rollback: run uninstall.ps1, or restore package.json from $backupDir." -ForegroundColor DarkGray

package/lib/skills-sync.js

@@ -0,0 +1,245 @@
+/**
+ * Update-safe skill synchronisation.
+ *
+ * Rules:
+ *  - a missing skill is installed;
+ *  - a skill that still matches the hash recorded at the last sync is updated
+ *    (with a backup);
+ *  - a skill the user edited is never overwritten — it is reported as a
+ *    conflict and stays untouched;
+ *  - an installation without a state file is adopted only when its content
+ *    matches a known baseline hash; otherwise it is treated as user-owned.
+ *
+ * The state file lives next to the skills and is written atomically.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export const SKILLS_SYNC_SCHEMA = 1;
+export const STATE_FILE = ".dsh-kit-skills.json";
+export const BACKUP_DIR = ".dsh-kit-backups";
+const SKIP_FILES = new Set([".DS_Store", "Thumbs.db", STATE_FILE]);
+
+function sha256(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+
+export function hashText(text) {
+  return sha256(String(text ?? ""));
+}
+
+/** Deterministic directory hash: sorted relative paths + bytes. */
+export function hashSkillDir(directory) {
+  const hash = crypto.createHash("sha256");
+  let files = 0;
+  let bytes = 0;
+  const walk = (current, relative) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+    for (const entry of entries) {
+      if (SKIP_FILES.has(entry.name)) continue;
+      const full = path.join(current, entry.name);
+      const rel = relative.length > 0 ? `${relative}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        walk(full, rel);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      try {
+        const content = fs.readFileSync(full);
+        hash.update(rel);
+        hash.update("\0");
+        hash.update(String(content.length));
+        hash.update("\0");
+        hash.update(content);
+        files += 1;
+        bytes += content.length;
+      } catch {
+        /* unreadable file: ignore, the hash stays stable */
+      }
+    }
+  };
+  walk(directory, "");
+  return { hash: hash.digest("hex"), files, bytes };
+}
+
+export function readManifest(packageRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(packageRoot, "skills", "manifest.json"), "utf8"));
+    return parsed && parsed.schema === SKILLS_SYNC_SCHEMA && parsed.skills ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readBaseline(packageRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(packageRoot, "skills-baseline.json"), "utf8"));
+    return parsed && parsed.versions ? parsed.versions : {};
+  } catch {
+    return {};
+  }
+}
+
+export function loadSkillState(target) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(target, STATE_FILE), "utf8"));
+    if (!parsed || parsed.schema !== SKILLS_SYNC_SCHEMA) return emptyState();
+    return {
+      ...emptyState(),
+      ...parsed,
+      skills: parsed.skills && typeof parsed.skills === "object" ? parsed.skills : {},
+      conflicts: parsed.conflicts && typeof parsed.conflicts === "object" ? parsed.conflicts : {},
+    };
+  } catch {
+    return emptyState();
+  }
+}
+
+function emptyState() {
+  return { schema: SKILLS_SYNC_SCHEMA, kitVersion: "", updatedAt: "", skills: {}, conflicts: {} };
+}
+
+function writeAtomic(file, text) {
+  const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(temp, text, "utf8");
+  fs.renameSync(temp, file);
+}
+
+export function saveSkillState(target, state) {
+  try {
+    fs.mkdirSync(target, { recursive: true });
+    writeAtomic(path.join(target, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
+  } catch {
+    /* state is an optimization; a failed write must not break skills */
+  }
+}
+
+function copySkill(source, destination) {
+  const parent = path.dirname(destination);
+  fs.mkdirSync(parent, { recursive: true });
+  const temp = path.join(parent, `.${path.basename(destination)}.kit-tmp-${process.pid}-${Date.now()}`);
+  fs.rmSync(temp, { recursive: true, force: true });
+  try {
+    fs.cpSync(source, temp, { recursive: true });
+  } catch (error) {
+    fs.rmSync(temp, { recursive: true, force: true });
+    throw error;
+  }
+  return temp;
+}
+
+function moveWithBackup(target, source, name) {
+  const hadTarget = fs.existsSync(target);
+  let backup = null;
+  if (hadTarget) {
+    const backupRoot = path.join(path.dirname(target), BACKUP_DIR, "skills");
+    fs.mkdirSync(backupRoot, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/gu, "-");
+    backup = path.join(backupRoot, `${name}-${stamp}`);
+    fs.renameSync(target, backup);
+  }
+  try {
+    fs.renameSync(source, target);
+  } catch (error) {
+    if (backup && !fs.existsSync(target)) {
+      try { fs.renameSync(backup, target); } catch { /* best effort */ }
+    }
+    throw error;
+  }
+  return backup;
+}
+
+/**
+ * Synchronise bundled skills into `target`.
+ * @returns {{added:string[],updated:string[],adopted:string[],kept:string[],conflicts:string[],removed:string[],state:object}}
+ */
+export function syncSkills({ source, target, kitVersion, manifest, baseline, force = false, logger } = {}) {
+  const result = { added: [], updated: [], adopted: [], kept: [], conflicts: [], removed: [], state: emptyState() };
+  if (typeof source !== "string" || typeof target !== "string" || !fs.existsSync(source)) return result;
+  fs.mkdirSync(target, { recursive: true });
+  const state = loadSkillState(target);
+  state.kitVersion = kitVersion ?? state.kitVersion;
+  state.updatedAt = new Date().toISOString();
+  state.schema = SKILLS_SYNC_SCHEMA;
+  const knownBaselines = new Map();
+  for (const version of Object.values(baseline ?? {})) {
+    for (const [name, hash] of Object.entries(version ?? {})) {
+      if (!knownBaselines.has(name)) knownBaselines.set(name, new Set());
+      knownBaselines.get(name).add(hash);
+    }
+  }
+  const bundled = [];
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    if (entry.isDirectory()) bundled.push(entry.name);
+  }
+  bundled.sort();
+
+  for (const name of bundled) {
+    const sourceDir = path.join(source, name);
+    const targetDir = path.join(target, name);
+    const sourceInfo = hashSkillDir(sourceDir);
+    const manifestHash = manifest?.skills?.[name]?.hash;
+    const sourceHash = sourceInfo.hash;
+    const targetExists = fs.existsSync(targetDir);
+    const entry = state.skills[name];
+    const targetHash = targetExists ? hashSkillDir(targetDir).hash : "";
+
+    if (!targetExists) {
+      const temp = copySkill(sourceDir, targetDir);
+      moveWithBackup(targetDir, temp, name);
+      state.skills[name] = { hash: sourceHash, updatedAt: state.updatedAt, kitVersion: state.kitVersion };
+      delete state.conflicts[name];
+      result.added.push(name);
+      continue;
+    }
+    if (targetHash === sourceHash || (manifestHash && targetHash === manifestHash && sourceHash === manifestHash)) {
+      state.skills[name] = { hash: sourceHash, updatedAt: entry?.updatedAt ?? state.updatedAt, kitVersion: state.kitVersion };
+      delete state.conflicts[name];
+      if (!entry) result.adopted.push(name);
+      continue;
+    }
+    const unchangedSinceSync = Boolean(entry && targetHash === entry.hash);
+    const knownBaseline = !entry && Boolean(knownBaselines.get(name)?.has(targetHash));
+    if (force || unchangedSinceSync || knownBaseline) {
+      const temp = copySkill(sourceDir, targetDir);
+      moveWithBackup(targetDir, temp, name);
+      state.skills[name] = { hash: sourceHash, updatedAt: state.updatedAt, kitVersion: state.kitVersion };
+      delete state.conflicts[name];
+      result.updated.push(name);
+      continue;
+    }
+    state.conflicts[name] = {
+      reason: entry ? "modified-since-last-sync" : "modified-unknown-base",
+      hash: targetHash,
+      at: state.updatedAt,
+    };
+    result.kept.push(name);
+    result.conflicts.push(name);
+  }
+
+  /* Skills removed from the bundle are never deleted: they may be user-owned. */
+  for (const name of Object.keys(state.skills)) {
+    if (!bundled.includes(name) && fs.existsSync(path.join(target, name))) result.removed.push(name);
+  }
+
+  saveSkillState(target, state);
+  result.state = state;
+  if (result.added.length + result.updated.length > 0) {
+    logger?.info?.(`[dsh-desktop-kit] skills: +${result.added.length} ~${result.updated.length}, conflicts ${result.conflicts.length}`);
+  }
+  return result;
+}
+
+export function kitManifestSummary(manifest) {
+  if (!manifest?.skills) return { count: 0, bytes: 0 };
+  const values = Object.values(manifest.skills);
+  return { count: values.length, bytes: values.reduce((sum, skill) => sum + (Number(skill.bytes) || 0), 0) };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-desktop-kit",
-  "version": "2.1.4",
-  "description": "DeepSeek Harness desktop kit 2.1: self-applying skills, live token lab, Skills Studio, self-scanning project memory, Russian UI, peak guard, chat move and profile transfer.",
+  "version": "2.2.1",
+  "description": "DeepSeek Harness desktop kit 2.2: update-safe self-applying skills, live token lab, Skills Studio, self-scanning project memory, Russian UI, peak guard, chat move and profile transfer.",
   "keywords": [
     "deepseek-harness",
     "dsh",
@@ -32,8 +32,14 @@
     "client.js",
     "cordis.patch.yml",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
+    "doctor.ps1",
+    "install.ps1",
+    "uninstall.ps1",
+    "lib/**",
     "docs/**",
+    "skills-baseline.json",
     "plugins/*/package.json",
     "plugins/*/*.js",
     "plugins/*/lib/**",
@@ -47,8 +53,9 @@
   ],
   "scripts": {
     "build:client": "node tools/build-client.mjs",
+    "build:skills": "node tools/build-skill-manifest.mjs",
     "check:client": "node tools/check-client.mjs client.js",
-    "test": "node tools/smoke-tests.mjs && node tools/memory-tests.mjs",
+    "test": "node tools/smoke-tests.mjs && node tools/memory-tests.mjs && node tools/skills-sync-tests.mjs && node tools/kit-upgrade-tests.mjs",
     "skills:cost": "node tools/skill-cost.mjs",
     "skills:check": "node tools/skill-cost.mjs --check"
   },

package/skills/manifest.json

@@ -0,0 +1,132 @@
+{
+  "schema": 1,
+  "kitVersion": "2.2.1",
+  "generatedAt": "2026-11-06T12:03:12.122Z",
+  "skills": {
+    "code-review-checklist": {
+      "hash": "e665bf72cfbfb77948a3cd6df6ebced38777f9aff543d7b9c80b2ced8cccc662",
+      "files": 1,
+      "bytes": 4483
+    },
+    "content-writing": {
+      "hash": "a21b26ff814e0337d03eeb587b200a1dc66e7de91bfea0f32840ddf8884deeee",
+      "files": 28,
+      "bytes": 271717
+    },
+    "context-economy": {
+      "hash": "bc8fa2e15327d21cf9ebd187b0df5f620d6a5b617976fa88910ae7877eb46b75",
+      "files": 4,
+      "bytes": 12766
+    },
+    "database-safety": {
+      "hash": "56f43f6bac270aefce34355e2a932192e4d17725d8faec5f91f476792b28c617",
+      "files": 1,
+      "bytes": 4448
+    },
+    "debugging-playbook": {
+      "hash": "0d70b8102f04d29774e466efd81abb448c84a6537a2ca3438f6931a2d6fe0c3a",
+      "files": 1,
+      "bytes": 4443
+    },
+    "design-critique": {
+      "hash": "bbc6ca34b0b76798d581dcd78e83a59040dfac028b5e10d8e7a9be28225410b8",
+      "files": 6,
+      "bytes": 25754
+    },
+    "dev-workflow": {
+      "hash": "832d36da6d3dc3e6e7d1feb18c38260ed8669c7702dffbd2d7a96fc9bc93d22f",
+      "files": 4,
+      "bytes": 17194
+    },
+    "git-and-ci": {
+      "hash": "0681041edb935da2c124265bbdacd3b6a0a96c7f163323960cff8c8ea67fd2f4",
+      "files": 1,
+      "bytes": 4192
+    },
+    "pg-upgrade-verify": {
+      "hash": "d734178c5dad317fc55842215bbeeba85230cdd8e7b0ea46d74eed92910b8dea",
+      "files": 1,
+      "bytes": 4496
+    },
+    "project-deep-dive": {
+      "hash": "a70355f2a40b42a6ff03e745ba42389549b4efe4f392c98033fe5073f946452e",
+      "files": 4,
+      "bytes": 26290
+    },
+    "project-memory-maintenance": {
+      "hash": "648f175093f6a86e20157156d8731b8e9602badedc79188e77160b18832f4893",
+      "files": 4,
+      "bytes": 23469
+    },
+    "release-and-deploy": {
+      "hash": "e6ed27856b00e8759d31659162290307c16e203d2b5d28fcacb574be17fc795b",
+      "files": 1,
+      "bytes": 4409
+    },
+    "requirements-and-planning": {
+      "hash": "532cbccfb2d0f7eca06343927aba100bd653145ccd9b9173ca50299194631a05",
+      "files": 4,
+      "bytes": 12964
+    },
+    "security-review": {
+      "hash": "8665b2c469de8e83aca670021d5c335fa8c9b93b8dc6bb866759e6062b1abde4",
+      "files": 1,
+      "bytes": 4257
+    },
+    "seo": {
+      "hash": "ed48ebc4c1278f857ff430f9a5ec55f638c2f9ba07cc406185cfb94be18ee80d",
+      "files": 29,
+      "bytes": 386169
+    },
+    "service-desk-conventions": {
+      "hash": "22ae6c29b7debb0154d183bc732795b67557aeaa0ac906d7b038134aea8ba39a",
+      "files": 1,
+      "bytes": 4488
+    },
+    "service-desk-db-safety": {
+      "hash": "672c08d25e0a9262aeb0eec27b6daa2a619fade6ff3269bc2b9dc27e22c83d28",
+      "files": 1,
+      "bytes": 4482
+    },
+    "service-desk-release": {
+      "hash": "1bd0c03f772bf4b79ec4e887f5d0ebd564653bafd3d0d33d70f6c934afdcce47",
+      "files": 1,
+      "bytes": 4418
+    },
+    "service-desk-testing": {
+      "hash": "eaff64154a596590684308cdccb3f55099240589b57c0f506a85e5b38ddf5ac5",
+      "files": 1,
+      "bytes": 4129
+    },
+    "service-desk-ui": {
+      "hash": "a3a0e78ab147f4837e4ca9736f4d87cf77a6638c2db7c5859629df70abdd2c1c",
+      "files": 1,
+      "bytes": 4201
+    },
+    "skills-router": {
+      "hash": "63c2dcdeb07dd4af464a30a8065465bd06b73e4caa8aa874802e5188d4d5a4ae",
+      "files": 3,
+      "bytes": 13888
+    },
+    "testing-strategy": {
+      "hash": "773fdf1e389e59841b7766862f8890a11fba4a2fce42a2022b9c4bfaae8f6ecc",
+      "files": 1,
+      "bytes": 4279
+    },
+    "ui-design-system": {
+      "hash": "19244221171995b758dbad02f2e3602859308370b50cc37d93c6f2a6d44cd6f1",
+      "files": 4,
+      "bytes": 19454
+    },
+    "web-research": {
+      "hash": "9bf4d8ba6d2a0fc39c241cdd9f5fe54835af28872473aa617941589c526387c8",
+      "files": 3,
+      "bytes": 14150
+    },
+    "wow-design": {
+      "hash": "81139f32fc759f438a36eb4c0212ed3ea17df9d8075e909580e12bc47a0848dd",
+      "files": 52,
+      "bytes": 913669
+    }
+  }
+}