cskill-agents

Collapse multiple change sources into one caller-facing boolean so headless bootstraps know whether a downstream refresh is necessary.

After awaiting persistence work, update the shared budget state for each `tool_use_id` exactly once so no concurrent reader ever sees a half-committed decision.

Issue continuation nudges while the turn stays under budget, then halt once diminishing returns or the budget cap justify stopping.

Lazily extract referenced files for bundled skills so large prompts stay offline until needed.

Persist a cache-safe stop-hook context snapshot only for main session queries so later helpers can resume from stable state without fork pollution.

Sweep stale extension caches before activation, then fall back to a sticky manual-refresh flag if the live refresh fails.

Warm the authoritative cache path first, then fan out cache-only readers in parallel so derived loaders never race stale state.

Emit low-cost debug telemetry for skill-listing batches that records batch size, initial-vs-dynamic mode, and cumulative sent count without logging the payload body.

Distill the compact boundary delta into the session memory summary and the freshest user cues needed for skill capture prompts.

Persist deterministic artifacts with a create-only write and treat existing files as replay success instead of an error.

Skip update actions that point at missing local paths when a valid materialized entry already exists, preserving the working state instead of converting drift into a noisy failure.

Decide when to auto-refresh plugins after marketplaces change and when to defer to a manual `/reload-plugins` via the `needsRefresh` flag.

Project marketplace installation progress by diffing declared sources before kickoff so the UI shows pending spinners without waiting on the clone.

Guard requests from closing instantly when a tool returns nothing by injecting the sentinel message and logging the event.

Fail fast when the repository has no refs so downstream bundling never triggers empty Git bundles.

Skip nested memory collection when no triggers exist so render-bound `getAppState()` is never invoked unnecessarily.

Journal each per-message tool result replacement so resume logic replays the exact preview the model saw.

When a declared source is only a fallback default, treat any existing materialized source as satisfying the contract instead of forcing a replacement.

Reconstruct child replacement state from local records first, then fill uncovered gaps from the parent's live map.

Propagate CLI flags/environment variables from the leader into tmux teammates so they share permission mode, plugins, and env configuration.

Skip the background memory extractor when the main agent already persisted memory during the same turn to avoid duplicates and race hazards.

Normalize the main thread to a concrete empty-string key so agent-scoped state maps treat main and forked threads uniformly.

Gate cached microcompact cache edits to the main thread so background forks cannot alter the shared cache state.

Filter prefetched memory attachments against cumulative read state before mutating that state, so async surfacing does not dedupe itself away.

React to marketplace materialization diffs by refreshing plugins when new installs land and escalating to needsRefresh when updates or refresh failures occur.

Ensure memory directories exist once and surface consistent guidance so agents skip redundant mkdir calls.

Keep MEMORY.md terse by capping entries, warning when caps hit, and pointing each memory to its own file.

Inject mode-specific skip rules into a shared reconciler so unsupported source types are recorded and skipped without forking the core install logic.

Process every nested-memory trigger before wiping the trigger set so subsequent iterations only see new paths.

Return no attachment when an incremental skill delta has no unseen items instead of emitting a formally empty update payload.

Map async marketplace reconciliation events into AppState rows so UIs show install/installing/failed badges without blocking.

Validate remote numeric override maps defensively so null, non-finite, or negative flag payloads never corrupt runtime thresholds.

Design skill steps with explicit execution topology, asking which parts run directly, in subagents, in teammate swarms, or in parallel.

Return a narrow stop-hook result that can halt the query loop without throwing, while still surfacing blocking errors separately.

Collect stop-hook progress/errors, emit a structured prevented-continuation attachment, and summarize the block for users and logs.

Capture in-flight WIP via `git stash create`, make it reachable through temporary refs, and tear down the refs after bundling finishes.

Mark the current skill listing as already sent when resuming so the transcript does not receive a redundant payload.

Trim user and system context based on the agent’s role so read-only helpers don’t inherit stale git or CLAUDE metadata.

Prevent session-memory background forks from draining teammate mailbox attachments that belong to the main lead thread.

Reset skill-listing announcement state only when the underlying skill set actually changes, not on compaction or transcript churn.