AI Development and Agentic Automation Projects

Finding and clearing out duplicate files used to mean opening a separate window on top of your file list. Now it’s a full mode of its own, switched to with one click, so reviewing duplicates feels like a normal part of working the list rather than a detour.

• Added a toolbar switch between the regular file list and a dedicated Duplicates view, sharing the same project sidebar so you never lose your place moving between the two.
• The Duplicates screen keeps everything it already did – re-scan, exclusion patterns, keep-pattern rules – now with more room to work and no popup window to manage.
• If you’ve made changes in Duplicates mode and haven’t saved them, switching projects or modes now warns you first, so a half-finished cleanup can never be silently lost.
• Under the hood, this is also the foundation for upcoming duplicate-handling rules – the mode switch had to exist before rules could be built on top of it.

Documentor’s auto-versioning has now been run against a real, messy corpus of client files – and every rough edge that turned up became a fix, from a genuine crash to a handful of review-screen refinements that make it faster to trust what’s being proposed.

• Fixed a real crash: a rare document-history shape – two independent ancestors both converging on one later file – was being walked twice instead of recognized as unorderable, corrupting the numbering. Documentor now detects this shape up front and correctly flags it for manual review instead.
• Documentor can now recognize an original file with no version number in its name, sitting among copies that do (v2, v3, and so on) – it correctly infers that file is the first version, exactly where structural clues alone leave gaps.
• The review screen now shows a file’s modified date and size, tags exact-duplicate copies the same way the family view does, and adds a toggle to hide families with no established order – useful once a corpus has a lot of them.
• Un-doing a false grouping is now a genuine toggle: previously the only way back was re-checking every file in the group one at a time, and a small string-matching gap meant “Report_Revised.docx” wasn’t recognized as a version marker the way “Report Revised.docx” was.

Documentor has been able to work out a family of documents’ order and propose a clean version number for a while now, but only within its own records – nothing on the actual file changed. That gap closes today: Documentor can now rename real files to match their assigned version, with a full undo available whenever it’s needed, plus smarter handling of documents that split into separately-edited copies and files that already carry their own version label.

• Assigning a version number and renaming the real file are now two separate, deliberate steps – nothing changes on disk until you’ve reviewed and explicitly approved it, and a rename always covers every duplicate copy of a file, not just the one you’re looking at.
• Every rename is recorded before it happens, so an interrupted batch – a crash, a permissions hiccup – can always be picked back up right where it left off, and a completed rename can be undone at any time, restoring the original filename with the same one-click safety.
• When a document splits into two separately-edited copies, each branch now gets its own clean label showing where it diverged and how many edits it’s had since. If one branch is later declared the real one going forward, a single click collapses its whole history into the next version number, without disturbing the other branch’s numbering.
• Documentor now recognizes files that already carry a deliberate version scheme of their own (v1.0, v2.0) and leaves them alone by default, while still cleaning up messier labels like “FINAL” or “Draft 2”. A safety fix also ensures that if a file is renamed a second time, undo only ever reaches back to the most recent rename – never an earlier one that’s already been superseded.

Word documents have long carried a revision history Documentor can read to work out their order. PDFs carry a different kind of history, embedded in the file itself, and Documentor now reads that too – so PDFs take their place in a version family’s sequence instead of sitting in the “order unknown” pile.

• PDFs embed their own provenance: a record, inside the file, of which earlier draft a saved copy was created from. Documentor now reads that directly from the file’s own metadata, so a family of PDF revisions can be put in order the same way Word documents already are.
• This signal takes priority over the order Documentor infers from content alone, since it comes from the file itself rather than a guess. When the two disagree – a document’s own history looks reverted relative to what its metadata claims – Documentor flags it for a look rather than picking one silently.
• A new “Review order” indicator in the Version Families view surfaces exactly which files triggered that disagreement, alongside the existing order badges.
• The “order unknown” pile shrinks: PDFs, which previously carried no ordering signal at all, can now be sequenced wherever this metadata is present – closing the last major gap in version ordering.

Documentor already groups files that are revisions of one another; now it works out their order too – reading the sequence from each document’s own revision history, flagging genuine forks, recognising identical copies as the same version, and honestly saying ‘unknown’ rather than guessing when there is no signal to go on.

• For Microsoft Office documents, Documentor reads the revision history a file accumulates as it is edited and reconstructs the sequence – earliest draft to latest – showing a numbered order wherever the history makes it clear.
• Confidence is shown honestly: when two revisions are near-identical rather than a clean progression the order is marked ‘likely’ rather than asserted, a document edited in two parallel directions is shown as branched instead of flattened into a false line, and files with no ordering signal are left ‘unknown’ rather than guessed.
• Files that share identical revision history are recognised as the same version saved in more than one place – co-equal copies, not a sequence – and labelled as such, so they are not forced into an order that does not exist.
• A new Merge action lets you combine families that were split apart, and the primary copy of each version is now chosen the same way duplicate copies are resolved – your kept or starred copy, otherwise the simplest-named one.

Documentor can now show ‘version families’ – groups of files that are revisions of one another – discovered from each document’s content lineage rather than its filename, and it lets you curate them: separate true duplicates from genuine versions, and correct any grouping that looks wrong.

• A new Version Families view groups files that are revisions of one another by their content lineage – the revision history Microsoft Word records, or a content fingerprint of the text – not by their filenames, so inconsistently-named copies still line up.
• Exact duplicates are detected and collapsed, then shown separately from real version sets, so a tangle of similarly-named files reads as one clean lineage with its copies noted.
• The grouping was refined against a real document library: thresholds tuned, a filename check added so a shared template no longer merges distinct documents, and implausibly large groupings flagged for review.
• Correction controls let you uncheck a file that does not belong or dismiss a whole false grouping, with the choice remembered on future scans – plus a results export for reviewing the output.

Documentor’s version-detection moved from groundwork to a working capability for Microsoft Office documents – it now recognizes when Word files are revisions of one another by reading the revision history Word quietly records inside every document, and groups them into version families.

• Documentor now identifies related versions of Word documents from the revision-tracking metadata Microsoft Word embeds in each file – so it recognizes revisions of the same document even when the filenames are inconsistent or unhelpful.
• Related versions are grouped into ‘families’, so a tangle of similarly-named copies is seen as one ordered lineage – the basis for tidying them into a single clean version sequence.
• Coverage spans the whole Word family – standard documents, macro-enabled files, and templates – and the detection runs automatically as part of the normal folder scan, reusing its results on later scans.
• The work is backed by a thorough automated test suite and a shared clustering engine, with every change isolated on a feature branch and verified green before release.

Design and groundwork began on a new Documentor capability that recognizes when several files are really versions of the same document – revisions of one another – even when their names give nothing away, and that can re-number them into one clean, consistent version sequence.

• Completed the design for automatic version detection – how Documentor will group files that are revisions of one another and assign each a clean version number, working from the documents’ own content and history rather than their filenames.
• Built and tested the detection foundation: a compact content ‘fingerprint’ for every scanned file that recognizes near-duplicate revisions, not just byte-for-byte identical copies.
• Optimized the fingerprinting algorithm to run roughly eleven times faster, so it stays quick even across very large folders.
• Wired it into the existing folder scan so fingerprints are computed automatically in the background and reused on later scans, keeping the app responsive even on large libraries.

Documentor’s duplicate-cleanup workspace now recognizes that some copies are kept on purpose – a canonical version, a disclosure copy, a delivered set – and lets you settle those once and apply the decision across a whole project, without ever being forced down to a single file.

• New multi-keep patterns let you keep copies in several legitimate folders at once and drop only the stray duplicates elsewhere, applied across every matching set in one step – so a recurring ‘keep these, drop the rest’ decision is made once rather than file by file.
• A ‘mark kept’ control resolves a set you intend to keep as-is, so it counts as done and stops reappearing on future scans – while a newly added copy still brings the set back for review.
• Patterns now respect group size: a decision made on a two-copy group applies only to other two-copy groups, so a simple case never bleeds into a more complex one.
• The entire cleanup session is now safely abandonable – review your exclusions and keep-marks, then Save or Discard – with ‘important to review’ stars kept independent so they are never lost.

• Find Duplicates is now a resizable, much faster workspace – a content-hash cache lets re-scans reuse prior hashes instead of re-reading every file, and long paths are readable so near-identical copies are easy to tell apart.
• A new path-pattern tool resolves hundreds of duplicate sets at once – exclude every copy under a chosen folder (root or any sub-folder), with a safety rule that never removes a file’s last copy.
• “Show excluded” and a “Normalize to this pattern” action let you revisit and reverse earlier choices as you work, so changing your mind mid-process just works.
• A new file-type browser groups a project’s files by type and owning app, so a large project can be thinned to just the files that matter.

• A new File Query Language (FQL) now powers List View search – filter files by name or folder path using and / not, bracketed or, quoted phrases, and the * and ? wildcards.
• Searching is done through a form-first faceted panel that opens inline beneath the toolbar (a Finder-style filter) – labeled Name and Path rows, live validation, and a plain-English readback of every query.
• An Advanced mode adds a raw query box for power users, with a one-way “Copy to Advanced” from the form and a live matches-of-total count in the status bar.
• The same query engine is built to also drive Documentor’s upcoming duplicate-management rules, so search and cleanup will share one language.

The descriptions, groups, and stars you add to a file in Documentor now follow it when the file is renamed or moved – so your curation work is never stranded by a reorganized folder.

• When a scan finds a file has been renamed or moved to a different folder, its description, group memberships, star, and exclusion are carried across to the new location automatically – there’s no need to re-tag the file.
• The relocated file is recognized by its content fingerprint – its size and timestamps – so the match is instant, needs no re-hashing, and is applied silently for a clear one-to-one match.
• The matching is deliberately cautious: when two files look identical it won’t guess, leaving those cases for you to resolve rather than risk attaching notes to the wrong file.

A design milestone for Documentor – defining one query language that serves both file search and automatic duplicate clean-up.

• Designed a single query language for the Documentor document-curation app that scopes searches by filename and folder path, reusing its existing boolean operators (and / or / not), quoted phrases, and wildcards.
• Extended the same language to drive automatic duplicate handling – an ordered, first-match-wins list of keep and drop rules that reads like a precedence list rather than nested conditions.
• Folded the existing shortest-filename heuristic into the new model as a composable tiebreaker, and added relative options such as keep-newest and keep-oldest.
• Built in a safety rule so an automatic de-duplication pass can never flag every copy in a set – at least one file is always retained.

• Streamlined the duplicate-handling workflow – auto-select or exclude duplicate copies with iterative re-scan.
• Added a Groups column with multi-select filtering, a sortable file-type column, clickable links in exports, and smoother handling of cloud-only files.

• Added powerful search (boolean, wildcard, negation), multi-select with bulk actions, and per-file descriptions with bulk editing.
• Introduced exact duplicate detection and spreadsheet (XLSX) export of deliverable summaries, plus performance gains on large file sets.

• Began building Documentor – a macOS app for organizing, documenting, and managing documents and files, designed for contractors and consultants to give clients clean summaries of deliverables separate from working files.
• Stood up the initial app: file scanning, a sortable file list, grouping, and Quick Look preview.