taskledger 0.6.1__tar.gz → 0.6.2__tar.gz

{taskledger-0.6.1 → taskledger-0.6.2}/.ledger/releaseledger/data/ledgers/main/events/events.jsonl

@@ -11,3 +11,12 @@
 {"data":{"added_source_refs":["git:c1d0982"],"fields":["source_refs"],"removed_source_refs":[],"source_refs_mode":"merge"},"entry_id":"entry-0005","event":"entry.updated","event_id":"event-0011","record_revisions":{"entry:v0.6.1/entry-0005":2},"release_version":"v0.6.1","schema_version":2}
 {"data":{"added_source_refs":["git:94965d3"],"fields":["source_refs"],"removed_source_refs":[],"source_refs_mode":"merge"},"entry_id":"entry-0004","event":"entry.updated","event_id":"event-0012","record_revisions":{"entry:v0.6.1/entry-0004":2},"release_version":"v0.6.1","schema_version":2}
 {"data":{"released_at":"2026-08-14"},"event":"release.finalized","event_id":"event-0013","record_revisions":{"release:v0.6.1":7},"release_version":"v0.6.1","schema_version":2}
+{"data":{"status":"planned"},"event":"release.created","event_id":"event-0014","record_revisions":{"release:v0.6.2":1},"release_version":"v0.6.2","schema_version":2}
+{"data":{"kind":"added","status":"accepted"},"entry_id":"entry-0001","event":"entry.added","event_id":"event-0015","record_revisions":{"entry:v0.6.2/entry-0001":1,"release:v0.6.2":2},"release_version":"v0.6.2","schema_version":2}
+{"data":{"added_source_refs":[],"fields":["kind","summary"],"removed_source_refs":[],"source_refs_mode":"unchanged"},"entry_id":"entry-0001","event":"entry.updated","event_id":"event-0016","record_revisions":{"entry:v0.6.2/entry-0001":2},"release_version":"v0.6.2","schema_version":2}
+{"data":{"kind":"changed","status":"accepted"},"entry_id":"entry-0002","event":"entry.added","event_id":"event-0017","record_revisions":{"entry:v0.6.2/entry-0002":1,"release:v0.6.2":3},"release_version":"v0.6.2","schema_version":2}
+{"data":{"kind":"fixed","status":"accepted"},"entry_id":"entry-0003","event":"entry.added","event_id":"event-0018","record_revisions":{"entry:v0.6.2/entry-0003":1,"release:v0.6.2":4},"release_version":"v0.6.2","schema_version":2}
+{"data":{"kind":"docs","status":"accepted"},"entry_id":"entry-0004","event":"entry.added","event_id":"event-0019","record_revisions":{"entry:v0.6.2/entry-0004":1,"release:v0.6.2":5},"release_version":"v0.6.2","schema_version":2}
+{"data":{"added_source_refs":[],"fields":["summary"],"removed_source_refs":[],"source_refs_mode":"unchanged"},"entry_id":"entry-0002","event":"entry.updated","event_id":"event-0020","record_revisions":{"entry:v0.6.2/entry-0002":2},"release_version":"v0.6.2","schema_version":2}
+{"data":{"added_source_refs":[],"fields":["summary"],"removed_source_refs":[],"source_refs_mode":"unchanged"},"entry_id":"entry-0003","event":"entry.updated","event_id":"event-0021","record_revisions":{"entry:v0.6.2/entry-0003":2},"release_version":"v0.6.2","schema_version":2}
+{"data":{"released_at":"2026-08-15"},"event":"release.finalized","event_id":"event-0022","record_revisions":{"release:v0.6.2":6},"release_version":"v0.6.2","schema_version":2}

taskledger-0.6.2/.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0001.md

@@ -0,0 +1,27 @@
+---
+schema_version: 2
+object_type: release_entry
+versioning:
+  schema_version: 1
+  revision: 2
+entry_id: entry-0001
+release_version: v0.6.2
+kind: changed
+summary:
+  Automatic indexes cache bootstrapping before canonical mutations with quarantine-based
+  recovery for unbound caches
+status: accepted
+audience: null
+scopes: []
+source_refs:
+  - git:6305f28
+paths:
+  - taskledger/storage/index_cache.py
+issues: []
+prs: []
+sources: []
+contributors: []
+breaking: false
+internal: false
+order: 1
+---

taskledger-0.6.2/.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0002.md

@@ -0,0 +1,27 @@
+---
+schema_version: 2
+object_type: release_entry
+versioning:
+  schema_version: 1
+  revision: 2
+entry_id: entry-0002
+release_version: v0.6.2
+kind: changed
+summary:
+  Indexes mount is fixed to cache storage; `storage set indexes cache` is now
+  an idempotent topology request and non-cache indexes storage is rejected directly
+status: accepted
+audience: null
+scopes: []
+source_refs: []
+paths:
+  - taskledger/api/storage.py
+issues: []
+prs: []
+sources:
+  - git:6305f28
+contributors: []
+breaking: false
+internal: false
+order: 2
+---

taskledger-0.6.2/.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0003.md

@@ -0,0 +1,27 @@
+---
+schema_version: 2
+object_type: release_entry
+versioning:
+  schema_version: 1
+  revision: 2
+entry_id: entry-0003
+release_version: v0.6.2
+kind: fixed
+summary:
+  "`reindex` command now reports cache recovery results and surfaces structured
+  errors for recovery failures"
+status: accepted
+audience: null
+scopes: []
+source_refs: []
+paths:
+  - taskledger/services/tasks.py
+issues: []
+prs: []
+sources:
+  - git:6305f28
+contributors: []
+breaking: false
+internal: false
+order: 3
+---

taskledger-0.6.2/.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0004.md

@@ -0,0 +1,25 @@
+---
+schema_version: 2
+object_type: release_entry
+versioning:
+  schema_version: 1
+  revision: 1
+entry_id: entry-0004
+release_version: v0.6.2
+kind: docs
+summary: Documented indexes cache recovery behavior and multi-machine sync workflow
+status: accepted
+audience: null
+scopes: []
+source_refs: []
+paths:
+  - docs/command_contract.md
+issues: []
+prs: []
+sources:
+  - git:6305f28
+contributors: []
+breaking: false
+internal: false
+order: 4
+---

taskledger-0.6.2/.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/release.md

@@ -0,0 +1,26 @@
+---
+schema_version: 2
+object_type: release
+versioning:
+  schema_version: 1
+  revision: 6
+version: v0.6.2
+status: released
+title: Release v0.6.2
+released_at: "2026-08-15"
+previous_version: v0.6.1
+cancel_reason: null
+superseded_by: null
+changelog_file: null
+boundary_ref: null
+source_refs: []
+source_count: null
+entry_count: 4
+artifact_count: 0
+git_base_ref: null
+git_base_sha: null
+git_head_ref: null
+git_head_sha: null
+git_range: null
+git_commit_count: null
+---

{taskledger-0.6.1/taskledger.egg-info → taskledger-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskledger
-Version: 0.6.1
+Version: 0.6.2
 Summary: Durable project-state storage and CLI for coding workflows
 Author: Taskledger Contributors
 Maintainer: Holger Nahrstaedt

{taskledger-0.6.1 → taskledger-0.6.2}/docs/changelog.md

@@ -2,6 +2,23 @@
 
 > **Generated by releaseledger.** Manual edits may be overwritten. Update releaseledger entries and rebuild this file instead.
 
+## [v0.6.2] - 2026-08-15
+
+### Changed
+
+- Automatic indexes cache bootstrapping before canonical mutations with quarantine-based recovery for unbound caches
+- Indexes mount is fixed to cache storage; `storage set indexes cache` is now an idempotent topology request and non-cache indexes storage is rejected directly
+
+### Fixed
+
+- `reindex` command now reports cache recovery results and surfaces structured errors for recovery failures
+
+### Documentation
+
+- Documented indexes cache recovery behavior and multi-machine sync workflow
+
+<!-- generated by releaseledger -->
+
 ## [v0.6.1] - 2026-08-14
 
 ### Added

{taskledger-0.6.1 → taskledger-0.6.2}/docs/command_contract.md

@@ -664,15 +664,24 @@ taskledger ledger doctor
 ```
 
 Checkout-scoped indexes under the resolved cache mount are optional derived
-caches or registries. Task, plan, and run commands must continue to work from
-canonical Markdown/YAML records even when cache files are absent. The remaining
-derived caches may be plain JSON arrays with no version metadata and can be
-rebuilt with:
+caches or registries. Read-only commands continue to work from canonical
+Markdown/YAML records and do not initialize a missing cache. Before a canonical
+mutation, Taskledger initializes a missing or empty cache binding and rebuilds
+the derived indexes. A non-empty cache without its binding marker is atomically
+quarantined beside the cache and rebuilt from canonical records. Conflicting or
+invalid markers, symlinks, and non-directory cache paths are not adopted
+automatically. The remaining derived caches may be plain JSON arrays with no
+version metadata and can be rebuilt explicitly with:
 
 ```bash
 taskledger reindex
 ```
 
+`taskledger repair index` uses the same recovery path and reports any quarantine
+location. The `indexes` mount is fixed to cache storage, so
+`taskledger storage set indexes cache` is an idempotent topology request;
+non-cache indexes storage is rejected directly.
+
 A newer storage version than the installed taskledger supports is rejected with
 a clear error.
 

{taskledger-0.6.1 → taskledger-0.6.2}/docs/sync.md

@@ -42,6 +42,15 @@ taskledger sync git push
 
 ## Second PC bootstrap
 
+Indexes are checkout-local derived state and are not synchronized between PCs.
+After opening a project on a new machine, deleting the local cache, or allowing
+the cache to be evicted, read-only commands continue to use canonical records.
+The first mutating command creates the local Ledgercore cache binding and
+rebuilds the indexes automatically; no second `taskledger init` is required.
+If a non-empty unbound cache is found, Taskledger preserves it as an
+`indexes.quarantine-*` sibling before rebuilding. Use `taskledger repair index`
+for explicit cache health repair.
+
 Clone both repositories as siblings:
 
 ```bash

{taskledger-0.6.1 → taskledger-0.6.2}/skills/taskledger/SKILL.md

@@ -459,7 +459,13 @@ Lock recovery decision tree:
 - If doctor reports a running implementation run with no matching lock and the task is still resumable, run `taskledger implement resume --task TASK --run RUN --reason "Reacquire implementation lock."`.
 - Never use repair to bypass approval, validation, or active implementation locks.
 - If validation fails, record the failure and return to implementation or replanning.
-- If indexes are stale, run `taskledger repair index`; `taskledger reindex` is a compatibility alias.
+- Missing or empty checkout-local indexes caches are bootstrapped automatically
+  before canonical mutations and rebuilt from authoritative records. A
+  non-empty unbound cache is quarantined rather than deleted; conflicting
+  markers are not auto-adopted. Read-only commands do not bootstrap the cache.
+- If indexes are stale or an unusual cache-binding problem needs explicit
+  repair, run `taskledger repair index`; `taskledger reindex` is a compatibility
+  alias. Do not tell users to manually create `.ledger-project.toml`.
 - If a task is truly cancelled and the user wants to continue, use `taskledger task uncancel --task TASK_REF --reason "..." [--to STAGE]` to restore a safe durable stage before re-entering an active stage.
 - If dependencies must be bypassed, only a user waiver may unblock implementation.
 

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.1'
-__version_tuple__ = version_tuple = (0, 6, 1)
+__version__ = version = '0.6.2'
+__version_tuple__ = version_tuple = (0, 6, 2)
 
-__commit_id__ = commit_id = 'g7491339c7'
+__commit_id__ = commit_id = 'g196a79e85'

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/api/storage.py

@@ -148,6 +148,23 @@ def storage_set(
 ) -> dict[str, object]:
     if mode not in {"copy", "move"}:
         raise LaunchError("mode must be copy or move")
+    if mount == "indexes":
+        if storage != "cache":
+            raise LaunchError(
+                "TASKLEDGER_STORAGE_BINDING_INVALID: The Taskledger indexes mount "
+                "is fixed to cache storage.",
+                details={"mount": mount, "requested_storage": storage},
+                remediation=["Run `taskledger repair index` to rebuild the cache."],
+            )
+        report = build_storage_location_report(
+            workspace_root, require_initialized=False
+        ).to_dict()
+        report["unchanged"] = True
+        report["message"] = "Indexes already use cache storage."
+        report["remediation"] = (
+            "Run `taskledger repair index` to rebuild the indexes cache."
+        )
+        return report
     if storage == "external" and not external_root:
         raise LaunchError("external storage requires --root")
     migrate_taskledger_mount(

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/cli_misc.py

@@ -1210,7 +1210,11 @@ def emit_can_command(ctx: typer.Context, task_ref: str | None, action: str) -> N
 
 def emit_reindex_command(ctx: typer.Context) -> None:
     state = cli_state_from_context(ctx)
-    payload = reindex(state.cwd)
+    try:
+        payload = reindex(state.cwd)
+    except LaunchError as exc:
+        emit_error(ctx, exc)
+        raise typer.Exit(code=launch_error_exit_code(exc)) from exc
     emit_payload(ctx, payload, human="reindexed v2 task state")
 
 

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/errors.py

@@ -36,6 +36,7 @@ STORAGE_ERROR_CODES = frozenset(
         "TASKLEDGER_LEDGER_SCHEMA_MIGRATION_REQUIRED",
         "TASKLEDGER_REGISTRATION_INVALID",
         "TASKLEDGER_STORAGE_BINDING_INVALID",
+        "TASKLEDGER_CACHE_RECOVERY_FAILED",
         "TASKLEDGER_EXTERNAL_STORE_INVALID",
         "TASKLEDGER_STORAGE_MIGRATION_ACTIVE_LOCKS",
         "TASKLEDGER_STORAGE_MIGRATION_BLOCKED",
@@ -275,6 +276,12 @@ class StorageCorruption(LaunchError):
     error_type = "StorageCorruption"
 
 
+class CacheRecoveryFailed(LaunchError):
+    code = "TASKLEDGER_CACHE_RECOVERY_FAILED"
+    exit_code = 4
+    error_type = "CacheRecoveryFailed"
+
+
 class ActiveTaskNotFound(StorageCorruption):
     code = "ACTIVE_TASK_NOT_FOUND"
     error_type = "StorageCorruption"

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/services/tasks.py

@@ -1564,12 +1564,18 @@ def task_dossier(
 
 
 def reindex(workspace_root: Path) -> dict[str, object]:
+    from taskledger.storage.project_context import require_mutable_project_context
+
+    context = require_mutable_project_context(workspace_root)
     paths = ensure_v2_layout(workspace_root)
     counts = rebuild_v2_indexes(paths)
     _append_event(
         workspace_root, "*", "repair.index", dict(cast(dict[str, object], counts))
     )
-    return {"kind": "taskledger_reindex", "counts": counts}
+    payload: dict[str, object] = {"kind": "taskledger_reindex", "counts": counts}
+    if context.cache_recovery is not None:
+        payload["cache_recovery"] = context.cache_recovery.to_dict()
+    return payload
 
 
 def repair_task_record(*args, **kwargs):  # type: ignore[no-untyped-def]

taskledger-0.6.2/taskledger/storage/index_cache.py

@@ -0,0 +1,199 @@
+"""Safe recovery for Taskledger's disposable indexes cache."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+from uuid import uuid4
+
+from filelock import FileLock
+
+from taskledger.errors import CacheRecoveryFailed, LaunchError
+from taskledger.storage.ledgercore_backend import (
+    INDEX_MOUNT,
+    initialize_taskledger_bindings,
+    validate_taskledger_mount,
+)
+
+if TYPE_CHECKING:
+    from taskledger.storage.project_context import TaskledgerProjectContext
+
+
+@dataclass(frozen=True, slots=True)
+class IndexCacheRecoveryResult:
+    """Describe local cache maintenance performed before a mutation."""
+
+    action: Literal["initialized", "rebuilt", "quarantined_rebuilt"]
+    cache_root: Path
+    quarantine_path: Path | None
+    counts: dict[str, int]
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "action": self.action,
+            "cache_path": str(self.cache_root),
+            "quarantine_path": (
+                str(self.quarantine_path) if self.quarantine_path is not None else None
+            ),
+            "counts": dict(self.counts),
+        }
+
+
+def _index_validation_result(
+    context: TaskledgerProjectContext, root: Path
+) -> Any | None:
+    report = context.storage_validation
+    if report is None:
+        return None
+    return next(
+        (result for result in report.results if result.path == root),
+        None,
+    )
+
+
+def _safe_recovery_candidate(context: TaskledgerProjectContext) -> bool:
+    if context.mode != "canonical" or context.layout is None:
+        return False
+    if context.initialization.status != "ready":
+        return False
+    manifest = getattr(context.loaded_project, "manifest", None)
+    if getattr(manifest, "schema_version", None) != 3:
+        return False
+    if (
+        not context.paths.data_root.is_dir()
+        or not context.paths.storage_meta_path.is_file()
+    ):
+        return False
+    index_mount = context.layout.mounts.get(INDEX_MOUNT)
+    if index_mount is None or index_mount.storage != "cache":
+        return False
+
+    root = index_mount.path
+    index_result = _index_validation_result(context, root)
+    if index_result is not None and index_result.path != root:
+        return False
+    report = context.storage_validation
+    if report is not None and any(
+        not result.valid and result.path != root for result in report.results
+    ):
+        return False
+    return True
+
+
+def _expected_index_files_missing(context: TaskledgerProjectContext) -> bool:
+    paths = context.paths
+    return any(
+        not path.is_file()
+        for path in (
+            paths.task_index_path,
+            paths.active_locks_index_path,
+            paths.sidecar_index_path,
+            paths.introductions_index_path,
+            paths.dependencies_index_path,
+        )
+    )
+
+
+def _unique_quarantine_path(root: Path) -> Path:
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    while True:
+        candidate = root.with_name(f"{root.name}.quarantine-{stamp}-{uuid4().hex[:8]}")
+        if not candidate.exists() and not candidate.is_symlink():
+            return candidate
+
+
+def _recovery_failure(
+    root: Path,
+    quarantine: Path | None,
+    exc: Exception,
+) -> CacheRecoveryFailed:
+    return CacheRecoveryFailed(
+        "TASKLEDGER_CACHE_RECOVERY_FAILED: unable to rebuild indexes cache "
+        f"{root}: {exc}",
+        details={
+            "cache_path": str(root),
+            "quarantine_path": str(quarantine) if quarantine is not None else None,
+            "operation": "rebuild",
+            "cause": str(exc),
+        },
+        remediation=[
+            "Run `taskledger storage validate`.",
+            "Run `taskledger repair index`.",
+        ],
+    )
+
+
+def ensure_indexes_cache_for_mutation(
+    context: TaskledgerProjectContext,
+) -> IndexCacheRecoveryResult | None:
+    """Prepare the disposable indexes mount before writing derived state.
+
+    This helper is intentionally narrow: it only handles a canonical schema-3
+    cache mount after persistent config/data storage has validated successfully.
+    """
+    if not _safe_recovery_candidate(context):
+        return None
+
+    layout = context.layout
+    if layout is None:
+        return None
+    index_mount = layout.mounts[INDEX_MOUNT]
+    root = index_mount.path
+    root.parent.mkdir(parents=True, exist_ok=True)
+
+    with FileLock(f"{root}.recovery.lock"):
+        if root.is_symlink() or (root.exists() and not root.is_dir()):
+            return None
+
+        marker = root / ".ledger-project.toml"
+        if marker.is_symlink():
+            return None
+
+        # Re-check after locking so a concurrent mutation can safely win.
+        validation = validate_taskledger_mount(index_mount, allow_missing=True)
+        if marker.exists():
+            if not validation.valid:
+                return None
+            if not _expected_index_files_missing(context):
+                return None
+            try:
+                from taskledger.storage.indexes import rebuild_v2_indexes
+                from taskledger.storage.task_store import v2_paths_from_context
+
+                counts = rebuild_v2_indexes(v2_paths_from_context(context))
+            except (LaunchError, OSError) as exc:
+                raise _recovery_failure(root, None, exc) from exc
+            return IndexCacheRecoveryResult("rebuilt", root, None, counts)
+
+        quarantine: Path | None = None
+        try:
+            if root.exists():
+                if any(root.iterdir()):
+                    quarantine = _unique_quarantine_path(root)
+                    root.rename(quarantine)
+
+            initialize_taskledger_bindings(
+                layout,
+                initialize_config=False,
+                initialize_data=False,
+                initialize_indexes=True,
+            )
+            from taskledger.storage.indexes import rebuild_v2_indexes
+            from taskledger.storage.task_store import v2_paths_from_context
+
+            counts = rebuild_v2_indexes(v2_paths_from_context(context))
+        except (LaunchError, OSError) as exc:
+            marker = root / ".ledger-project.toml"
+            if marker.is_file() and not marker.is_symlink():
+                marker.unlink(missing_ok=True)
+            raise _recovery_failure(root, quarantine, exc) from exc
+
+        action: Literal["initialized", "quarantined_rebuilt"] = (
+            "quarantined_rebuilt" if quarantine is not None else "initialized"
+        )
+        return IndexCacheRecoveryResult(action, root, quarantine, counts)
+
+
+__all__ = ["IndexCacheRecoveryResult", "ensure_indexes_cache_for_mutation"]

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/storage/ledgercore_backend.py

@@ -40,7 +40,11 @@ from ledgercore.manifest import (
     LedgerRegistration,
     MountDefinition,
 )
-from ledgercore.storage_binding import StorageBindingError, read_storage_binding
+from ledgercore.storage_binding import (
+    StorageBindingError,
+    read_storage_binding,
+    validate_storage_binding,
+)
 
 TOOL_NAME = "taskledger"
 DATA_MOUNT = "data"
@@ -302,6 +306,11 @@ def initialize_taskledger_bindings(
     return results
 
 
+def validate_taskledger_mount(mount: Any, *, allow_missing: bool = False) -> Any:
+    """Validate one resolved mount through the Ledgercore adapter boundary."""
+    return validate_storage_binding(mount, allow_missing=allow_missing)
+
+
 def initialize_taskledger_external_store(layout: Any) -> bool:
     """Initialize an external root only during explicit Taskledger init."""
     mount = layout.mounts[DATA_MOUNT]
@@ -453,6 +462,7 @@ __all__ = [
     "ensure_taskledger_ledger_registration",
     "execute_taskledger_layout_migration",
     "initialize_taskledger_bindings",
+    "validate_taskledger_mount",
     "load_taskledger_ledger_layout",
     "locate_taskledger_project",
     "initialize_taskledger_external_store",

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger/storage/project_context.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import importlib
+import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Literal, cast
@@ -135,6 +136,7 @@ class TaskledgerProjectContext:
     legacy_locator: ProjectPaths | None
     loaded_project: Any | None = None
     storage_validation: Any | None = None
+    cache_recovery: Any | None = None
     local_overrides_present: bool = False
     # Compatibility fields are derived values, not configuration ownership.
     store_root: Path | None = None
@@ -388,9 +390,28 @@ def require_mutable_project_context(
     """Require a real initialized project before any command may write state."""
     context = load_project_context(
         start,
-        require_initialized=True,
+        require_initialized=False,
         allow_legacy=allow_legacy,
     )
+    cache_recovery = None
+    if context.mode == "canonical":
+        from taskledger.storage.index_cache import ensure_indexes_cache_for_mutation
+
+        cache_recovery = ensure_indexes_cache_for_mutation(context)
+        context = load_project_context(
+            start,
+            require_initialized=True,
+            allow_legacy=allow_legacy,
+        )
+        if cache_recovery is not None:
+            from dataclasses import replace
+
+            context = replace(context, cache_recovery=cache_recovery)
+            if cache_recovery.quarantine_path is not None:
+                logging.getLogger(__name__).warning(
+                    "Taskledger quarantined the unbound indexes cache at %s",
+                    cache_recovery.quarantine_path,
+                )
     if context.mode == "legacy":
         required = (
             context.paths.project_dir,

{taskledger-0.6.1 → taskledger-0.6.2/taskledger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskledger
-Version: 0.6.1
+Version: 0.6.2
 Summary: Durable project-state storage and CLI for coding workflows
 Author: Taskledger Contributors
 Maintainer: Holger Nahrstaedt

{taskledger-0.6.1 → taskledger-0.6.2}/taskledger.egg-info/SOURCES.txt

@@ -158,6 +158,11 @@ specmason.toml
 .ledger/releaseledger/data/ledgers/main/releases/v0.6.1/entries/entry-0003.md
 .ledger/releaseledger/data/ledgers/main/releases/v0.6.1/entries/entry-0004.md
 .ledger/releaseledger/data/ledgers/main/releases/v0.6.1/entries/entry-0005.md
+.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/release.md
+.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0001.md
+.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0002.md
+.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0003.md
+.ledger/releaseledger/data/ledgers/main/releases/v0.6.2/entries/entry-0004.md
 .ledger/task/config.toml
 .ledger/taskledger/.ledger-project.toml
 .ledger/taskledger/config.toml
@@ -417,6 +422,7 @@ taskledger/storage/atomic.py
 taskledger/storage/common.py
 taskledger/storage/events.py
 taskledger/storage/frontmatter.py
+taskledger/storage/index_cache.py
 taskledger/storage/indexes.py
 taskledger/storage/init.py
 taskledger/storage/layout_migration.py
@@ -478,6 +484,7 @@ tests/test_implementation_change_scan.py
 tests/test_implementation_checks.py
 tests/test_import_boundaries.py
 tests/test_indexes.py
+tests/test_indexes_cache_recovery.py
 tests/test_json_contracts.py
 tests/test_ledger_manifest_mutation.py
 tests/test_ledgercore_compat.py