@h1v35/hivex 0.2.1 → 0.2.2

package/README.md

@@ -109,10 +109,18 @@ bun hivex snapshot export --root /path/to/project
 bun hivex snapshot import --root /path/to/project
 ```
 
-`snapshot export` writes `.hivex/graph.json` atomically as stable, readable JSON. Commit that file alongside the Markdown it describes to share decisions, relationships, source versions, evidence, available provenance and coverage. It exports the graph, not work records, process identities, budgets or cached model answers. Both snapshot operations make zero model calls.
+`snapshot export` writes `.hivex/graph.json` atomically as stable, readable JSON. Commit that file alongside the Markdown it describes to share decisions, relationships, source versions, evidence, available provenance and coverage. It exports the graph, not work records, process identities, budgets or cached model answers. Snapshot operations make zero model calls.
 
 A fresh clone can use `search`, `neighbors` and `status` directly from the shared snapshot without creating a local database. Its first update reuses matching ingestion units and starts local work accounting. If a local graph already exists, it takes precedence: use `snapshot import` to adopt a new shared version. Import refuses while local work is unfinished and never resets attempts or budgets. Complete or recover that work through its normal lifecycle first.
 
+When Markdown moves, explicitly relocate its knowledge before the next update:
+
+```sh
+bun hivex snapshot relocate docs/old-guide.md docs/guidelines/guide.md --root /path/to/project
+```
+
+The old source must no longer be selected, and the destination must be selected current Markdown. Relocation preserves IDs, relationships, source versions and uncertainty, leaving existing work, cached answers and budgets intact. It makes zero model calls and refuses unfinished local work. An identical move to a destination without prior knowledge reuses ingestion coverage when all retained source evidence has matching, known versions. If content changed, source versions are mixed or missing, or the destination already had knowledge, its coverage becomes pending so the usual update/check can validate the result. Mismatched evidence remains stale until then. Keep the relocation report with the change and export the final graph; do not use relocation to hide unrelated missing evidence.
+
 The snapshot response identifies current, stale and unavailable source versions, pending units and warnings. A changed or absent source is not silently current; matching sources remain reusable. Partial and uncertain knowledge can be shared with those states retained. Freshness is not proof that a model interpretation is correct: the cited Markdown remains authority.
 
 Keep only the shared graph under version control, for example:
@@ -139,7 +147,7 @@ bun run format:check
 bun run test
 ```
 
-Tests use the public CLI and a simulated native transport. Real Luna evaluations are bounded and reported separately; simulated token usage is not a consumption measurement. Development is issue-first, with coherent PRs, independent Standards/Spec review and CI on the final commit. See the [engineering workflow](docs/engineering.md).
+Tests use the public CLI and a simulated native transport. Real Luna evaluations are bounded and reported separately; simulated token usage is not a consumption measurement. Development is issue-first, with coherent PRs, independent Standards/Spec review and CI on the final commit. See the [engineering workflow](docs/guidelines/engineering.md).
 
 Earlier candidate/fidelity/comparison/admission protocols and their tests are retired from the active CLI. Their code remains in Git history and historical evidence keeps its original results. They do not impose a requirement to reproduce an Opus graph or exhaustively replay an old gold suite.
 

package/docs/CONTEXT.md

@@ -34,6 +34,8 @@ Hivex supplies project knowledge to the agents responsible for implementation an
 
 **Interpretation repair**: Replacing a wrong derived interpretation by comparing it with unchanged Markdown. It preserves source authority and does not resolve a genuine policy conflict by itself.
 
+**Source relocation**: Moving existing knowledge to a document's new location, retaining its decisions and relationships while distinguishing reusable evidence from content that needs a new check.
+
 **Context**: The decisions, related evidence and remaining uncertainties relevant to a particular task.
 
 **Implementation version**: The captured change against a particular base together with the exact contents of the affected files. Later code changes are outside that review.

package/docs/README.md

@@ -1,7 +1,8 @@
 # Documentation map
 
 - [Domain language](CONTEXT.md): documents, decisions, relationships, evidence and bounded work.
-- [Engineering workflow](engineering.md): development, verification and knowledge maintenance.
+- [Engineering guidelines](guidelines/engineering.md): development, verification and knowledge maintenance.
+- [Runner procedure](procedures/self-hosted-runner.md): install and move the repository's CI runner.
 - [Practical knowledge assistance](adr/0010-practical-knowledge-assistance.md): the current approved contract, staged delivery, autonomy, semantic relationships, uncertainty and cost.
 - [Shared knowledge and selective history](adr/0011-shared-knowledge-and-selective-history.md): accepted extension for compact ADRs, bounded historical retrieval and a Git-versioned knowledge snapshot.
 - [Recommended Markdown convention](../skills/hivex/references/markdown.md): optional organization and writing practices for any adopting project.

package/docs/adr/0011-shared-knowledge-and-selective-history.md

@@ -25,3 +25,7 @@ Use deterministic structural and source-version checks to distinguish reusable k
 This extends ADR 0010's portable second-brain contract and supersedes a blanket recommendation to ignore every artifact under `.hivex/`. The CLI supports explicit snapshot export/import and reuses the snapshot in a fresh clone. Configurable `history` globs keep historical sources available for focused retrieval while excluding them from ordinary ingestion. A saved snapshot alone does not complete a project's rollout; publication and process retirement follow the project's normal workflow.
 
 Delivery is tracked by [#53](https://github.com/H1V35/hivex/issues/53) (shared graph snapshot) and [#54](https://github.com/H1V35/hivex/issues/54) (selective historical sources), under [the approved extension to #17](https://github.com/H1V35/hivex/issues/17#issuecomment-5631587186). The CLI remains the existing behavioral test boundary for both independent deliveries.
+
+## Source relocation — 2026-09-13 (#64)
+
+An explicit source relocation keeps knowledge usable when documentation changes location. It preserves decision and relationship identities, source versions, uncertainty and existing work history. An identical move can reuse ingestion coverage without a model call. Changed content or consolidation requires the normal update/check at the destination; relocation does not approve that interpretation or make mismatched evidence current. Refuse relocation while local work is unfinished, preserve original work and model answers, and record the source/destination and versions in the operation report. Commit the exported graph with the corresponding source changes so their history remains auditable.

package/docs/{engineering.md → guidelines/engineering.md}

@@ -19,13 +19,9 @@ Independent code reviewers use the coordinating agent's current model and reason
 
 Choose verification for the affected surfaces. Code changes require typechecking, lint, formatting and relevant behavior tests; documentation-only changes need formatting and checks of affected references or declared sources. Record the exact revision and the checks actually completed. A later change invalidates the affected results. Do not claim an omitted, interrupted or truncated check passed.
 
-GitHub Actions runs the quality workflow on the owner's Mac through an official self-hosted runner, using `[self-hosted, macOS, ARM64, hivex]`. GitHub retains secrets, logs and PR checks; no hosted runner fallback is configured. No speed benchmark is required. A queued, skipped or interrupted run is not a pass. Local verification remains required when the runner is unavailable.
+GitHub Actions runs the quality workflow on the owner's Mac through an official self-hosted runner, using `[self-hosted, macOS, ARM64, hivex]`. GitHub retains secrets, logs and PR checks; no hosted runner fallback is configured. No speed benchmark is required. A queued, skipped or interrupted run is not a pass. Local verification remains required when the runner is unavailable. Installation and host migration follow the [runner procedure](../procedures/self-hosted-runner.md).
 
-Runner installation is repository administration, outside Hivex's product. Register the admitted macOS ARM64 release from GitHub's runner settings in its own directory, verify the official checksum, and use the generated `svc.sh install/start/status/stop` commands. Keep automatic updates enabled, a stable Homebrew/system PATH and the Mac awake and connected under the logged-in user. The runner work directory must be separate from the developer checkout and other repository runners. Only trusted code may run on this persistent host; review that boundary before public contributions. See [GitHub's runner reference](https://docs.github.com/en/actions/reference/runners/self-hosted-runners).
-
-During a host migration, disable Actions, register and confirm the runner is online, and merge all workflow routes before re-enabling Actions. Then dispatch Quality on that exact revision and check the assigned runner and completed result. The route change alone is not functional verification.
-
-Use `bun install` for development and `bun ci` for frozen installation. Bun owns dependency installation through its native configuration and lockfile; Hivex has no custom installer or registry verifier. See the [installation decision](adr/0003-independent-bun-installation.md).
+Use `bun install` for development and `bun ci` for frozen installation. Bun owns dependency installation through its native configuration and lockfile; Hivex has no custom installer or registry verifier. See the [installation decision](../adr/0003-independent-bun-installation.md).
 
 Lint uses the published Ultracite ESLint/Prettier core presets with the owner's selected preferences: maximum cyclomatic complexity 20, cognitive complexity 15, nesting depth 3 and four parameters per function; print width 100 and single quotes; unused variables, arguments and caught errors may have a leading `_`, and loose equality is allowed when comparing with `null`. Keep the rest of the presets unchanged. Naming and unused-variable checks allow the leading `_` for unused bindings. The overlapping SonarJS unused-variable rule, `no-eq-null` and optional-catch-binding preference are disabled because they cannot express those exceptions; the configured unused-variable and equality rules still check ordinary names and comparisons. Use `eslint-plugin-boundaries` to enforce actual module responsibilities and keep additional policy minimal and tied to domain behavior. Configuration and dependency versions belong in the executable project configuration. Refactor around meaningful responsibilities instead of adding wrappers to satisfy arbitrary thresholds.
 
@@ -61,7 +57,7 @@ Keep docs with the monorepo, workspace or module they describe. Link to common r
 
 Use repository decisions and review evidence for durable knowledge, not private agent memory. Checkpoints identify the exact commit, verified work and remaining work. Choose a context handoff when the task needs it; Hivex does not impose the retired machinery's fixed token thresholds. Knowledge-model operations use the admitted Luna/max profile and record actual usage, including failed or interrupted attempts. Deterministic retrieval and maintenance do not require a model.
 
-The replacement workflow follows [ADR 0010](adr/0010-practical-knowledge-assistance.md). It processes bounded document batches with one additional knowledge check, keeps partial knowledge usable and preserves a work budget across phases and resumption. A consultation maintains one pending batch before answering, and a source-based repair replaces interpretations without changing doctrine. Keep check warnings scoped and public evidence limited to source coordinates, version and text. Avoid a new abstraction or protocol unless it protects a concrete requirement. The owner-authorized implementation can replace the earlier cohort/admission pipeline; its historical evidence remains unchanged.
+The replacement workflow follows [ADR 0010](../adr/0010-practical-knowledge-assistance.md). It processes bounded document batches with one additional knowledge check, keeps partial knowledge usable and preserves a work budget across phases and resumption. A consultation maintains one pending batch before answering, and a source-based repair replaces interpretations without changing doctrine. Keep check warnings scoped and public evidence limited to source coordinates, version and text. Avoid a new abstraction or protocol unless it protects a concrete requirement. The owner-authorized implementation can replace the earlier cohort/admission pipeline; its historical evidence remains unchanged.
 
 Hivex assists the principal reviewer with decisions, dependencies, exceptions and possible conflicts. The reviewer verifies its findings. Missing context or uncertainty limits the conclusions it affects; a definitive finding must refer to the actual document and implementation versions reviewed.
 

package/docs/procedures/self-hosted-runner.md

@@ -0,0 +1,7 @@
+# Self-hosted GitHub Actions runner
+
+Follow the [engineering guidelines](../guidelines/engineering.md#development-and-verification) for runner labels, execution boundaries and verification requirements.
+
+Runner installation is repository administration, outside Hivex's product. Register the admitted macOS ARM64 release from GitHub's runner settings in its own directory, verify the official checksum, and use the generated `svc.sh install/start/status/stop` commands. Keep automatic updates enabled, a stable Homebrew/system PATH and the Mac awake and connected under the logged-in user. The runner work directory must be separate from the developer checkout and other repository runners. Only trusted code may run on this persistent host; review that boundary before public contributions. See [GitHub's runner reference](https://docs.github.com/en/actions/reference/runners/self-hosted-runners).
+
+During a host migration, disable Actions, register and confirm the runner is online, and merge all workflow routes before re-enabling Actions. Then dispatch Quality on that exact revision and check the assigned runner and completed result. The route change alone is not functional verification.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h1v35/hivex",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Versioned project knowledge for people and agents.",
   "scripts": {
@@ -63,7 +63,8 @@
     "!src/**/*.test.ts",
     "docs/README.md",
     "docs/CONTEXT.md",
-    "docs/engineering.md",
+    "docs/guidelines/engineering.md",
+    "docs/procedures/self-hosted-runner.md",
     "docs/adr/0003-independent-bun-installation.md",
     "docs/adr/0010-practical-knowledge-assistance.md",
     "docs/adr/0011-shared-knowledge-and-selective-history.md",

package/skills/hivex/SKILL.md

@@ -53,6 +53,10 @@ Repair a demonstrably wrong interpretation with `update --repair <document> --re
 
 A clone without local knowledge can read the snapshot directly and reuse its matching units on the first update. Existing local knowledge takes precedence; `hivex snapshot import` explicitly adopts the shared graph and refuses if work is unfinished. Preserve that work and its accounting rather than deleting the store to force import. Stale or unavailable source versions remain explicit, and source freshness is not semantic approval. Export when knowledge changes; ordinary reads do not dirty the shared artifact.
 
+When Markdown moves, use `hivex snapshot relocate <old-document> <new-document>` before updating knowledge. The old source must no longer be selected, and the destination must be selected current Markdown. This explicit operation preserves decision and relationship IDs and does not call the model or rewrite earlier work, answers, attempts or budgets. Unfinished work must be resolved through its normal lifecycle first.
+
+An identical document at a previously unknown destination reuses its knowledge and ingestion coverage when retained evidence has matching, known source versions. Changed content, mixed or missing source versions, or consolidation into an existing destination leaves that destination pending for the normal update/check; it does not certify the old interpretation against new text. Retain the relocation report with the change and export the resulting graph alongside its Markdown. Do not relocate unrelated knowledge merely to hide unavailable evidence.
+
 ## Control consumption
 
 Large Markdown is ingested in bounded rounds. Inspect pending units and coverage, and resume the same work; do not wipe the store or resend the whole corpus when only a later round remains.

package/skills/hivex/references/markdown.md

@@ -18,7 +18,7 @@ A useful catalogue distinguishes:
 - Procedures for concrete operational or recovery tasks.
 - Research and evidence identified as dated support, not automatically current decisions.
 
-For example, a project may use `docs/README.md`, `docs/CONTEXT.md`, `docs/adr/`, `docs/guidelines/`, `docs/process/`, `docs/procedures/` and `docs/research/`. These are examples, not required paths. Multiple bounded contexts may have their own glossary and decisions with a small context map linking them; a monorepo need not duplicate one shared product glossary.
+For example, a project may use `docs/README.md`, `docs/CONTEXT.md`, `docs/adr/`, `docs/guidelines/`, `docs/procedures/` and `docs/research/`. Keep standing rules and design guidance in `guidelines`, and instructions for carrying out tasks in `procedures`; avoid overlapping directories with indistinct purposes. These are examples, not required paths. Multiple bounded contexts may have their own glossary and decisions with a small context map linking them; a monorepo need not duplicate one shared product glossary.
 
 ## Write decisions for the next reader
 

package/src/cli.ts

@@ -67,7 +67,7 @@ const main = async (input: string[]) => {
         {
           modelCalls: 0,
           name: 'snapshot',
-          usage: 'snapshot export | import [--root <project>]',
+          usage: 'snapshot export | import | relocate <from> <to> [--root <project>]',
         },
         { modelCalls: 0, name: 'status', usage: 'status [--root <project>]' },
       ],

package/src/snapshot-command.ts

@@ -5,19 +5,26 @@ import { ingestionUnits } from './ingestion-units.ts';
 import { KnowledgeStore } from './knowledge-store.ts';
 import { readKnowledgeSnapshot, writeKnowledgeSnapshot } from './knowledge-snapshot.ts';
 import { loadProject } from './documents.ts';
+import { relocateSource } from './source-relocation.ts';
 import type { Graph } from './knowledge-model.ts';
 import type { Project } from './documents.ts';
+import type { SourceRelocation } from './source-relocation.ts';
 
 const sourceVersion = function sourceVersion([document, version]: [string, string]) {
   return { document, version };
 };
 
+const warningScopes = function warningScopes(warning: Graph['warnings'][number]) {
+  return typeof warning === 'string' ? [] : warning.scope;
+};
+
 const sourceVersions = function sourceVersions(project: Project, graph: Graph) {
   const references = [
     ...Object.entries(graph.documents).map(sourceVersion),
     ...Object.values(graph.units),
     ...graph.decisions,
     ...graph.relationships.flatMap((edge) => edge.evidence),
+    ...graph.warnings.flatMap(warningScopes),
   ];
   const current = new Set<string>();
   const stale = new Set<string>();
@@ -68,6 +75,15 @@ const snapshotReport = function snapshotReport(project: Project, graph: Graph, o
   };
 };
 
+const relocationReport = function relocationReport(project: Project, relocation: SourceRelocation) {
+  return {
+    ...snapshotReport(project, relocation.graph, 'relocate'),
+    from: { document: relocation.from, versions: relocation.fromVersions },
+    reused: relocation.reused,
+    to: { document: relocation.to, version: relocation.destinationVersion },
+  };
+};
+
 export const snapshotCommand = function snapshotCommand(argumentsList: string[]) {
   const { positionals, values } = parseArgs({
     allowPositionals: true,
@@ -75,18 +91,27 @@ export const snapshotCommand = function snapshotCommand(argumentsList: string[])
     options: { root: { type: 'string' } },
     strict: true,
   });
-  const [, operation] = positionals;
+  const [, operation, from, to] = positionals;
+  const isRelocate = operation === 'relocate';
+  const expectedPositionals = isRelocate ? 4 : 2;
+  const isValidOperation = operation === 'export' || operation === 'import' || isRelocate;
   if (
-    positionals.length !== 2 ||
-    positionals[0] !== 'snapshot' ||
-    (operation !== 'export' && operation !== 'import')
+    !isValidOperation ||
+    positionals.length !== expectedPositionals ||
+    positionals[0] !== 'snapshot'
   ) {
     throw new HivexError({
       code: 'INVALID_ARGUMENT',
-      message: 'Use snapshot export | import [--root <project>]',
+      message: 'Use snapshot export | import | relocate <from> <to> [--root <project>]',
     });
   }
   const project = loadProject(values.root ?? process.cwd());
+  if (isRelocate) {
+    using store = new KnowledgeStore(project.root, { update: true });
+    const relocation = relocateSource(store.graph(), project, from ?? '', to ?? '');
+    store.importGraph(relocation.graph);
+    return relocationReport(project, relocation);
+  }
   const incoming = operation === 'import' ? readKnowledgeSnapshot(project.root) : null;
   if (operation === 'import' && incoming === null) {
     throw new HivexError({

package/src/source-relocation.ts

@@ -0,0 +1,222 @@
+import { compareSerializedStrings } from './ordering.ts';
+import { HivexError } from './errors.ts';
+import { isMarkdownPath } from './markdown.ts';
+import type { Project } from './documents.ts';
+import type { Graph } from './knowledge-model.ts';
+
+const protectedParts = new Set(['', '.', '..', '.git', '.hivex', 'node_modules']);
+
+const isPortablePath = function isPortablePath(value: string) {
+  if (!isMarkdownPath(value) || value.startsWith('/')) {
+    return false;
+  }
+  if (value.includes('\\') || value.includes('\0')) {
+    return false;
+  }
+  return value.split('/').every((part) => !protectedParts.has(part));
+};
+
+const fail = function fail(code: string, message: string): never {
+  throw new HivexError({ code, message });
+};
+
+const relationshipVersions = function relationshipVersions(
+  relationship: Graph['relationships'][number],
+  document: string
+) {
+  return relationship.evidence
+    .filter((evidence) => evidence.document === document)
+    .flatMap((evidence) => (evidence.version === undefined ? [] : [evidence.version]));
+};
+
+const warningVersions = function warningVersions(
+  warning: Graph['warnings'][number],
+  document: string
+) {
+  if (typeof warning === 'string') {
+    return [];
+  }
+  return warning.scope.filter((scope) => scope.document === document).map((scope) => scope.version);
+};
+
+const sourceVersions = function sourceVersions(graph: Graph, document: string) {
+  const versions = [
+    graph.documents[document],
+    ...Object.values(graph.units)
+      .filter((unit) => unit.document === document)
+      .map((unit) => unit.version),
+    ...graph.decisions
+      .filter((decision) => decision.document === document)
+      .map((decision) => decision.version),
+    ...graph.relationships.flatMap((relationship) => relationshipVersions(relationship, document)),
+    ...graph.warnings.flatMap((warning) => warningVersions(warning, document)),
+  ].filter((version): version is string => version !== undefined);
+  return [...new Set(versions)].toSorted(compareSerializedStrings);
+};
+
+const hasKnowledge = function hasKnowledge(graph: Graph, document: string) {
+  if (graph.documents[document] !== undefined) {
+    return true;
+  }
+  if (Object.values(graph.units).some((unit) => unit.document === document)) {
+    return true;
+  }
+  if (graph.decisions.some((decision) => decision.document === document)) {
+    return true;
+  }
+  if (
+    graph.relationships.some((relationship) =>
+      relationship.evidence.some((evidence) => evidence.document === document)
+    )
+  ) {
+    return true;
+  }
+  return graph.warnings.some(
+    (warning) =>
+      typeof warning !== 'string' && warning.scope.some((scope) => scope.document === document)
+  );
+};
+
+const selectedDocument = function selectedDocument(project: Project, id: string) {
+  return project.documents.find((document) => document.id === id);
+};
+
+const mapCitation = function mapCitation<T extends { document: string }>(
+  citation: T,
+  from: string,
+  to: string
+) {
+  return citation.document === from ? { ...citation, document: to } : citation;
+};
+
+const mapUnitId = function mapUnitId(id: string, from: string, to: string) {
+  const prefix = `${from}:`;
+  return id.startsWith(prefix) ? `${to}${id.slice(from.length)}` : id;
+};
+
+const mapWarning = function mapWarning(
+  warning: Graph['warnings'][number],
+  from: string,
+  to: string
+): Graph['warnings'][number] {
+  return typeof warning === 'string'
+    ? warning
+    : { ...warning, scope: warning.scope.map((scope) => mapCitation(scope, from, to)) };
+};
+
+const mapDecision = function mapDecision(
+  decision: Graph['decisions'][number],
+  from: string,
+  to: string
+) {
+  return { ...decision, document: decision.document === from ? to : decision.document };
+};
+
+const mapRelationship = function mapRelationship(
+  relationship: Graph['relationships'][number],
+  from: string,
+  to: string
+) {
+  return {
+    ...relationship,
+    evidence: relationship.evidence.map((evidence) => mapCitation(evidence, from, to)),
+  };
+};
+
+const mapUnits = function mapUnits(
+  graph: Graph,
+  from: string,
+  to: string,
+  isCoverageRelocated: boolean
+) {
+  const entries = Object.entries(graph.units).flatMap(([id, unit]) => {
+    if (!isCoverageRelocated && (unit.document === from || unit.document === to)) {
+      return [];
+    }
+    if (unit.document !== from) {
+      return [[id, unit] as const];
+    }
+    const relocatedId = mapUnitId(id, from, to);
+    return [[relocatedId, { ...unit, document: to }] as const];
+  });
+  return Object.fromEntries(entries);
+};
+
+const mapDocuments = function mapDocuments(
+  graph: Graph,
+  from: string,
+  to: string,
+  options: { isCoverageRelocated: boolean; sourceVersion: string | undefined }
+) {
+  const entries = Object.entries(graph.documents).filter(([id]) => id !== from && id !== to);
+  if (options.isCoverageRelocated && options.sourceVersion !== undefined) {
+    entries.push([to, options.sourceVersion]);
+  }
+  return Object.fromEntries(entries);
+};
+
+export interface SourceRelocation {
+  destinationVersion: string;
+  from: string;
+  fromVersions: string[];
+  graph: Graph;
+  reused: boolean;
+  to: string;
+}
+
+export const relocateSource = function relocateSource(
+  graph: Graph,
+  project: Project,
+  from: string,
+  to: string
+): SourceRelocation {
+  if (from === to || !isPortablePath(from) || !isPortablePath(to)) {
+    fail(
+      'INVALID_ARGUMENT',
+      'Source relocation paths must be distinct project-local Markdown files'
+    );
+  }
+  if (!hasKnowledge(graph, from)) {
+    fail('SOURCE_NOT_FOUND', `Source is not present in knowledge: ${from}`);
+  }
+  if (selectedDocument(project, from) !== undefined) {
+    fail('INVALID_ARGUMENT', `Source must no longer be selected: ${from}`);
+  }
+  const destination = project.currentDocuments.find((document) => document.id === to);
+  if (destination === undefined) {
+    return fail('SOURCE_NOT_FOUND', `Destination is not a selected current Markdown source: ${to}`);
+  }
+  const versions = sourceVersions(graph, from);
+  const hasDestinationKnowledge = hasKnowledge(graph, to);
+  const hasUnversionedEvidence = graph.relationships
+    .flatMap((relationship) => relationship.evidence)
+    .some((evidence) => evidence.document === from && evidence.version === undefined);
+  const isReused =
+    !hasDestinationKnowledge &&
+    !hasUnversionedEvidence &&
+    versions.length > 0 &&
+    versions.every((version) => version === destination.hash);
+  const documents = mapDocuments(graph, from, to, {
+    isCoverageRelocated: isReused,
+    sourceVersion: graph.documents[from],
+  });
+  const units = mapUnits(graph, from, to, isReused);
+  const relocated: Graph = {
+    ...graph,
+    decisions: graph.decisions.map((decision) => mapDecision(decision, from, to)),
+    documents,
+    relationships: graph.relationships.map((relationship) =>
+      mapRelationship(relationship, from, to)
+    ),
+    units,
+    warnings: graph.warnings.map((warning) => mapWarning(warning, from, to)),
+  };
+  return {
+    destinationVersion: destination.hash,
+    from,
+    fromVersions: versions,
+    graph: relocated,
+    reused: isReused,
+    to,
+  };
+};