Review local changes before moving on.
Keep or revert text changes in VS Code, with pending reviews preserved across restarts.

Quick Start · Features · Docs · Releases

Code Diff Tracker

Code Diff Tracker is a VS Code extension that records local workspace file changes. Supported text can be reviewed and safely kept or reverted; non-text resources have file-level visibility and, when their identity can be verified, an Acknowledge action. Review views include:

• Inline read-only diff document
• VS Code side-by-side diff
• Cursor-like WebView diff with floating Undo/Keep actions
• Optional Native Review with read-only, version-bound snapshots

Review changes as they happen, then keep or safely revert them by block, file, or batch. Pending reviews can survive VS Code restarts, stale review actions are rejected, and Git-context changes are guarded before write operations continue.

中文说明

For version-specific changes, see the release notes.

This repository is the lengmh/DiffTracker continuation of the DiffTracker fork lineage: wizyoung/DiffTracker → TinyTigerPan/DiffTracker → lengmh/DiffTracker. The project retains the MIT license and upstream attribution. The Marketplace extension ID is lengmh.code-diff-tracker.

Compatibility note: Before installing, disable or uninstall TinyTigerPan.diff-tracker and any earlier test VSIX published as lengmh.diff-tracker. These extensions register the same commands, views, and configuration keys and are not supported side by side. VS Code treats each extension ID separately, so saved review sessions are not migrated between IDs.

Screenshots

Cursor-like WebView Unified	Cursor-like WebView Split

Editor Inline View	Editor Inline View (hover effect)

Inline View 2	Side-by-side diff

Features

• Persistent review sessions: pending, unaccepted changes survive VS Code restarts
• Versioned review actions that reject stale CodeLens and WebView operations
• Block-, file-, and batch-level Keep/Revert workflows
• Bounded Undo Last Revert recovery for supported revert operations
• Git-context protection for branch, detached HEAD, worktree, and conflict changes
• Automation-only tracking mode for AI/agent or extension-driven edits
• Configurable WebView opening position (current group or beside)
• Automatic recording after activation when the effective scope and baseline are ready
• Activity Bar Change Recording tree with file grouping
• Workspace baseline snapshots with start/stop recording controls
• Rules and Whole Workspace monitoring modes with local consent for scope expansion
• File watching within the effective scope, including external file changes and visible coverage gaps
• Read-only opaque/unknown review entries, with version-checked Acknowledge for eligible opaque changes
• Inline read-only diff view with line- and word-level highlights
• Side-by-side diff (Original ↔ Current) through the built-in VS Code diff editor
• Cursor-like WebView diff with Split/Unified, Wrap, Expand, Keep All, and Reject All
• Deleted-line badges, CodeLens actions, and hover details
• Settings panel and unified Manage Monitoring Scope editor with literal includes and restricted .gitignore-style excludes

Usage

1. Open Code Diff Tracker from the Activity Bar.
2. Choose Start Recording to build a baseline. New workspaces stay stopped by default. A new or expanded scope may need local confirmation first.
3. Edit files in your workspace.
4. In Change Recording, select a changed file to open the configured review view.
5. Use the context menu or editor title actions to open:
   • Inline Diff
   • Side-by-Side Diff
   • WebView Diff
   • Native Review Snapshot
6. In WebView Diff, use block-level Undo/Keep or file-level Keep All/Reject All.
7. Use Revert File / Revert Text Changes for eligible text, or Acknowledge Read-only Change for eligible opaque changes.
8. Stop recording when you no longer want to track changes. Existing pending reviews keep the last captured content, including after reload; later edits, deletions and new files are not added. Keep/Revert still verify the actual file and editor, and refuse stale review without overwriting newer edits or refreshing the stopped snapshot. Start explicitly captures a new baseline and resumes recording.

When stopped, opening Side-by-Side Diff uses a read-only Review Snapshot. Already-open Live File diffs remain normal VS Code views of working files; reopen Native Review Snapshot from the changed file’s context menu to see the stopped capture.

Clear Diffs resets the baseline to the current workspace while recording. When recording is stopped, it clears the saved baseline and Undo history and remains stopped, including after reload. It does not modify workspace files or dirty buffers.

Recheck Observation Coverage is available in the Command Palette and Settings → Tools. For an active, ready configured scope, it reinstalls failed observation coverage and performs one bounded comparison against the original review baselines. Pending text/opaque reviews and unknown before-images are preserved. It refuses while recording is stopped, scope changes or recovery are pending, or editors have unsaved changes. Activity, unsupported coverage or resource limits may leave a visible coverage gap; retry after resolving the cause. Scope actions automatically perform their necessary reconciliation; Recheck remains available to retry unresolved observation failures against the original baselines. Unchanged files stop appearing as Unknown; unknown before-images still require a separate explicit Reset once coverage is verified. It does not accept changes, rebuild the baseline or modify workspace files.

Monitoring Scope and File Types

Open Settings → Tools → Manage Monitoring Scope, or run Code Diff Tracker: Manage Monitoring Scope. The old Edit Watch Ignores command opens this same manager. It shows the requested scope, effective scope, pending changes, preparation errors and current observation coverage.

Status updates as recovery, baseline transactions, baseline scans and settings writes start or finish. It reports the actual blocking reason and available next step; interrupted durable baseline preparation requires Reload Window, not forcing a transaction lock clear. Unsaved scope drafts remain preserved during status updates.

legacyV3 identifies compatible monitoring policy, not a corrupt session. With no legacy rules and no pending Workspace request, recording can continue in compatibility mode. Legacy rules require review through migration preview; a completed rule migration still needs Apply Saved Request before configured scope becomes effective. Status distinguishes these stages from recovery failures.

• Rules follows ordinary ignore policy. Explicit workspace-relative includes can add ignored paths; explicit exclusions still take precedence.
• Whole Workspace requests all monitorable resources in the workspace, including ordinarily ignored files. Explicit exclusions and safety boundaries still apply; it does not mean every path is safely observable.
• Scope expansion requires a trusted workspace and local consent tied to the workspace roots and requested scope. Shared settings do not transfer consent to another machine or extension host. Saving a request alone does not make it effective.
• Preparation is bounded. Failure, cancellation or capacity limits keep the previous effective scope and pending reviews; an unprepared workspace does not become Ready. Unsupported watcher combinations remain visibly limited or paused.
• Includes are literal relative paths. New structured excludes use restricted .gitignore-style patterns without ! negation. Use the manager's migration preview for legacy string rules; do not silently rewrite them.

Directory creation, imports and renames automatically receive bounded observation verification while recording. File/folder exclusions, Save and Apply, and Restore Effective Scope Configuration each continue through their necessary verification from one action, with one combined confirmation when needed. Cancellation preserves drafts and reviews. If settings are committed but verification cannot finish, the exclusion stays effective and the result reports partial completion; independent coverage problems are listed separately. Stopped sessions remain stopped.

Text baselines store content in workspace-specific extension storage. Opaque resources, such as binary files, unsupported encodings and oversized text, retain existence and bounded identity evidence rather than new content copies. Acknowledge Read-only Change rechecks the reviewed identity and persists it as the new baseline. It does not modify the file, back up its bytes or create non-text Undo/Revert capability. An unreadable file or unknown before-image cannot be accepted as a verified opaque baseline merely to clear the list. Coverage diagnostics for directories are separate from file reviews.

Recovery controls have distinct purposes:

• Apply Pending Scope reviews and applies a requested scope; Retry Scope Preparation retries preparation of an already authorized scope.
• Recheck Observation Coverage repairs observation and compares against the original baselines, as described above.
• Retry Saved Review Recovery, available in Monitoring Scope and the Command Palette, retries validation of preserved session/last-good recovery data. Success restores a paused review with its original before-images and Undo; it does not apply scope settings or start a new baseline. Start exposes this recovery choice even when requested and effective scopes differ.
• Discard Saved Session… separately confirms deletion of stored session, pending review and Undo recovery files, including interrupted-operation records. Preserve extension storage first if needed. It leaves workspace files and preferences unchanged and does not automatically rebuild. Failed validation may still require manual recovery; retry is not a guarantee of recovery.
• Restore Effective Scope Configuration explicitly writes the previous effective scope back to Workspace Settings; Migrate Legacy Watch Rules opens migration preview.
• Clear Diffs rebuilds the baseline while recording, or clears saved review state while stopped. It is not a substitute for Recheck.

How It Works

When recording starts, Code Diff Tracker:

1. Captures baseline snapshots for supported workspace files.
2. Tracks file and document changes and rebuilds line/block diffs.
3. Serves virtual inline/original documents for review views.
4. Persists the baseline and pending reviews so they can be restored after restart.
5. Keeps the tree, decorations, CodeLens, and WebView synchronized.
6. Verifies review version, file state, persistence state, and Git context before mutating reviewed files.

Storage and Cleanup

• Review state lives in VS Code's workspace-scoped extension storage on the extension host. In Remote-WSL, that host is in WSL. Supported text baselines store full original content, including unchanged files in the captured scope; opaque files store identity metadata, not binary copies. This is not an unlimited copy of every edit. Undo retains up to 10 operations, each potentially covering several files.
• The 50 MiB limit applies to one serialized session, not the whole storage directory. The primary state and last-good copy can use roughly twice that session's size; a temporary write can add another copy. The latest archive and recovery backups can add more.
• To reduce future baseline size, exclude unneeded build output, dependencies or logs through Manage Monitoring Scope, then review and explicitly apply the proposed scope. Exclusion is not a guarantee that all historical or recovery copies are deleted.
• When the current review is no longer needed, stop recording, then run Clear Diffs and confirm to clear its saved baseline, pending review and Undo. This loses review evidence but does not change workspace files; it does not guarantee removal of every backup or secure erasure. While recording, Clear Diffs instead captures a new baseline and may not reduce storage. Archive and Rebuild keeps the latest previous archive, so it is not a space-cleanup shortcut.

Do not delete individual session JSON files, recovery intents or failure markers to free space or bypass a recovery warning. Preserve the workspace and extension storage before troubleshooting an interrupted save.

Safety and Recovery Behavior

Optional Native Review

Choose Native Review in Settings → Display → Default open mode, or set diffTracker.defaultOpenMode to nativeReview in VS Code settings. Clicking a changed text file then opens a read-only Native Review snapshot. Opaque and unknown resources use the WebView fallback. The default remains webview; other review modes remain available.

You can also run Open Native Review Snapshot for the active changed file, or Review Text Changes Natively for a multi-file view. Both sides are read-only, version-bound snapshots. VS Code 1.80 and hosts without Multi Diff use an explicit file picker and single-file Diff; more than 50 text changes also use this bounded fallback. This limit applies to one Multi Diff view, not the monitoring capacity.

Right-click inside the snapshot's current side to Keep Reviewed File, Revert Reviewed File, or act on one exactly selected whole block. Partial selections, deleted-line blocks, stale snapshots, and ambiguous editor targets are refused. Use file-level review when a block cannot be mapped safely. Block Revert retains the existing unsaved-buffer behavior; save the real file when required, then open a fresh snapshot.

The separate diffTracker.nativeQuickDiff setting remains false by default; selecting Native Review does not enable it. Enable it explicitly to use the Code Diff Tracker Review gutter provider. Its Open Native Review Snapshot menu opens a fresh review; it does not directly apply unversioned Quick Diff hunks. Read-only/unknown resources remain in the existing Changes view.

Review consistency and persistence

Code Diff Tracker rejects an action when the displayed review is stale, the baseline is incomplete, persistence has failed, or the target cannot be validated safely. Session state is written atomically and retains a last-known-good copy. If recovery data is corrupt or a session write is interrupted, automatic restoration is blocked instead of silently replacing the saved review state.

Baseline growth and Keep operations must be persisted before review actions resume.

Git context changes

diffTracker.autoStartRecording defaults to false. Opting in starts only workspaces without a saved session (including non-Git folders); empty windows remain idle. Previously recording sessions resume normally; saved stopped sessions remain stopped. Damaged or incomplete sessions are preserved for explicit recovery through Start.

diffTracker.promptOnGitBranchChange defaults to false. While recording, enabling it permits an Archive and Rebuild prompt after a Git context change; it never archives automatically. Stop suppresses these prompts and background Git snapshot sampling. Existing review remains frozen and viewable. Keep/Revert still verify live Git context and current file contents when invoked; a stale action may require retrying from the refreshed review. Revert cannot write an old branch's baseline into another branch.

Start while already recording is a no-op. Starting again from a stopped session builds a new baseline and asks before replacing pending review. Cancel leaves the review intact. Repository Archive and Rebuild requires recording and explicit confirmation. Clear Diffs retains its separate explicit confirmation; while stopped it clears saved review without scanning a new baseline.

Fresh recording waits for the VS Code Git API to become ready before establishing the Git baseline. If a repository later changes branch, detached HEAD, worktree identity, or enters an unstable merge/rebase state, existing review data is preserved, while Revert and Undo actions for that repository pause. Returning to a compatible Git context automatically revalidates the live repository before resuming future review actions. Existing before-images, pending reviews and Undo records are retained; an in-flight action that observed the incompatible context is not revived. Archive and Rebuild Paused Git Baseline explicitly starts a new baseline, rather than unlocking the existing review.

After switching between stable named branches in the same verified repository and worktree, text Keep can still update the selected review baselines. Both branches must have commits, and the review version, current content, unsaved-editor state, monitoring scope and saved-session checks must pass. Keep does not modify workspace files, the Git index or HEAD. It does not change the Git context originally recorded with the session or clear its pause.

This applies to file, block, folder and batch text Keep. Batch confirmation shows the number of eligible text files; mixed batches do not relax the restrictions on non-text Acknowledge or unknown-baseline reset. If the Git context or reviewed content changes while Keep is pending, the operation is refused or rolled back. If saving is interrupted, reload to recover the saved review before starting a new baseline. Revert, Undo, folder/batch non-text Acknowledge and unknown-baseline reset retain their strict Git-context restrictions.

The single-file Acknowledge Read-only Change action can accept a verified current identity across stable named branches under the same Git checks as text Keep. It advances only that file’s baseline, leaves other reviews and the repository pause unchanged, and removes only that file’s obsolete Undo entries. It does not save binary before-images or provide binary Revert. Different file content after returning to the original branch becomes pending again. Ordinary single-file Accept/Acknowledge runs directly; conflicts remain visible without accepting a newer version automatically.

Acknowledge and explicit Unknown Reset preserve a complete pre-action session before publication. Interrupted saves recover the prior review rather than relying on an in-memory rollback; unchanged watcher notifications do not invalidate an approved file identity.

Files larger than 64 MiB use reminders only: the extension does not read their full contents or compute content fingerprints. Reminders compare path, existence and size; same-size content edits and timestamp-only changes are intentionally ignored. Files already present when the baseline is established do not produce an initial reminder. Later additions, size changes and deletions do; renames can appear as deletion of the old path and addition of the new path.

Acknowledging a large-file reminder marks that observed path/size state as seen. It does not verify or accept file contents, replace an earlier text baseline, remove earlier Undo evidence, or provide binary Revert. An earlier review remains preserved when a small file grows beyond the limit. If the file becomes small again, normal review resumes against any preserved before-image; missing original content remains Unknown. Use your own Git or software backups for recovery; the extension does not check that those backups exist.

Ordinary commits on the same named branch do not invalidate the review context.

Keep has these additional limits:

• Repositories using Git's reftable ref storage are not supported by the current verifier; Keep is refused when the Git state cannot be verified.
• Manually replacing or repointing .git or linked-worktree metadata at the same path is not treated as a normal branch switch. Use Archive and Rebuild Paused Git Baseline once the repository is stable before continuing.
• A Git repository must have an initial commit before Keep is available, including ordinary same-branch Keep. Creating that commit is a separate user action; DiffTracker does not create it.
• When a restored session contains recorded Git provenance, Keep is refused if the VS Code Git monitor is unavailable (for example, the Git extension is disabled, missing or fails to start). Restore Git monitoring before retrying; switching to non-Git behavior does not bypass that saved provenance.

Use Code Diff Tracker: Restore Archived Git Review from the Command Palette to restore the latest review saved by Archive and Rebuild. Preview the repository, branch/HEAD, workspace root and saved baseline evidence, then confirm replacement of the current DiffTracker review state. Return to the archived branch yourself before restoring; the command never switches branches or changes Git history or workspace files.

Restoration supports one workspace root and one repository, with matching root identities and monitoring scope. A missing/incompatible archive, unverified Git state, merge/rebase, dirty editor or pending scope/recovery operation blocks restoration. Any remaining Git pause is cleared only after the archived context is validated. Current disk content is reconciled against the archived before-images; unknown before-images stay unknown.

Restoration preserves the archive's recording state. Active archives resume tracking; stopped archives receive one bounded reconciliation, including later-added files, and remain stopped. Temporary watchers verify the restore transaction and are released for a stopped session. A stopped current session can still restore an active archive. Start Recording creates a fresh baseline from current files; it does not resume an archived baseline.

Only the latest archive is available: each Archive and Rebuild replaces session-state.archive.json. Before Restore replaces the live session, it saves the entire current session separately as session-state.pre-restore.json. These are extension-host workspace-storage files, not files in the project. In Remote-WSL, they belong to the WSL extension host; do not swap Windows-side JSON files. Interrupted restoration recovers the validated pre-restore session or blocks with the preserved evidence intact.

Created and deleted files

Code Diff Tracker does not automatically delete a file when a Revert or Undo operation would remove a file that was absent from the baseline. VS Code does not expose a conditional, version-checked delete primitive, so automatic deletion could destroy newer work. Inspect and delete the file manually, then retry the operation if required. Batch Revert reports that item as a conflict and continues with other eligible files.

When restoring a deleted file, Code Diff Tracker publishes fully written content without overwriting a destination that appeared concurrently. If the destination already exists or the filesystem cannot provide the required safe publication behavior, the action reports a conflict.

Baseline and ignore provenance

A newly discovered path is classified as a new file only when Code Diff Tracker has sufficient baseline-scan provenance to prove that it was absent. Files exposed by changed ignore rules, or restored from older sessions without compatible scan provenance, remain pending with an unknown baseline until an explicit rebuild. Existing known baselines are preserved.

Changes to folder-scoped or nested ignore semantics may invalidate older scan provenance even when the visible rule text is unchanged.

Unsupported or unsafe files

Within the effective monitoring scope, binary files, unsupported text encodings, UTF-8 BOM files and oversized resources are represented as read-only opaque changes when sufficient evidence is available. Unreadable resources and unknown before-images retain their uncertainty and reasons. They are not decoded and written speculatively. Paths outside the workspace and unsafe target identities remain excluded or safely refused. Pure line-ending-style changes are treated as no logical content change.

New snapshots and recovery records preserve POSIX file permission bits, including executability. Older sessions without mode metadata cannot reconstruct original permissions. Missing parent directories created during recovery use private permissions (0700, subject to umask); existing directory permissions are not changed. Directory ACLs and historical directory modes are not reconstructed automatically.

Automation-only mode

Automation-only mode conservatively retains editor changes when their source cannot be proven. Saving a document does not silently accept those changes. Extensions can use the automation-session API described under Extension Settings to identify their own edits.

Installation

Marketplace

Search for Code Diff Tracker by publisher lengmh, or run:

code --install-extension lengmh.code-diff-tracker

From VSIX

1. Download the .vsix file.
2. Open VS Code.
3. Open Extensions (Cmd+Shift+X / Ctrl+Shift+X).
4. Open the Extensions menu and select Install from VSIX....
5. Select the downloaded file.

Requirements

• VS Code ^1.80.0
• Verified local Host combinations: Windows Stable 1.140.0, Ubuntu Stable 1.140.0 and Ubuntu 1.80.2. This is a finite Windows/Linux support scope, not verification of every platform, filesystem or future Stable version. The minimum-version Host uses the single-file Native Diff fallback.

Extension Settings

Setting	Default	Description
diffTracker.showDeletedLinesBadge	true	Show a badge indicating deleted lines
diffTracker.showCodeLens	true	Show CodeLens actions (Revert/Keep) above change blocks
diffTracker.highlightAddedLines	true	Highlight added lines with green background
diffTracker.highlightModifiedLines	true	Highlight modified lines with blue background
diffTracker.highlightWordChanges	true	Highlight word-level changes within modified lines
diffTracker.defaultOpenMode	webview	Changed-file opening mode; select nativeReview for version-bound text snapshots with WebView fallback for opaque/unknown resources
diffTracker.nativeQuickDiff	false	Separate opt-in Quick Diff provider whose menu opens a fresh Native Review snapshot
diffTracker.monitoringScope	rules	Requested rules or wholeWorkspace mode; expansion requires local consent and preparation
diffTracker.watchInclude	[]	Structured literal workspace-relative includes, managed with the scope editor
diffTracker.webviewDiffStyle	split	Initial WebView layout: split (side by side) or unified (one column)
diffTracker.webviewWordWrap	false	Wrap long lines in a new WebView panel
diffTracker.webviewExpandUnchanged	false	Expand all unchanged context lines in a new WebView panel
diffTracker.openWebviewBeside	false	Open WebView diff in a side editor group instead of the current editor group
diffTracker.watchExclude	[]	Structured explicit exclusions without ! negation; legacy string entries retain compatibility until migration
diffTracker.onlyRecordReviewableText	false	Skip new unsupported resources using safe content classification; preserve existing review and Undo
diffTracker.autoOpenNextPendingFile	false	Open the next pending file after successful single-file review, only when the current file has no remaining review
diffTracker.enableSourceTracking	false	Opt in to experimental source hints for Vibe Coding Only; baseline and coverage warnings remain visible when off
diffTracker.onlyTrackAutomatedChanges	false	Track external/tagged automation edits while retaining uncertain editor edits for explicit review

Choose the opening mode in Settings → Display → Default open mode, through Select Default Open Mode, or in VS Code settings. The values are webview, inline, sideBySide, original, splitOriginalWebview and nativeReview. Display/highlight settings remain in the sidebar Settings panel; monitoring rules are in Manage Monitoring Scope.

WebView display defaults are also available under Settings → Display: WebView default layout, WebView default: Wrap, and WebView default: Expand. Expand shows unchanged context, including lines outside the changed hunks. These settings initialize a new panel; an existing panel keeps its toolbar choices during updates, hiding/revealing, and file switches. Close the WebView tab and open it again to apply changed defaults. Toolbar clicks do not rewrite your settings. These defaults do not change the native VS Code diff editor.

When diffTracker.openWebviewBeside is enabled, WebView diff opens in a side editor group. By default it opens in the current editor group.

The Recording settings group also exposes Only record reviewable text and Auto-open next pending file. Text eligibility uses the existing UTF-8, binary-content and size checks, including extensionless files. Enabling the text filter does not clear existing reviews or Undo. Dirty editors, read failures and coverage gaps remain unresolved. A previously skipped resource that becomes text requires Reset Unknown Baseline (Current Disk State); disabling the filter does not recreate missed history. A bounded, conservative membership record protects this rule across restart; it may also require a baseline reset for another untracked path. Stop continues to freeze the saved review.

Use Stop Recording This File or Folder from Explorer or a pending file/folder context menu to exclude that exact path. If it has pending reviews, confirmation lists those reviews before any settings or review state changes; Cancel leaves the scope and review unchanged. Confirmation removes only the selected path’s active review, baselines and Undo entries, without modifying workspace files or rebuilding the workspace baseline. A path with no pending review needs no discard dialog. Resolve existing pending scope requests or legacy migration in Manage Monitoring Scope first, and close unsaved scope drafts. Concurrent scope/review changes require a fresh confirmation; failure restores the quick action’s own request where it is still current, never overwriting newer user settings. Workspace roots, ambiguous folder names and paths that cannot be represented exactly by the restricted exclusion grammar are refused without changing settings.

Automatic navigation uses a stable path order and the configured default open mode. It wraps to remaining earlier files; when none remain, it leaves the current editor open. Failed, stale, cancelled or paused actions, remaining blocks, batch actions, and user focus changes do not navigate.

When diffTracker.onlyTrackAutomatedChanges is enabled:

• Editor events without reliable source information remain pending. Optional source hints require diffTracker.enableSourceTracking, which is off by default. Switching it on affects new observations; it does not reconstruct source attribution for earlier edits.
• External tools or CLI processes that modify files on disk are still tracked through file watchers.
• VS Code extensions should call diffTracker.beginAutomationSession before applying edits and diffTracker.endAutomationSession after they finish.

Example integration from another VS Code extension:

const sessionId = await vscode.commands.executeCommand<string>(
  'diffTracker.beginAutomationSession',
  { allFiles: true, ttlMs: 30000 }
);

try {
  // Apply WorkspaceEdit or editor edits here.
} finally {
  await vscode.commands.executeCommand('diffTracker.endAutomationSession', sessionId);
}

Upgrade Notes

When upgrading from older DiffTracker builds, saved review sessions remain associated with the extension ID that created them. Sessions from TinyTigerPan.diff-tracker or earlier lengmh.diff-tracker test builds are not migrated automatically to lengmh.code-diff-tracker.

This build saves review sessions as Session V5, adding bounded stopped-review snapshots to the effective scope and durable gap evidence introduced in V4. Valid V1–V4 sessions remain readable; observation coverage is re-established after activation. Restored older sessions remain in scope-compatibility mode until explicit rule migration and scope preparation succeed. Cancelled or failed migration retains the existing review state.

Version 0.7.2 already stores existence and content identity for opaque files. Upgrading preserves the evidence available in the saved session; it cannot reconstruct a missing historical fingerprint from the current file. Paths without a known before-image or reliable baseline scan remain visibly unknown.

Text review sessions and ordered legacy rules have been verified when upgrading from released 0.7.2 to V4. Migration of opaque-file state from that release has not been verified. Recovery of opaque state newly created by the candidate build has been checked across process restarts; this does not verify recovery of older opaque state or behavior after Reload Window. Preserve the workspace and extension storage before upgrading, especially when opaque changes are pending.

V5 is incompatible with builds that only read V4 or older formats; downgrade recovery is blocked rather than silently recapturing post-Stop edits or discarding saved review data. Older stopped sessions did not save pending current-content snapshots, so their baselines are preserved in an incomplete, paused state without guessing the missing review. Start or rebuild explicitly when ready. Explicit archived-review restoration retains its documented one-time current-filesystem reconciliation. Preserve the workspace and extension storage before changing versions. Do not delete recovery markers or saved state merely to bypass a compatibility warning.

Known Issues

• Pure line-ending-style changes (CRLF/LF only) are treated as no logical content change.
• Unsupported or unsafe files are not eligible for text Keep/Revert actions.
• If you find a reproducible diff/render edge case, open an issue with a minimal file sample.

Release Notes

Release notes are maintained in CHANGELOG.md.

Contributing

See the development guide for local setup, checks and packaging.

License

MIT

Acknowledgements

Discuss, free AI, and get help at linux.do.