Method vault_record_working_copy

atomic-repository/src/repository/vault.rs:654–710

Deflate changed vault files from disk into redb. Scans the vault working copy, detects changes, and updates the database. Returns the list of paths that were updated. This is the inverse of `vault_materialize_all`. Together they form the inflate/deflate cycle: - `vault_materialize_all`: redb -> disk (for humans to read/edit) - `vault_record_working_copy`: disk -> redb (after humans edit)

(&self)

    /// - `vault_materialize_all`: redb -> disk (for humans to read/edit)
    /// - `vault_record_working_copy`: disk -> redb (after humans edit)
    pub fn vault_record_working_copy(&self) -> Result<Vec<String>, RepositoryError> {
        let changes = self.vault_scan_working_copy()?;

        let mut updated_paths = Vec::new();

        for change in &changes {
            match change.change_type {
                VaultChangeType::New | VaultChangeType::Modified => {
                    // Infer entry type from path
                    let entry_type = infer_entry_type(&change.path);

                    // T5b record-time grant-lapse (gap #2): a raw on-disk
                    // substance edit to a `done` Draft intent reaches the vault
                    // through THIS path (not `vault_intent_update`), so apply the
                    // same demote-only lapse here. `record_time_lapse_frontmatter`
                    // is Intent-only, demote-only, and returns the demoted
                    // frontmatter iff a lapse applied; otherwise the incoming
                    // frontmatter is stored unchanged. Single store, no recursion.
                    let lapsed_fm = self.record_time_lapse_frontmatter(change, entry_type);
                    let frontmatter_json = lapsed_fm
                        .clone()
                        .unwrap_or_else(|| change.frontmatter_json.clone());

                    self.vault_store(
                        &change.path,
                        entry_type,
                        change.content.clone(),
                        frontmatter_json,
                    )?;

                    // `vault_store` maintains only counts/merkle for Intent
                    // entries — it does not sync the IntentSummary status/pin. On
                    // a lapse, mirror the demoted status/reason into the manifest
                    // so lists and triage stay consistent (as vault_intent_update
                    // does on its path).
                    if let Some(new_fm_json) = lapsed_fm {
                        self.sync_intent_summary_after_lapse(&change.path, &new_fm_json)?;
                    }

                    updated_paths.push(change.path.clone());
                }
                VaultChangeType::Deleted => {
                    self.vault_delete(&change.path)?;
                    updated_paths.push(change.path.clone());
                }
            }
        }

        // Index any intent entries the manifest is missing — even when no
        // file changed. Entries can predate this call (clone bootstrap
        // deflates inherited files) and `update_manifest_for_store` leaves
        // intent summaries to higher-level methods; without this, inherited
        // intents exist in redb but never show up in `intent list`.
        self.vault_reconcile_intent_manifest()?;

        Ok(updated_paths)
    }