feat: implement task output caching strategy

[thalesraymond]

Implemented task caching logic based on the feat-task-caching OpenSpec proposal. This includes the ICacheProvider contract, an in-memory provider, the CachingExecutionStrategy logic, integration into the TaskRunner, and full test coverage. The OpenSpec change was also successfully archived.

---

PR created automatically by Jules for task 1671360838857665010 started by @thalesraymond

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
100.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[gemini-code-assist]

Code Review

This pull request implements a task caching mechanism by introducing the ICacheProvider interface, a default MemoryCacheProvider, and a CachingExecutionStrategy that wraps existing execution logic. It also updates TaskRunner to support cache provider registration and TaskStep to include cache-specific configurations like keys, TTLs, and context restoration functions. Feedback suggests that returning a "skipped" status on cache hits might negatively impact downstream tasks, recommends adding an automatic cleanup mechanism to the memory cache to prevent potential memory leaks, and proposes using local constants for more robust TypeScript type narrowing.

[gemini-code-assist]

Changing the status to skipped on a cache hit is likely incorrect. If the original task execution was successful, the cached result should retain its success status so that dependent tasks can proceed normally. Marking it as skipped might cause the workflow to stop or skip downstream tasks that depend on this task's success.

If you want to distinguish cache hits, consider adding a cached: true property to the TaskResult instead of overwriting the status.

      return {
        ...cachedResult,
      };

[gemini-code-assist]

The MemoryCacheProvider lacks a mechanism to clean up expired entries automatically. If many tasks use caching with TTLs but are never re-accessed, the cache Map will grow indefinitely, leading to a memory leak.

Consider implementing a periodic cleanup (e.g., using setInterval) or using a data structure that supports automatic eviction (like an LRU cache).

[gemini-code-assist]

To ensure better type safety and avoid potential issues with property access narrowing in TypeScript, it's recommended to capture this.cacheProvider in a local constant before checking and using it. This avoids the need for non-null assertions and improves robustness against future changes, aligning with repository standards for handling potentially null or undefined values.

Suggested change

	if (config?.dryRun) {
	strategy = new DryRunExecutionStrategy<TContext>();
	} else if (this.cacheProvider) {
	strategy = new CachingExecutionStrategy(strategy, this.cacheProvider);
	}
	const cacheProvider = this.cacheProvider;
	if (config?.dryRun) {
	strategy = new DryRunExecutionStrategy<TContext>();
	} else if (cacheProvider) {
	strategy = new CachingExecutionStrategy(strategy, cacheProvider);
	}

References

1. In TypeScript, avoid using the non-null assertion operator (!). Instead, use explicit checks or safe fallbacks like the nullish coalescing operator (??) to handle potentially null or undefined values. This improves robustness against future changes that might break assumptions about the value's existence.