@@ -682,8 +682,8 @@ codebase-memory-mcp config reset auto_index              # reset to default
 explicit value, including `off`, replaces that dimension of a selected
 profile. Exceeding an effective limit fails the complete index attempt rather
 than publishing a partial graph, and an existing serving index is preserved.
-Storage probes also fail closed when an enabled measurement cannot be
-completed. See
+`index_status` reports the latest physical indexing attempt and Git-based
+freshness after the first recorded attempt. See
 [Index resource limits](docs/INDEX_RESOURCE_LIMITS.md).
 
 ### Environment Variables
 
@@ -10,6 +10,7 @@ This page documents the configuration files that `codebase-memory-mcp` reads or
 | Per-project custom extension mapping | `{repo_root}/.codebase-memory.json` | JSON | Overrides conflicting global `extra_extensions` entries. |
 | CLI-managed runtime settings | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/_config.db` | SQLite | Written by `codebase-memory-mcp config set/reset`. |
 | UI settings | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/config.json` | JSON | Stores `ui_enabled` and `ui_port`. |
+| Latest indexing attempt | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/status/<project>.json` | JSON | Owner-private, atomically replaced status used by `index_status`. |
 | Daemon operation log | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/logs/cbm-daemon.log` | Structured log | Durable daemon lifecycle, watcher/indexing, UI, resource, and error events. |
 | Admission conflict log | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/logs/daemon-conflicts.ndjson` | NDJSON | Exact-build, ABI, and canonical-cache conflicts. |
 | Activation log | `${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}/logs/activation-events.ndjson` | NDJSON | Install/update/uninstall activation progress and outcomes. |
@@ -109,6 +110,14 @@ timeout. See
 [Index resource limits](INDEX_RESOURCE_LIMITS.md) for counting, validation, and
 error-response details.
 
+After the first physical indexing attempt for a project, `index_status` adds
+`last_index_attempt` and `freshness`. Freshness is `fresh` only when a clean
+Git snapshot observed both before and after indexing still matches the current
+clean `HEAD`. A different clean `HEAD` is `stale`, while non-Git, dirty,
+changed-during-index, missing, or unreadable snapshots are `unknown`.
+`delete_project` also removes a matching attempt record when no database was
+published.
+
 ## 3. UI Settings
 
 The optional built-in graph UI stores its settings in:
 
@@ -170,6 +170,25 @@ Both cases preserve the old serving database. Staging files created by a
 terminated supervised worker are tagged with a private task token and removed
 after its process tree is quiescent; cleanup cannot match another attempt.
 
+## Attempt visibility and freshness
+
+The latest physical attempt for each project is atomically stored in an
+owner-private file below `${CBM_CACHE_DIR}/status/`. It records the
+`explicit`, `auto`, or `watcher` origin; `queued`, `running`, `completed`,
+`failed`, or `cancelled` state; effective profile source; timestamps; and
+stable resource failure details when applicable. Daemon startup changes
+abandoned `queued` or `running` records to `failed` with
+`failure_code=worker_lost`.
+
+After a record exists, `index_status` returns `last_index_attempt` and
+`freshness`. A generation is comparable only when matching clean Git snapshots
+were observed before and after indexing, and it is `fresh` only while the
+current worktree remains clean at that `HEAD`. A different clean `HEAD`, or a
+failed watcher rebuild after an observed change, is `stale`. Non-Git roots,
+dirty or changed-during-index snapshots, failed Git probes, and corrupt records
+are `unknown`. Dirty state is never proof of freshness or staleness. Projects
+with no attempt record retain the previous response shape.
+
 ## Trust and compatibility
 
 Limits are read from the CLI-managed `_config.db`; they are not MCP request
 
@@ -146,6 +146,8 @@ struct cbm_daemon_application_job {
     bool cancelled;
     bool cancel_requested;
     bool supervision_failed;
+    bool attempt_recorded;
+    char attempt_id[33];
     cbm_daemon_application_job_t *next;
 };
 
@@ -1212,6 +1214,63 @@ static void application_record_cancelled(cbm_index_worker_result_t *last_result,
     last_log[0] = '\0';
 }
 
+static cbm_index_resource_t application_resource_from_name(const char *name) {
+    for (int resource = CBM_INDEX_RESOURCE_FILES;
+         resource <= CBM_INDEX_RESOURCE_DISCOVERY_DURATION_MS; resource++) {
+        if (name && strcmp(name, cbm_index_resource_name((cbm_index_resource_t)resource)) == 0) {
+            return (cbm_index_resource_t)resource;
+        }
+    }
+    return CBM_INDEX_RESOURCE_NONE;
+}
+
+static bool application_response_error_metadata(const char *response, char *code, size_t code_size,
+                                                cbm_index_resource_violation_t *violation) {
+    if (code && code_size > 0) {
+        code[0] = '\0';
+    }
+    if (violation) {
+        *violation = (cbm_index_resource_violation_t){0};
+    }
+    yyjson_doc *outer = response ? yyjson_read(response, strlen(response), 0) : NULL;
+    yyjson_val *outer_root = outer ? yyjson_doc_get_root(outer) : NULL;
+    yyjson_val *is_error =
+        outer_root && yyjson_is_obj(outer_root) ? yyjson_obj_get(outer_root, "isError") : NULL;
+    yyjson_val *content =
+        outer_root && yyjson_is_obj(outer_root) ? yyjson_obj_get(outer_root, "content") : NULL;
+    yyjson_val *first = content && yyjson_is_arr(content) ? yyjson_arr_get_first(content) : NULL;
+    yyjson_val *text = first && yyjson_is_obj(first) ? yyjson_obj_get(first, "text") : NULL;
+    yyjson_doc *inner = text && yyjson_is_str(text)
+                            ? yyjson_read(yyjson_get_str(text), yyjson_get_len(text), 0)
+                            : NULL;
+    yyjson_val *inner_root = inner ? yyjson_doc_get_root(inner) : NULL;
+    yyjson_val *inner_status =
+        inner_root && yyjson_is_obj(inner_root) ? yyjson_obj_get(inner_root, "status") : NULL;
+    bool failed = (is_error && yyjson_is_bool(is_error) && yyjson_get_bool(is_error)) ||
+                  (inner_status && yyjson_is_str(inner_status) &&
+                   strcmp(yyjson_get_str(inner_status), "error") == 0);
+    if (failed && inner_root && yyjson_is_obj(inner_root)) {
+        yyjson_val *failure_code = yyjson_obj_get(inner_root, "code");
+        if (code && code_size > 0 && failure_code && yyjson_is_str(failure_code)) {
+            (void)snprintf(code, code_size, "%s", yyjson_get_str(failure_code));
+        }
+        yyjson_val *resource = yyjson_obj_get(inner_root, "resource");
+        yyjson_val *observed = yyjson_obj_get(inner_root, "observed");
+        yyjson_val *limit = yyjson_obj_get(inner_root, "limit");
+        if (violation && resource && yyjson_is_str(resource)) {
+            violation->resource = application_resource_from_name(yyjson_get_str(resource));
+            violation->probe_failed = code && strcmp(code, "resource_probe_failed") == 0;
+            if (observed && yyjson_is_uint(observed) && limit && yyjson_is_uint(limit)) {
+                violation->observed = yyjson_get_uint(observed);
+                violation->limit = yyjson_get_uint(limit);
+            }
+        }
+    }
+    yyjson_doc_free(inner);
+    yyjson_doc_free(outer);
+    return failed;
+}
+
 static bool application_result_is_attributable_failure(
     const application_attempt_t *attempt, cbm_mcp_supervised_result_disposition_t disposition) {
     return disposition == CBM_MCP_SUPERVISED_RESULT_CONTAINED_FAILURE && attempt->has_result &&
@@ -1227,6 +1286,7 @@ typedef enum {
 typedef struct {
     char *response;
     bool successful;
+    bool response_is_error;
     bool unsafe_terminal;
     bool supervision_failed;
     cbm_index_worker_result_t last_result;
@@ -1256,12 +1316,17 @@ static application_attempt_decision_t application_consume_attempt(
         execution->response = attempt->result.response;
         attempt->result.response = NULL;
         execution->successful = execution->response != NULL;
+        execution->response_is_error =
+            execution->response &&
+            application_response_error_metadata(execution->response, NULL, 0, NULL);
         application_attempt_free(attempt);
         return APPLICATION_ATTEMPT_DECISION_SUCCESS;
     }
     if (disposition == CBM_MCP_SUPERVISED_RESULT_RESOURCE_FAILURE) {
         execution->response =
             cbm_mcp_index_worker_resource_response(job->args_json, &attempt->result);
+        execution->successful = execution->response != NULL;
+        execution->response_is_error = execution->response != NULL;
         application_attempt_free(attempt);
         return APPLICATION_ATTEMPT_DECISION_STOP;
     }
@@ -1461,6 +1526,46 @@ static void application_job_publish(cbm_daemon_application_job_t *job,
             execution->have_last_result ? &execution->last_result : NULL,
             execution->last_log[0] ? execution->last_log : NULL);
     }
+    if (job->attempt_recorded) {
+        bool cancelled =
+            execution->have_last_result && execution->last_result.cancellation_requested;
+        bool attempt_completed = execution->successful && !execution->response_is_error;
+        const char *state = attempt_completed ? "completed" : cancelled ? "cancelled" : "failed";
+        const char *failure_code = NULL;
+        const cbm_index_resource_violation_t *violation = NULL;
+        char response_failure_code[CBM_SZ_128] = {0};
+        cbm_index_resource_violation_t response_violation = {0};
+        if (!attempt_completed && !cancelled) {
+            if (application_response_error_metadata(execution->response, response_failure_code,
+                                                    sizeof(response_failure_code),
+                                                    &response_violation)) {
+                failure_code = response_failure_code[0] ? response_failure_code : "index_failed";
+                if (response_violation.resource != CBM_INDEX_RESOURCE_NONE) {
+                    violation = &response_violation;
+                }
+            } else if (execution->have_last_result &&
+                       execution->last_result.resource_violation.resource !=
+                           CBM_INDEX_RESOURCE_NONE) {
+                violation = &execution->last_result.resource_violation;
+                failure_code =
+                    violation->probe_failed ? "resource_probe_failed" : "resource_limit_exceeded";
+            } else if (execution->supervision_failed || execution->unsafe_terminal) {
+                failure_code = "supervision_failed";
+            } else if (!execution->have_last_result ||
+                       execution->last_result.outcome == CBM_PROC_SPAWN_FAILED) {
+                failure_code = "worker_start_failed";
+            } else {
+                failure_code = "index_failed";
+            }
+        } else if (cancelled) {
+            failure_code = "cancelled";
+        }
+        if (!cbm_mcp_index_attempt_transition(job->project_key, job->root_path, job->attempt_id,
+                                              state, failure_code, violation, attempt_completed)) {
+            cbm_log_warn("daemon.index.attempt_record", "project", job->project_key, "state",
+                         "terminal_write_failed");
+        }
+    }
     cbm_daemon_application_t *application = job->application;
     cbm_mutex_lock(&application->mutex);
     job->response = execution->response;
@@ -1508,6 +1613,12 @@ static void *application_job_thread(void *opaque) {
     if (!application_job_wait_for_mutations(job)) {
         application_job_execution_cancel(&execution);
     } else {
+        if (job->attempt_recorded &&
+            !cbm_mcp_index_attempt_transition(job->project_key, job->root_path, job->attempt_id,
+                                              "running", NULL, NULL, false)) {
+            cbm_log_warn("daemon.index.attempt_record", "project", job->project_key, "state",
+                         "running_write_failed");
+        }
         application_attempt_t attempt;
         application_attempt_status_t status =
             application_job_run_attempt(job, NULL, NULL, &attempt);
@@ -1556,6 +1667,18 @@ static char *application_index_project_key(const char *root_path, const char *ar
     return key;
 }
 
+static const char *application_index_origin(const char *args_json, char **owned_origin) {
+    *owned_origin = cbm_mcp_get_string_arg(args_json, "_cbm_index_origin");
+    if (*owned_origin &&
+        (strcmp(*owned_origin, "auto") == 0 || strcmp(*owned_origin, "watcher") == 0 ||
+         strcmp(*owned_origin, "explicit") == 0)) {
+        return *owned_origin;
+    }
+    free(*owned_origin);
+    *owned_origin = NULL;
+    return "explicit";
+}
+
 static size_t application_active_job_count_locked(cbm_daemon_application_t *application) {
     size_t count = 0;
     for (cbm_daemon_application_job_t *job = application->jobs; job; job = job->next) {
@@ -1587,6 +1710,7 @@ static bool application_index_args_normalize_defaults(yyjson_mut_val *root) {
     if (name && (!yyjson_mut_is_str(name) || yyjson_mut_get_len(name) == 0)) {
         (void)yyjson_mut_obj_remove_key(root, "name");
     }
+    (void)yyjson_mut_obj_remove_key(root, "_cbm_index_origin");
     return true;
 }
 
@@ -1619,6 +1743,9 @@ static cbm_daemon_application_job_t *application_job_subscribe_locked(
     if (application->stopping) {
         return NULL;
     }
+    char *requested_origin = cbm_mcp_get_string_arg(args_json, "_cbm_index_origin");
+    bool watcher_request = requested_origin && strcmp(requested_origin, "watcher") == 0;
+    free(requested_origin);
     cbm_daemon_application_job_t *job =
         application_find_active_job_locked(application, project_key);
     if (job) {
@@ -1631,6 +1758,9 @@ static cbm_daemon_application_job_t *application_job_subscribe_locked(
             return NULL;
         }
         job->subscribers++;
+        if (watcher_request && job->attempt_recorded) {
+            (void)cbm_mcp_index_attempt_mark_watcher_change(job->project_key, job->attempt_id);
+        }
         *status_out = APPLICATION_JOB_SUBSCRIBE_OK;
         return job;
     }
@@ -1656,6 +1786,20 @@ static cbm_daemon_application_job_t *application_job_subscribe_locked(
     }
     job->application = application;
     job->subscribers = 1;
+    cbm_index_resource_policy_t policy;
+    char policy_error[CBM_SZ_256] = {0};
+    char *owned_origin = NULL;
+    const char *origin = application_index_origin(args_json, &owned_origin);
+    if (cbm_mcp_index_policy_from_internal_args(args_json, &policy, policy_error,
+                                                sizeof(policy_error))) {
+        job->attempt_recorded =
+            cbm_mcp_index_attempt_begin(project_key, root_path, origin, &policy,
+                                        strcmp(origin, "watcher") == 0, job->attempt_id);
+    }
+    free(owned_origin);
+    if (!job->attempt_recorded) {
+        cbm_log_warn("daemon.index.attempt_record", "project", project_key, "state", "unavailable");
+    }
     job->next = application->jobs;
     application->jobs = job;
     if (application_job_thread_create(&job->thread, job) == 0) {
@@ -1666,6 +1810,11 @@ static cbm_daemon_application_job_t *application_job_subscribe_locked(
          * reservation back synchronously and let background callers retry. */
         application->jobs = job->next;
         job->next = NULL;
+        if (job->attempt_recorded) {
+            (void)cbm_mcp_index_attempt_transition(job->project_key, job->root_path,
+                                                   job->attempt_id, "failed", "worker_start_failed",
+                                                   NULL, false);
+        }
         application_job_free(job);
         *status_out = APPLICATION_JOB_SUBSCRIBE_UNAVAILABLE;
         cbm_log_warn("daemon.index.thread_start_failed", "action", "retry");
@@ -1985,6 +2134,7 @@ static char *application_auto_index_args(cbm_daemon_application_t *application,
     }
     yyjson_mut_doc_set_root(document, root);
     char *args = yyjson_mut_obj_add_strcpy(document, root, "repo_path", root_path) &&
+                         yyjson_mut_obj_add_str(document, root, "_cbm_index_origin", "auto") &&
                          application_index_args_add_policy(application, document, root)
                      ? yyjson_mut_write(document, 0, NULL)
                      : NULL;
@@ -3013,6 +3163,7 @@ cbm_daemon_application_t *cbm_daemon_application_new(
             application->watcher, application_watcher_mutation_begin,
             application_watcher_mutation_end, application_watcher_project_pruned, application);
     }
+    cbm_mcp_index_attempt_recover_abandoned();
     return application;
 }
 
@@ -3437,6 +3588,8 @@ static int application_background_index(cbm_daemon_application_t *application,
     }
     yyjson_mut_doc_set_root(document, root);
     bool encoded = yyjson_mut_obj_add_strcpy(document, root, "repo_path", canonical_root) &&
+                   yyjson_mut_obj_add_str(document, root, "_cbm_index_origin",
+                                          require_live_watch ? "watcher" : "explicit") &&
                    application_index_args_add_policy(application, document, root);
     char *default_project = cbm_project_name_from_path(canonical_root);
     bool custom_project =
 
@@ -86,6 +86,35 @@ static int git_capture(const char *repo_path, const char *git_args, char **out)
     return *out ? 0 : CBM_NOT_FOUND;
 }
 
+static int git_dirty_status(const char *repo_path, bool *dirty_out) {
+    if (!dirty_out || !repo_path || !git_validate_repo_path(repo_path)) {
+        return CBM_NOT_FOUND;
+    }
+    *dirty_out = false;
+#ifdef _WIN32
+    const char *null_dev = "NUL";
+#else
+    const char *null_dev = "/dev/null";
+#endif
+    char cmd[GIT_CMD_MAX];
+    int n = snprintf(
+        cmd, sizeof(cmd),
+        "git --no-optional-locks -C \"%s\" status --porcelain --untracked-files=normal 2>%s",
+        repo_path, null_dev);
+    if (n < 0 || n >= (int)sizeof(cmd)) {
+        return CBM_NOT_FOUND;
+    }
+    FILE *fp = cbm_popen(cmd, "r");
+    if (!fp) {
+        return CBM_NOT_FOUND;
+    }
+    char buffer[CBM_SZ_4K];
+    while (fread(buffer, 1, sizeof(buffer), fp) > 0) {
+        *dirty_out = true;
+    }
+    return cbm_pclose(fp) == 0 ? 0 : CBM_NOT_FOUND;
+}
+
 static bool path_is_absolute(const char *path) {
     if (!path || !path[0]) {
         return false;
@@ -239,6 +268,36 @@ void cbm_git_context_free(cbm_git_context_t *ctx) {
     memset(ctx, 0, sizeof(*ctx));
 }
 
+int cbm_git_snapshot_read(const char *path, cbm_git_snapshot_t *out) {
+    if (!out) {
+        return CBM_NOT_FOUND;
+    }
+    memset(out, 0, sizeof(*out));
+    char *head_sha = NULL;
+    int status = git_capture(path, "rev-parse --verify HEAD", &head_sha);
+    if (status != 0 || !head_sha || !head_sha[0]) {
+        free(head_sha);
+        return status == 0 ? CBM_NOT_FOUND : status;
+    }
+    bool dirty = false;
+    if (git_dirty_status(path, &dirty) != 0) {
+        free(head_sha);
+        return CBM_NOT_FOUND;
+    }
+    out->head_sha = head_sha;
+    out->available = true;
+    out->dirty = dirty;
+    return 0;
+}
+
+void cbm_git_snapshot_free(cbm_git_snapshot_t *snapshot) {
+    if (!snapshot) {
+        return;
+    }
+    free(snapshot->head_sha);
+    memset(snapshot, 0, sizeof(*snapshot));
+}
+
 int cbm_git_context_resolve(const char *path, cbm_git_context_t *out) {
     if (!out) {
         return CBM_NOT_FOUND;