agent-skillboard 0.2.18 → 0.3.0

package/src/route-advisory.mjs

@@ -119,6 +119,50 @@ export function postUsePolicySuggestionForCapabilityRoute({ matchedCapability, r
   });
 }
 
+export function policyMemoryForV2Route({ intent, selected, candidates, workflowName }) {
+  if (selected.explicit || selected.matchedIntents.length === 0 || candidates.length < 2) {
+    return null;
+  }
+  const alternatives = candidates.slice(1).map((candidate) => candidate.skill.id);
+  const alternativeText = alternatives.join(", ");
+  const context = workflowName === undefined ? "for the current agent" : `in legacy workflow ${workflowName}`;
+  return {
+    status: "applied",
+    mode: "remembered-or-configured-preference",
+    selected_skill: selected.skill.id,
+    available_alternatives: alternatives,
+    summary: `Remembered or configured policy selected ${selected.skill.id} for ${intent} ${context}; other allowed skills were also available: ${alternativeText}.`,
+    finish_disclosure: `I used ${selected.skill.id} for this request because SkillBoard has a remembered or configured preference for it; other allowed skills were also available: ${alternativeText}.`
+  };
+}
+
+export function postUsePolicySuggestionForV2Route({ intent, selected, candidates, workflowName, options, policyMemory }) {
+  if (selected.explicit || policyMemory !== null || candidates.length < 2) {
+    return null;
+  }
+  const context = workflowName === undefined ? "" : ` in ${workflowName}`;
+  return {
+    timing: "after_use",
+    mode: "ask_after_use",
+    reason: `SkillBoard found multiple allowed skills for ${intent} and selected ${selected.skill.id}. After completing the task, ask whether to remember ${selected.skill.id} for similar requests${context}.`,
+    question: `Should I remember ${selected.skill.id} as the preferred skill for similar ${intent} requests${context}?`,
+    requires_confirmation: true,
+    suggested_policy: {
+      kind: "prefer-skill",
+      skill: selected.skill.id,
+      workflow: workflowName ?? null,
+      intent,
+      command_hint: command([
+        "skillboard", "skill", "preference", selected.skill.id,
+        "--intent", intent,
+        "--priority", "100",
+        "--config", routeConfigPath(options),
+        ...(options.skillsRoot === undefined ? [] : ["--skills", routeSkillsRoot(options)])
+      ]).display
+    }
+  };
+}
+
 function postUsePolicySuggestionForDeniedPreferredFallback({ matchedCapability, recommended, routedSkills, workflowName, options }) {
   if (recommended === null || recommended.role !== "fallback" || recommended.guard.allowed !== true) {
     return null;
@@ -199,9 +243,10 @@ export function recommendationReason({ match, matchedFields, matchedTerms, skill
 export function guardCommand(skillId, workflowName, options) {
   return command([
     "skillboard", "guard", "use", skillId,
-    "--workflow", workflowName,
+    ...(workflowName === undefined ? [] : ["--workflow", workflowName]),
+    ...(options.agent === undefined ? [] : ["--agent", options.agent]),
     "--config", routeConfigPath(options),
-    "--skills", routeSkillsRoot(options)
+    ...(options.skillsRoot === undefined && workflowName === undefined ? [] : ["--skills", routeSkillsRoot(options)])
   ]).display;
 }
 

package/src/route-selection.mjs

@@ -24,6 +24,38 @@ export function selectRoute(workspace, workflow, intent) {
   };
 }
 
+export function selectV2Route(workspace, intent, agentName) {
+  const intentKey = phraseKey(intent);
+  const intentTokens = tokensFor(intent);
+  const candidates = workspace.skills
+    .map((skill) => {
+      const guard = canUseSkill(workspace, skill.id, undefined, agentName);
+      const explicit = exactSkillIdMention(intentKey, skill.id);
+      const preference = skill.preference;
+      const matchedIntents = preference?.intents.filter((term) => matchesIntentTerm(intentTokens, term)) ?? [];
+      const installed = installedSkillFor(workspace, skill.id);
+      const metadataTokens = tokensFor(`${installed?.name ?? ""} ${installed?.description ?? ""}`);
+      const metadataMatches = [...metadataTokens].filter((token) => intentTokens.has(token));
+      const hasMatch = explicit || matchedIntents.length > 0 || metadataMatches.length > 0;
+      const preferenceScore = matchedIntents.length > 0 ? (preference?.priority ?? 0) : 0;
+      const rawScore = (explicit ? 1_000_000 : 0)
+          + matchedIntents.length * 100
+          + preferenceScore
+          + metadataMatches.length;
+      const score = hasMatch ? Math.max(1, rawScore) : 0;
+      return { skill, guard, explicit, score, matchedIntents, metadataMatches };
+    })
+    .filter((candidate) => candidate.guard.allowed)
+    .filter((candidate) => candidate.score > 0)
+    .sort((left, right) => right.score - left.score || left.skill.id.localeCompare(right.skill.id));
+  return { candidates, selected: candidates[0] };
+}
+
+function matchesIntentTerm(intentTokens, term) {
+  const termTokens = tokensFor(term);
+  return termTokens.size > 0 && [...termTokens].every((token) => intentTokens.has(token));
+}
+
 function explicitAllowedSkillRouteCandidate(intent, skillCandidates) {
   const intentKey = phraseKey(intent);
   return skillCandidates.find((candidate) => candidate.allowed && exactSkillIdMention(intentKey, candidate.skill_id));
@@ -31,7 +63,10 @@ function explicitAllowedSkillRouteCandidate(intent, skillCandidates) {
 
 function exactSkillIdMention(intentKey, skillId) {
   const skillKey = phraseKey(skillId);
-  return skillKey.length > 0 && intentKey.includes(skillKey);
+  if (skillKey.length === 0) return false;
+  const intentTokens = intentKey.split(" ");
+  const skillTokens = skillKey.split(" ");
+  return intentTokens.some((_, index) => skillTokens.every((token, offset) => intentTokens[index + offset] === token));
 }
 
 function capabilityRouteCandidates(workspace, workflow) {
@@ -173,7 +208,8 @@ function skillMetadataTerms(workspace, skillId, weight) {
 
 function installedSkillFor(workspace, skillId) {
   const skill = workspace.skills.find((candidate) => candidate.id === skillId);
-  return workspace.installedSkills.find((installed) => installed.id === skillId || installed.path === skill?.path);
+  return workspace.installedSkills.find((installed) => installed.id === skillId || installed.path === skill?.path)
+    ?? workspace.inventory?.skills?.find((installed) => installed.id === skillId);
 }
 
 function phraseMatchScore(intent, capability) {

package/src/route.mjs

@@ -4,18 +4,23 @@ import {
   guardCommand,
   overlapResolutionForRoute,
   policyMemoryForRoute,
+  policyMemoryForV2Route,
   postUsePolicySuggestionForCapabilityRoute,
+  postUsePolicySuggestionForV2Route,
   recommendationReason,
   routeCandidate,
   selectedRouteSkill,
   usageDisclosure
 } from "./route-advisory.mjs";
-import { confidenceFor, possibleWorkflowSkills, selectRoute } from "./route-selection.mjs";
+import { confidenceFor, possibleWorkflowSkills, selectRoute, selectV2Route } from "./route-selection.mjs";
 
 export function routeSkill(workspace, options) {
   const intent = options.intent.trim();
   if (intent.length === 0) {
-    throw new Error("Usage: skillboard route <intent> --workflow <name>");
+    throw new Error("Usage: skillboard route <intent> [--agent <name>]");
+  }
+  if (workspace.version === 2) {
+    return routeV2Skill(workspace, options, intent);
   }
   const workflow = workspace.workflows.find((candidate) => candidate.name === options.workflow);
   if (workflow === undefined) {
@@ -97,6 +102,61 @@ export function routeSkill(workspace, options) {
   };
 }
 
+function routeV2Skill(workspace, options, intent) {
+  const { candidates, selected } = selectV2Route(workspace, intent, options.agent);
+  if (selected === undefined) {
+    return {
+      ok: true, intent, workflow: null, agent: options.agent ?? null,
+      matched_capability: null, matched_skill: null, match_source: "none", confidence: "none",
+      matched_terms: [], recommendation_reason: "No enabled skill installed for this agent matched this request.",
+      recommended_skill: null, fallback_skills: [], route_candidates: [], overlap_resolution: null,
+      policy_memory: null, guard_command: null, guard: null, usage_disclosure: null,
+      post_use_policy_suggestion: null, possible_skills: [], candidates: []
+    };
+  }
+  const routed = candidates.map((candidate) => ({
+    skill: candidate.skill.id,
+    role: candidate.explicit ? "matched" : "alternative",
+    guard: candidate.guard
+  }));
+  const matchedTerms = [...new Set([...selected.matchedIntents, ...selected.metadataMatches])];
+  const contextName = options.agent === undefined ? "the current agent" : `agent ${options.agent}`;
+  const recommended = routed[0];
+  const overlapResolution = overlapResolutionForRoute({
+    matchedCapability: intent,
+    recommended,
+    routedSkills: routed,
+    workflowName: contextName
+  });
+  const policyMemory = policyMemoryForV2Route({ intent, selected, candidates, workflowName: undefined });
+  const postUsePolicySuggestion = postUsePolicySuggestionForV2Route({
+    intent, selected, candidates, workflowName: undefined, options, policyMemory
+  });
+  return {
+    ok: true, intent, workflow: null, agent: options.agent ?? null,
+    matched_capability: null,
+    matched_skill: selected.skill.id,
+    match_source: selected.explicit
+      ? "explicit-skill"
+      : selected.matchedIntents.length > 0
+        ? "skill-preference"
+        : "skill-metadata",
+    confidence: confidenceFor(selected.score),
+    matched_terms: matchedTerms,
+    recommendation_reason: `Recommended ${selected.skill.id} because it is enabled, installed for this agent, and best matches the request.`,
+    recommended_skill: selected.skill.id,
+    fallback_skills: candidates.slice(1).map((candidate) => candidate.skill.id),
+    route_candidates: routed.map((entry, index) => routeCandidate(entry, index === 0)),
+    overlap_resolution: overlapResolution, policy_memory: policyMemory,
+    guard_command: guardCommand(selected.skill.id, undefined, options),
+    guard: selected.guard,
+    usage_disclosure: usageDisclosure(selected.skill.id, policyMemory),
+    post_use_policy_suggestion: postUsePolicySuggestion,
+    possible_skills: routed.map((entry) => ({ id: entry.skill, allowed: true })),
+    candidates: candidates.map((candidate) => ({ skill_id: candidate.skill.id, score: candidate.score }))
+  };
+}
+
 function noRoute({ intent, workflow, candidates, skillCandidates, workspace }) {
   return {
     ok: true,

package/src/shared-skill.mjs

@@ -0,0 +1,301 @@
+import { constants as fsConstants } from "node:fs";
+import { copyFile, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { analyzeAgentCompatibility, agentSkillRoot, findSourceSkillInRoots } from "./agent-skill-import.mjs";
+import { detectedAgentSkillRoots, supportedAgentNames } from "./agent-skill-roots.mjs";
+import { setV2SkillShared } from "./control/v2-skill-crud.mjs";
+import { refreshAgentInventory } from "./inventory-refresh.mjs";
+import { loadWorkspace } from "./workspace.mjs";
+
+const MARKER = ".skillboard-share.json";
+
+export async function setSkillSharing(options) {
+  const workspace = await loadWorkspace({ configPath: options.configPath, inventoryPath: options.inventoryPath });
+  const policy = workspace.skills.find((skill) => skill.id === options.skillId);
+  if (policy === undefined) throw new Error(`Unknown skill: ${options.skillId}`);
+  return options.shared
+    ? await shareSkill(options, workspace, policy)
+    : await unshareSkill(options, policy);
+}
+
+async function shareSkill(options, workspace, policy) {
+  const observation = workspace.inventory.skills.find((skill) => skill.id === options.skillId);
+  const installedOn = agents(observation?.installed_on);
+  const sourceAgent = installedOn[0];
+  if (sourceAgent === undefined) {
+    throw new Error(`Skill ${options.skillId} is not installed in a supported agent skill root.`);
+  }
+  const sourceRoots = (await detectedAgentSkillRoots(sourceAgent, options.home, options.env, { includeFallback: true }))
+    .map((entry) => entry.skillRoot);
+  const source = await findSourceSkillInRoots({ roots: sourceRoots, skill: options.skillId });
+  const sourceDir = await realpath(source.skillDir);
+  if (!(await lstat(sourceDir)).isDirectory()) {
+    throw new Error(`Skill source is not a directory: ${source.skillDir}`);
+  }
+  const content = await readFile(source.skillFile, "utf8");
+  const targetAgents = supportedAgentNames().filter((agent) => agent !== sourceAgent && !installedOn.includes(agent));
+  for (const targetAgent of targetAgents) {
+    const compatibility = analyzeAgentCompatibility(content, { sourceAgent, targetAgent });
+    if (!compatibility.compatible) {
+      throw new Error(`Skill ${options.skillId} needs adaptation for ${targetAgent}: ${compatibility.reasons.join("; ")}`);
+    }
+  }
+  const sharedRoot = join(options.home, ".agents", "shared-skills");
+  const sharedDir = shareTarget(sharedRoot, options.skillId);
+  const targets = await Promise.all(targetAgents.map(async (agent) => {
+    const root = await agentSkillRoot(agent, options.home, options.env);
+    return { agent, root, path: shareTarget(root, options.skillId) };
+  }));
+  await assertShareTargetAvailable(sharedRoot, sharedDir, options.home, options.skillId);
+  for (const target of targets) {
+    await assertShareTargetAvailable(target.root, target.path, options.home, options.skillId);
+  }
+  if (options.dryRun) {
+    return sharingResult(options, policy, installedOn, targetAgents, false);
+  }
+
+  const created = [];
+  let policyChanged = false;
+  try {
+    if (await copyManaged(sourceDir, sharedDir, marker(options.skillId, sourceAgent, "shared-source"), options)) {
+      created.push(sharedDir);
+    }
+    for (const target of targets) {
+      if (await exists(target.path)) continue;
+      if (await copyManaged(sharedDir, target.path, marker(options.skillId, sourceAgent, "agent-copy", target.agent), options)) {
+        created.push(target.path);
+      }
+    }
+    await setPolicy(options, true);
+    policyChanged = policy.shared !== true;
+    failpoint(options, "after-policy-write");
+    const refreshed = await refresh(options);
+    const current = refreshedInventoryAgents(refreshed, options);
+    return sharingResult(options, { ...policy, shared: true }, current, targetAgents, true);
+  } catch (error) {
+    const rollbackErrors = [];
+    await Promise.all(created.reverse().map(async (path) => {
+      await rm(path, { recursive: true, force: true }).catch((rollbackError) => rollbackErrors.push(rollbackError));
+    }));
+    if (policyChanged) {
+      await setPolicy(options, policy.shared).catch((rollbackError) => rollbackErrors.push(rollbackError));
+    }
+    throw rollbackOutcome(error, rollbackErrors);
+  }
+}
+
+async function unshareSkill(options, policy) {
+  const managed = [];
+  for (const agent of supportedAgentNames()) {
+    const root = await agentSkillRoot(agent, options.home, options.env);
+    const path = shareTarget(root, options.skillId);
+    if (await managedShare(path, options.skillId)) managed.push(path);
+  }
+  const sharedDir = shareTarget(join(options.home, ".agents", "shared-skills"), options.skillId);
+  if (await managedShare(sharedDir, options.skillId)) managed.push(sharedDir);
+  if (options.dryRun) {
+    return sharingResult(options, policy, [], [], false);
+  }
+  const staged = [];
+  let policyChanged = false;
+  try {
+    await setPolicy(options, false);
+    policyChanged = policy.shared !== false;
+    for (const path of [...new Set(managed)]) {
+      const stagedPath = join(
+        dirname(dirname(path)),
+        `.skillboard-unshare-${basename(path)}-${randomUUID()}`
+      );
+      await rename(path, stagedPath);
+      staged.push({ path, stagedPath });
+    }
+    failpoint(options, "after-files-staged");
+    await refresh(options);
+  } catch (error) {
+    const rollbackErrors = [];
+    for (const entry of staged.reverse()) {
+      await rename(entry.stagedPath, entry.path).catch((rollbackError) => rollbackErrors.push(rollbackError));
+    }
+    if (policyChanged) {
+      await setPolicy(options, policy.shared).catch((rollbackError) => rollbackErrors.push(rollbackError));
+    }
+    throw rollbackOutcome(error, rollbackErrors);
+  }
+  await Promise.all(staged.map((entry) => rm(entry.stagedPath, { recursive: true, force: true })));
+  const workspace = await loadWorkspace({ configPath: options.configPath, inventoryPath: options.inventoryPath });
+  const observation = workspace.inventory.skills.find((skill) => skill.id === options.skillId);
+  return sharingResult(options, { ...policy, shared: false }, agents(observation?.installed_on), [], true);
+}
+
+async function setPolicy(options, shared) {
+  await setV2SkillShared({ skillId: options.skillId, shared, configPath: options.configPath, dryRun: false });
+}
+
+async function refresh(options) {
+  await refreshAgentInventory({
+    root: options.home,
+    configPath: options.configPath,
+    home: options.home,
+    env: options.env
+  });
+  return await loadWorkspace({ configPath: options.configPath, inventoryPath: options.inventoryPath });
+}
+
+function refreshedInventoryAgents(workspace, options) {
+  return agents(workspace.inventory.skills.find((skill) => skill.id === options.skillId)?.installed_on);
+}
+
+async function copyManaged(source, target, metadata, options) {
+  if (await exists(target)) {
+    if (!await managedShare(target, metadata.skill)) {
+      throw new Error(`Share target already exists and is not managed by SkillBoard: ${target}`);
+    }
+    return false;
+  }
+  await mkdir(dirname(target), { recursive: true });
+  try {
+    await mkdir(target);
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      if (await managedShare(target, metadata.skill)) return false;
+      throw new Error(`Share target already exists and is not managed by SkillBoard: ${target}`);
+    }
+    throw error;
+  }
+  try {
+    failpoint(options, "after-copy-target-created");
+    await copyDirectory(source, target);
+    await writeFile(join(target, MARKER), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+    return true;
+  } catch (error) {
+    const rollbackErrors = [];
+    await rm(target, { recursive: true, force: true }).catch((rollbackError) => rollbackErrors.push(rollbackError));
+    throw rollbackOutcome(error, rollbackErrors);
+  }
+}
+
+async function copyDirectory(source, target) {
+  for (const entry of await readdir(source, { withFileTypes: true })) {
+    const sourcePath = join(source, entry.name);
+    const targetPath = join(target, entry.name);
+    if (entry.isDirectory()) {
+      await mkdir(targetPath);
+      await copyDirectory(sourcePath, targetPath);
+    } else if (entry.isFile()) {
+      await copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL);
+    } else if (entry.isSymbolicLink()) {
+      await symlink(await readlink(sourcePath), targetPath);
+    } else {
+      throw new Error(`Unsupported skill entry type: ${sourcePath}`);
+    }
+  }
+}
+
+async function managedShare(path, skillId) {
+  const value = await readFile(join(path, MARKER), "utf8").then(JSON.parse, () => null);
+  return value?.version === 1 && value.skill === skillId;
+}
+
+function marker(skill, sourceAgent, mode, targetAgent = null) {
+  return { version: 1, managed_by: "skillboard", mode, skill, source_agent: sourceAgent, target_agent: targetAgent };
+}
+
+function agents(value) {
+  const supported = new Set(supportedAgentNames());
+  return [...new Set((Array.isArray(value) ? value : []).filter((agent) => supported.has(agent)))].sort();
+}
+
+function sharingResult(options, policy, installedOn, targets, changed) {
+  return {
+    ok: true,
+    skill: options.skillId,
+    shared: options.dryRun ? options.shared : policy.shared,
+    changed,
+    dry_run: options.dryRun,
+    installed_on: agents(installedOn),
+    target_agents: [...targets].sort()
+  };
+}
+
+function failpoint(options, value) {
+  if (options.env?.SKILLBOARD_SHARE_FAILPOINT === value) {
+    throw new Error(`Injected sharing failure ${value}.`);
+  }
+}
+
+function rollbackOutcome(error, rollbackErrors) {
+  if (rollbackErrors.length === 0) return error;
+  const original = error instanceof Error ? error.message : String(error);
+  const rollback = rollbackErrors.map((entry) => entry instanceof Error ? entry.message : String(entry)).join("; ");
+  return new Error(`${original} Rollback also failed: ${rollback}`);
+}
+
+async function exists(path) {
+  return lstat(path).then(() => true, () => false);
+}
+
+function shareTarget(root, skillId) {
+  const value = String(skillId).replace(/\\/g, "/");
+  if (value.trim() === "" || value.includes("\0") || value.startsWith("/") || /^[A-Za-z]:\//.test(value)) {
+    throw new Error("skill id must identify a relative skill directory");
+  }
+  const resolvedRoot = resolve(root);
+  const target = resolve(resolvedRoot, value);
+  const rel = relative(resolvedRoot, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`skill id must stay under the skill root: ${skillId}`);
+  }
+  return target;
+}
+
+async function assertShareTargetAvailable(root, target, home, skillId) {
+  const resolvedRoot = resolve(root);
+  const resolvedHome = resolve(home);
+  const boundary = resolvedRoot === resolvedHome || isInside(resolvedRoot, resolvedHome)
+    ? resolvedHome
+    : resolvedRoot;
+  for (const component of directoryComponents(boundary, dirname(target))) {
+    const stats = await pathStats(component);
+    if (stats?.isSymbolicLink()) {
+      throw new Error(`Share target contains a symbolic link: ${component}`);
+    }
+    if (stats !== null && !stats.isDirectory()) {
+      throw new Error(`Share target directory component is not a directory: ${component}`);
+    }
+  }
+  const stats = await pathStats(target);
+  if (stats === null) return;
+  if (stats.isSymbolicLink()) {
+    throw new Error(`Share target is a symbolic link: ${target}`);
+  }
+  if (!stats.isDirectory() || !await managedShare(target, skillId)) {
+    throw new Error(`Share target already exists and is not managed by SkillBoard: ${target}`);
+  }
+}
+
+function directoryComponents(boundary, targetDir) {
+  const components = [];
+  let current = resolve(targetDir);
+  const root = resolve(boundary);
+  while (current === root || isInside(current, root)) {
+    components.push(current);
+    if (current === root) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return components.reverse();
+}
+
+function isInside(path, parent) {
+  const rel = relative(parent, path);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+async function pathStats(path) {
+  return lstat(path).catch((error) => {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  });
+}

package/src/source-digest.mjs

@@ -0,0 +1,42 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir, readlink } from "node:fs/promises";
+import { join, relative } from "node:path";
+
+const DIGEST_PREFIX = "sha256:";
+
+export async function sourceDigest(path) {
+  const hash = createHash("sha256");
+  hash.update("skillboard-source-digest-v1\n");
+  await addPathDigest(hash, path, path);
+  return `${DIGEST_PREFIX}${hash.digest("hex")}`;
+}
+
+export async function skillContentDigest(skillFilePath) {
+  const hash = createHash("sha256");
+  hash.update(await readFile(skillFilePath));
+  return `${DIGEST_PREFIX}${hash.digest("hex")}`;
+}
+
+async function addPathDigest(hash, root, path) {
+  const stats = await lstat(path);
+  const rel = relative(root, path).replace(/\\/g, "/") || ".";
+  if (stats.isSymbolicLink()) {
+    hash.update(`symlink\0${rel}\0${await readlink(path)}\n`);
+    return;
+  }
+  if (stats.isDirectory()) {
+    hash.update(`dir\0${rel}\n`);
+    const entries = (await readdir(path, { withFileTypes: true }))
+      .filter((entry) => entry.name !== ".git" && entry.name !== "node_modules")
+      .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) await addPathDigest(hash, root, join(path, entry.name));
+    return;
+  }
+  if (!stats.isFile()) {
+    hash.update(`other\0${rel}\n`);
+    return;
+  }
+  hash.update(`file\0${rel}\0${stats.size}\0`);
+  hash.update(await readFile(path));
+  hash.update("\n");
+}