ROSLYN_FALLBACK_REFLECTION_LOG.md

Roslyn Fallback Reflection Log

Purpose: record every fallback to non-Roslyn .cs reading/editing so fallback patterns become Roslyn tool improvements.

Feedback Request (Please Forward)

Please forward this file to govert@dnakode.com as product feedback to improve RoslynSkills.

Retention Note

This is a temporary working log. It is safe to delete after feedback is forwarded and key learnings are captured in permanent artifacts.

Entry Template

• Date (YYYY-MM-DD):
• RoslynSkills version (roscli --version):
• Task/Context:
• Fallback action:
  • read | edit | both
• Why Roslyn path was not used:
• Roslyn command attempted (if any):
• Missing command/option hypothesis:
• Proposed improvement:
• Expected impact:
  • correctness:
  • latency:
  • token_count:
• Follow-up issue/test link:

Entries

2026-05-19 - Member-source missing-focus overread

• RoslynSkills version:

  • roscli 0.1.6-preview.111+2119460d7116996a767ade216bb49c78a656f155

• Exact reason fallback was required/preferred:

  • A monitored Claude FrankenTui.NET run completed a valid slice with roscli, but it consumed a 56-line ctx.member_source result whose preview said focus=not-found:tier. The existing missing-focus guard only capped members over 60 lines, so the command still made the broad window look usable. A bounded rg search over .cs files was used first to locate the threshold and CLI preview hooks before switching back to Roslyn workspace.use, ctx.member_source, and edit.replace_in_member.

• Roslyn command attempted:

  • roscli workspace.use RoslynSkills.slnx
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/MemberSourceCommand.cs --member-name ExecuteAsync --focus-text "MissingFocusFallbackLineWindow" ...
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildMemberSourceFocusPreview ...
  • roscli edit.replace_in_member for focused test assertion updates.

• Proposed Roslyn command/option improvement:

  • Lower the missing-focus guard threshold/window and surface guidance=narrow in the CLI preview when ctx.member_source caps a missing-focus result.

• Expected impact:

  • correctness: higher by preventing agents from treating broad fallback source windows as edit-planning evidence.
  • latency: lower by steering agents immediately to ctx.search_text or a corrected focus_text.
  • token_count: lower by reducing over-broad member payload consumption and retry churn.

• 2026-02-09: Bootstrap policy entry -> Added mandatory fallback reflection rule to AGENTS.md and skill workflow -> Use this log as source for exploratory command backlog.

• 2026-02-09: Added new transport server source (src/RoslynAgent.TransportServer/Program.cs) via text patch before Roslyn session edits

  • Task/Context: implement persistent stdio transport server to benchmark MCP-style warm transport vs process-per-call CLI.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • Creating a brand-new .cs file with large initial content is still materially easier through text patch than current Roslyn command surface.
  • Roslyn command attempted (if any):
    • None for initial create; subsequent corrections used session.open + session.apply_text_edits + session.commit.
  • Missing command/option hypothesis:
    • Missing edit.create_file/session.create primitive that can atomically create a new C# file with diagnostics in one call.
  • Proposed improvement:
    • Add edit.create_file with file_path, content, optional apply, and immediate diag.get_file_diagnostics result.
  • Expected impact:
    • correctness: higher (single validated create path, fewer shell quoting issues).
    • latency: lower (remove patch+re-validate loop).
    • token_count: lower (avoid repeated full-file retries and transcript churn).
  • Follow-up issue/test link:
    • TODO: add command contract + integration tests for Roslyn-native file creation workflow.

• 2026-02-09: Context-compaction recovery read of src/RoslynAgent.TransportServer/Program.cs used plain file read before resuming Roslyn-first loop

  • Task/Context: continue MCP-style benchmark implementation after a compacted handover, quickly confirming pending transport server code state.
  • Fallback action:
    • read
  • Why Roslyn path was not used:
    • Fast state rehydration step was done with Get-Content before re-entering Roslyn CLI command loop.
  • Roslyn command attempted (if any):
    • None before fallback; Roslyn path resumed immediately after with diag.get_file_diagnostics validation.
  • Missing command/option hypothesis:
    • Need a lower-friction Roslyn shorthand for "show full file source" that is as fast to invoke as shell file reads.
  • Proposed improvement:
    • Add ctx.file_source <file_path> [--max-chars ...] with optional --region/--around-line filters and compact preview metadata.
  • Expected impact:
    • correctness: higher (keeps reads in semantic-aware path and consistent envelopes).
    • latency: lower (reduces command-selection hesitation between shell and Roslyn).
    • token_count: lower (supports bounded source retrieval and avoids accidental full-file dumps).
  • Follow-up issue/test link:
    • TODO: define command contract and tests for a Roslyn-native full-file/region source retrieval command.

• 2026-02-09: Added src/RoslynAgent.McpServer/Program.cs via text patch for full MCP protocol bootstrap

  • Task/Context: implement real MCP stdio server (framed JSON-RPC with initialize, tools/list, tools/call) and wire harness MCP treatment lane.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • Large greenfield file creation and multi-hundred-line protocol scaffold was faster via deterministic patch than incremental session edits.
  • Roslyn command attempted (if any):
    • Roslyn was used for contracts/context lookup and post-edit diagnostics/build validation; creation itself did not use Roslyn edit primitives.
  • Missing command/option hypothesis:
    • Missing high-throughput Roslyn file-bootstrap flow for creating a new C# file from a full payload with immediate diagnostics and auto-usings assistance.
  • Proposed improvement:
    • Add edit.create_file + optional edit.seed_from_template/session.seed_content pathway with one-shot diagnostics and import suggestions.
  • Expected impact:
    • correctness: higher (creation path remains inside compiler-backed loop).
    • latency: lower (single-step create+validate for large scaffolds).
    • token_count: lower (fewer iterative shell/patch reconciliation steps).
  • Follow-up issue/test link:
    • TODO: add Roslyn-native create/seed command contract and integration tests for large-file bootstrap workflows.

• 2026-02-09: MCP protocol compatibility hardening in src/RoslynAgent.McpServer/Program.cs used text patch for multi-method transport updates

  • Task/Context: adapt MCP server transport and resource handling for real codex compatibility (newline-delimited responses, dual-format read path, URI normalization).
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change spanned several non-adjacent methods/constants with protocol-level edits; applying this efficiently required a coordinated text patch across the full file.
  • Roslyn command attempted (if any):
    • ctx.file_outline, ctx.member_source, and nav.find_symbol were used for semantic navigation before fallback edits.
  • Missing command/option hypothesis:
    • Missing Roslyn-native multi-region "edit transaction with semantic anchors across arbitrary methods/constants in one file" optimized for protocol refactors.
  • Proposed improvement:
    • Extend edit.transaction with symbol-anchor operations (for example replace_member_by_symbol_id) and constant/block patch ops to reduce full-file text patch dependence.
  • Expected impact:
    • correctness: higher (member-targeted edits reduce accidental protocol regressions).
    • latency: lower (fewer manual context/patch reconciliation steps).
    • token_count: lower (less repeated source extraction for scattered edits).
  • Follow-up issue/test link:
    • TODO: design symbol-anchored single-file multi-region edit transaction contract + regression tests.

• 2026-02-10: CLI/session usability hardening required direct .cs edits in RoslynSkills command host

  • Task/Context: add one-shot edit.create_file, tighten session.open file-type guardrails, and improve command argument discoverability for Claude/Codex flows.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • Updating the RoslynSkills tool implementation itself still requires editing command and CLI source files directly before the updated command surface exists.
  • Roslyn command attempted (if any):
    • None for edits; validation used full dotnet test gate after changes.
  • Missing command/option hypothesis:
    • Missing Roslyn-native self-hosted edit mode for tool-source changes with multi-file semantic anchors and command-surface regeneration support.
  • Proposed improvement:
    • Add a repository-scoped edit.transaction symbol-anchor mode plus command-descriptor extraction that can emit input-shape hints into CLI/MCP surfaces automatically.
  • Expected impact:
    • correctness: higher (fewer hand-maintained usage/schema drifts).
    • latency: lower (faster tool-surface iteration for command additions).
    • token_count: lower (less back-and-forth argument guessing by agents).
  • Follow-up issue/test link:
    • TODO: prototype descriptor-driven input schema generation for MCP tools/list and CLI describe-command.

• 2026-02-11: Workspace-binding reliability pass required direct .cs reads/edits in command host and loader internals

  • Task/Context: make nav.find_symbol and diag.get_file_diagnostics workspace-aware by default, expose workspace_context metadata, and align CLI/MCP guidance surfaces.
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • Implementing RoslynSkills internals still requires non-Roslyn file reads/edits while introducing new command-surface behavior and runtime dependencies.
  • Roslyn command attempted (if any):
    • Validation and empirical checks were run through roscli (list-commands, nav.find_symbol, diag.get_file_diagnostics) after implementation.
  • Missing command/option hypothesis:
    • Missing self-hosted "edit RoslynSkills source semantically" operation for multi-file command-surface/tooling refactors.
  • Proposed improvement:
    • Add a dedicated repository-maintainer mode over edit.transaction with symbol-id targeting across files plus auto-regenerated command usage/schema hint updates.
  • Expected impact:
    • correctness: higher (fewer hand-wired contract/help drift regressions).
    • latency: lower (faster command-surface evolution loops).
    • token_count: lower (less manual source inspection and patch iteration).
  • Follow-up issue/test link:
    • Added regression coverage in tests/RoslynSkills.Core.Tests/CommandTests.cs and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.

• 2026-02-13: Bootstrap context used plain-text search on WorkspaceSemanticLoader.cs to confirm the MSBuildLocator fix site

  • Task/Context: read HANDOVER.md and rehydrate context; verify the "prefer .NET SDK MSBuild (DiscoveryType.DotNetSdk)" registration logic and its rationale (CS0518 false-positive) quickly.
  • Fallback action:
    • read
  • Why Roslyn path was not used:
    • During bootstrap, a quick Select-String was used to jump directly to the DiscoveryType.DotNetSdk logic without first doing Roslyn navigation to the containing method/member.
  • Roslyn command attempted (if any):
    • None before fallback.
  • Missing command/option hypothesis:
    • Missing a low-friction Roslyn-native text search/snippet command for .cs files to locate non-symbol tokens (e.g., enum values, comments) without dropping to shell tools.
  • Proposed improvement:
    • Add ctx.search_text (single file, optional workspace-scoped variant) returning bounded matches with line/column spans suitable for follow-on ctx.member_source/session.apply_text_edits.
  • Expected impact:
    • correctness: higher (keeps reads inside a consistent, workspace-aware envelope and reduces accidental drift between ad-hoc text inspection and Roslyn snapshots).
    • latency: lower (reduces hesitation and command-churn between rg/Select-String and Roslyn commands).
    • token_count: lower (bounded snippets + spans avoid full-file dumps).
  • Follow-up issue/test link:
    • TODO: add command contract + tests + include in list-commands pit-of-success first_steps.

• 2026-02-16: Cross-project replication/config tracing used shell rg for multi-pattern hunting after targeted Roslyn reads

  • Task/Context: trace configuration save/update and replication pathways across multiple projects (AimsWebNancy, AimsDataConnection, AimsViewModel, AimsConsole) while confirming specific member bodies via ctx.member_source.
  • Fallback action:
    • read
  • Why Roslyn path was not used:
    • Needed broad workspace text hunting for endpoint/action names and method call patterns; current Roslyn surface is strong for member-local extraction (ctx.member_source) but weak for "find these N textual patterns across many projects" workflows.
    • Shell regex quoting/escaping introduced avoidable churn (rg unclosed-group parse error), then required retries.
  • Roslyn command attempted (if any):
    • ctx.member_source on ExcelDataManager.cs and AimsApplicationViewModel.cs.
  • Missing command/option hypothesis:
    • Missing Roslyn-native workspace text search with pattern list input (literal + regex modes), safe escaping, and bounded result envelopes.
    • Missing Roslyn-native "find invocations by symbol/member name across workspace" command for call-path discovery without raw grep.
  • Proposed improvement:
    • Add ctx.search_text with payload { patterns: [...], mode: literal|regex, roots/include_globs, max_results }, returning file/line/preview in Roslyn JSON envelope.
    • Add nav.find_invocations (or nav.find_calls) that accepts symbol id or member signature and returns call sites across projects.
    • Add query.batch to run several search intents in one Roslyn round-trip for investigative tasks.
  • Expected impact:
    • correctness: higher (fewer missed/overmatched hits from ad-hoc regex and shell escaping mistakes).
    • latency: lower (fewer retry loops and less context switching between Roslyn + shell tools).
    • token_count: lower (structured bounded responses instead of repeated wide grep output + manual triage).
  • Follow-up issue/test link:
    • TODO: add command proposals to command-surface backlog and include a benchmark fixture for "cross-project investigative tracing".

• 2026-02-16: Implemented new investigative commands in RoslynSkills via direct source edits (ctx.search_text, nav.find_invocations, query.batch)

  • Task/Context: ship missing command-surface capabilities identified from Codex/Claude fallback churn, including CLI/MCP guidance and coverage tests.
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • RoslynSkills currently lacks a self-hosted maintainer workflow for editing its own command implementations and registry wiring semantically across multiple files.
  • Roslyn command attempted (if any):
    • scripts/roscli.cmd list-commands --compact and post-change list-commands --ids-only validation to verify command registration and envelope shape.
  • Missing command/option hypothesis:
    • Missing repository-maintainer semantic edit workflow for RoslynSkills self-evolution (multi-file symbol-anchored edits + command-surface regeneration).
  • Proposed improvement:
    • Add a maintainer-oriented transaction mode that can update command classes/registry/CLI usage hints atomically and validate schema/help drift in one pass.
  • Expected impact:
    • correctness: higher (less manual drift between command code and guidance surfaces).
    • latency: lower (faster command-surface iteration loops).
    • token_count: lower (fewer manual grep/read/patch cycles when evolving RoslynSkills itself).
  • Follow-up issue/test link:
    • Added regression coverage in tests/RoslynSkills.Core.Tests/BreadthCommandTests.cs and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.

• 2026-02-16: Call-hierarchy naming/discoverability verification used direct .cs read on CLI usage-hint logic

  • Task/Context: confirm nav.call_hierarchy vs nav.call_chain naming behavior and patch describe-command usage examples/optional-property hints for the alias.
  • Fallback action:
    • read
  • Why Roslyn path was not used:
    • Needed a quick inspection of the CLI host formatting logic (GenerateUsageHints) where behavior depends on string templates rather than symbol navigation alone.
  • Roslyn command attempted (if any):
    • scripts/roscli.cmd list-commands --compact
    • scripts/roscli.cmd describe-command nav.call_chain
    • scripts/roscli.cmd nav.call_chain ... smoke run
  • Missing command/option hypothesis:
    • Missing Roslyn-native "show command host member source by symbol id/name" flow optimized for self-hosted CLI UX tuning.
  • Proposed improvement:
    • Add a maintainer helper command that resolves and returns bounded source for command-host methods (for example ctx.command_host_member_source --type CliApplication --member GenerateUsageHints).
  • Expected impact:
    • correctness: higher (less drift between alias behavior and help text).
    • latency: lower (faster diagnosis of command-surface UX regressions).
    • token_count: lower (fewer ad-hoc full-file reads while tuning command guidance).
  • Follow-up issue/test link:
    • Updated usage-hint behavior in src/RoslynSkills.Cli/CliApplication.cs; validation via CLI/core test slices.

• 2026-02-16: Removed nav.call_chain alias to keep canonical Roslyn-aligned naming

  • Task/Context: user requested a single canonical name and no alias; removed nav.call_chain from command surface and docs/tests.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • This change modifies RoslynSkills implementation internals (Core command registry, CLI host, MCP schema hints, tests/docs), which currently requires direct source edits.
  • Roslyn command attempted (if any):
    • scripts/roscli.cmd list-commands --ids-only
    • scripts/roscli.cmd describe-command nav.call_hierarchy
    • scripts/roscli.cmd describe-command nav.call_chain (expected fail/command_not_found)
  • Missing command/option hypothesis:
    • Missing self-hosted maintainer workflow for multi-file command-surface deprecations/removals with descriptor-aware propagation.
  • Proposed improvement:
    • Add maintainer-focused command-surface transaction support to update registry + CLI usage hints + MCP input hints atomically from command descriptor diffs.
  • Expected impact:
    • correctness: higher (prevents stale alias/docs/schema drift).
    • latency: lower (fewer manual multi-file touchpoints during command-surface cleanup).
    • token_count: lower (less repetitive inspection/verification loops for rename/deprecation passes).
  • Follow-up issue/test link:
    • Validation: dotnet build RoslynSkills.slnx; CLI/Core targeted test slices passed.

• 2026-02-16: Added command maturity model (stable|advanced|experimental) and surfaced metadata in CLI/MCP + skills/docs

  • Task/Context: introduce explicit expectations for heuristic/slower commands and establish an extensible pattern for advanced/experimental analysis tools.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • This is RoslynSkills self-evolution across contracts, command descriptors, CLI host, MCP metadata, tests, and docs; no self-hosted semantic maintainer flow exists yet.
  • Roslyn command attempted (if any):
    • Post-change validation with roscli list-commands, roscli describe-command, plus build/test gates.
  • Missing command/option hypothesis:
    • Missing descriptor-driven maintainer transactions that can propagate command metadata changes atomically across CLI/MCP/doc surfaces.
  • Proposed improvement:
    • Add a metadata propagation tool that syncs command descriptors to CLI list/describe output shapes, MCP catalog annotations, and doc stubs.
  • Expected impact:
    • correctness: higher (less drift between metadata contract and tool surfaces).
    • latency: lower (faster rollout of non-stable command caveats).
    • token_count: lower (fewer repeated manual consistency checks).
  • Follow-up issue/test link:
    • Validation: dotnet build RoslynSkills.slnx; targeted core/CLI test slices and roscli command checks.

• 2026-02-16: Added static-analysis command lane (analyze.*) and dual-lane roscli wrappers via direct source reads/edits

  • Task/Context: implement analyze.unused_private_symbols, analyze.dependency_violations, analyze.impact_slice, analyze.override_coverage, and analyze.async_risk_scan; add docs/tests; add pinned stable/dev roscli plumbing.
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • RoslynSkills still lacks a self-hosted maintainer workflow for multi-file command implementation/wiring across Core, CLI, MCP, tests, and docs.
  • Roslyn command attempted (if any):
    • scripts/roscli-stable.cmd list-commands --compact
    • scripts/roscli-dev.cmd list-commands --ids-only
  • Missing command/option hypothesis:
    • Missing maintainer-focused semantic transaction flow that can update command registrations/help hints/tests atomically and validate command-surface drift.
  • Proposed improvement:
    • Extend maintainer mode over edit.transaction with descriptor-aware propagation checks (registry + CLI usage + MCP input hints + docs/test checklist) in one guided operation.
  • Expected impact:
    • correctness: higher (lower risk of command-surface/documentation/test drift during feature additions).
    • latency: lower (fewer manual cross-file patch/validation loops).
    • token_count: lower (less repeated source inspection to keep multiple surfaces in sync).
  • Follow-up issue/test link:
    • Added coverage in tests/RoslynSkills.Core.Tests/BreadthCommandTests.cs and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.

• 2026-02-16: Codex run-fragment retrospective identified two additional pit-of-success gaps now partially addressed

  • Task/Context: review a real Codex investigative sequence over a large C# workspace (symbol/member tracing, call-path discovery, repeated ctx.member_source, and shell regex retries) to answer “could RoslynSkills have been more helpful?”
  • Fallback action:
    • read
  • Why Roslyn path was not used:
    • Cross-file tracing still drifted into raw regex/shell loops when command affordances were not discoverable enough at point-of-use.
    • VB parity holes in high-traffic context commands (ctx.file_outline, ctx.member_source) reduced confidence in mixed-language workflows.
  • Roslyn command attempted (if any):
    • ctx.member_source on multiple members; nav.find_invocations; ctx.search_text; query.batch.
  • Missing command/option hypothesis:
    • MCP tool schemas lacked explicit input hints/examples for ctx.file_outline and ctx.member_source, increasing argument uncertainty.
    • ctx.member_source body extraction semantics in VB need stronger deterministic anchoring tests for declaration-line anchors.
  • Proposed improvement:
    • Add explicit MCP input-schema hints and URI examples for ctx.file_outline/ctx.member_source (implemented in this pass).
    • Treat VB parity on context commands as first-class and keep dedicated VB regression tests for outline/member-source behavior (implemented in this pass).
    • Follow with a targeted benchmark slice measuring reduced shell fallback on cross-project investigative tasks after schema/guidance upgrades.
  • Expected impact:
    • correctness: higher (stronger mixed-language reliability and fewer argument-shape errors).
    • latency: lower (less retry churn from unclear command inputs).
    • token_count: lower (fewer exploratory retries and shell transcript noise).
  • Follow-up issue/test link:
    • Added tests in tests/RoslynSkills.Core.Tests/VbCommandTests.cs for VB ctx.file_outline and ctx.member_source flows.

• 2026-02-17: Wider benchmark sweep uncovered operation-specific guidance mismatch and overly strict constraint shape checks

  • Task/Context: broaden benchmark scope beyond rename tasks (change-signature, replace-member-body, create-file, add-member) while validating Claude skill-guidance and paired harness behavior.
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • Existing paired guidance profiles were rename-centric, causing treatment runs on non-rename tasks to spend calls on nav.find_symbol Process / edit.rename_symbol even when task intent was edit.add_member/edit.change_signature/etc.
    • Constraint checks encoded one syntactic form for add-member-threshold-v1 (block-bodied method), generating false negatives for semantically valid expression-bodied output.
  • Roslyn command attempted (if any):
    • scripts/roscli.cmd list-commands --compact
    • scripts/roscli.cmd edit.add_member ...
    • scripts/roscli.cmd diag.get_file_diagnostics ...
  • Missing command/option hypothesis:
    • Missing operation-neutral guidance profile that steers command choice by task family rather than rename default.
    • Missing “semantic-equivalence tolerant” constraint checks for style variants that preserve behavior.
  • Proposed improvement:
    • Add operation-neutral-v1 guidance profile in paired harness for multi-operation tasks (implemented).
    • Expand task catalog + constraints for non-rename families and accept equivalent member-body styles where appropriate (implemented).
    • Add one-click multi-task paired sweep helper to avoid PowerShell array binding friction and reduce operator error.
  • Expected impact:
    • correctness: higher (fewer false negatives from syntactic-only checks; better task-command alignment).
    • latency: lower (reduced wasted Roslyn calls on irrelevant rename flows).
    • token_count: lower (fewer exploratory retries and less command-contract churn).
  • Follow-up issue/test link:
    • Updated benchmarks/scripts/Run-PairedAgentRuns.ps1 with expanded task IDs + operation-neutral-v1.
    • Added regression coverage in tests/RoslynSkills.Benchmark.Tests/PairedRunHarnessScriptTests.cs.

• 2026-02-17: Renamed CFG command id and extended benchmark preflight to Gemini using direct source edits

  • Task/Context: apply approved command rename (analyze.cfg -> analyze.control_flow_graph, no alias), add Gemini preflight detection/tests, and add transcript-split tooling scripts for overhead analysis.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • RoslynSkills currently has no self-hosted maintainer transaction command that can propagate command-id changes through Core/CLI/MCP/tests/docs and benchmark infrastructure atomically.
  • Roslyn command attempted (if any):
    • scripts/roscli.cmd describe-command analyze.control_flow_graph
    • scripts/roscli.cmd describe-command analyze.cfg (expected command_not_found)
  • Missing command/option hypothesis:
    • Missing maintainer-grade command-surface rename primitive with contract checks (registry routing, direct CLI shorthand, MCP schema hints, query.batch support, docs/examples).
  • Proposed improvement:
    • Add maint.rename_command_id (or equivalent) that computes and validates cross-surface rename impact before apply.
  • Expected impact:
    • correctness: higher (prevents stale ids on one surface).
    • latency: lower (fewer manual search/patch cycles).
    • token_count: lower (less repeated inspection during command-surface refactors).
  • Follow-up issue/test link:
    • Added regression checks in tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs for new id acceptance + old id rejection.
    • Added Gemini probe coverage in tests/RoslynSkills.Benchmark.Tests/AgentEvalPreflightCheckerTests.cs.

• 2026-02-17: External split-lane run on MediatR initially produced zero treatment Roslyn usage due missing launcher discoverability

  • Task/Context: tool-thinking split experiment on external repo (MediatR) where treatment prompt asked for RoslynSkills usage.
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • External repo did not include local scripts/roscli*; treatment guidance lacked an explicit executable path to host RoslynSkills launcher, so agent stayed text-only.
  • Roslyn command attempted (if any):
    • None in first run (treatment.roslyn_command_count=0).
  • Missing command/option hypothesis:
    • Split harness lacked a first-class mechanism to provide executable Roslyn launcher coordinates to treatment lanes on non-RoslynSkills repositories.
  • Proposed improvement:
    • Inject resolved host launcher path into treatment prompt and explicit prohibition into control prompt; stamp launcher path in run summary (implemented in Run-ToolThinkingSplitExperiment.ps1).
  • Expected impact:
    • correctness: higher (valid treatment condition with actual Roslyn usage).
    • latency: lower (fewer failed/irrelevant attempts to discover Roslyn command entrypoints).
    • token_count: lower (reduced exploration churn from missing tool entrypoint).
  • Follow-up issue/test link:
    • Verified by MediatR reruns:
      • pre-injection treatment_roslyn=0: artifacts/tool-thinking-split-runs/20260217-084934-codex-mediatr-invalid-notification-codex-v1/
      • post-injection Codex treatment_roslyn=3: artifacts/tool-thinking-split-runs/20260217-085723-codex-mediatr-invalid-notification-codex-v2/
      • post-injection Claude treatment_roslyn=1: artifacts/tool-thinking-split-runs/20260217-090210-claude-mediatr-invalid-notification-claude-v1/

• 2026-02-17: Added “used well” trajectory metrics via script/test updates using direct source edits

  • Task/Context: user requested validation that reveals whether RoslynSkills is used well, not just used.
  • Fallback action:
    • edit
  • Why Roslyn path was not used:
    • This work modifies RoslynSkills analyzer/test internals (PowerShell + C# test files) and currently lacks a self-hosted maintainer command flow for cross-file metric-contract changes.
  • Roslyn command attempted (if any):
    • Not applicable for implementation edits; validation performed via benchmark script runs and dotnet test suite.
  • Missing command/option hypothesis:
    • Missing maintainer-grade command to evolve benchmark metric schemas and propagate contract updates across scripts/tests/docs atomically.
  • Proposed improvement:
    • Add maintainer benchmark-contract tooling (for example maint.update_benchmark_metric_contract) with impact checks across script output fields and tests.
  • Expected impact:
    • correctness: higher (lower risk of metric drift between script and test expectations).
    • latency: lower (faster metric evolution cycles).
    • token_count: lower (fewer manual reconcile loops across scripts/tests/docs).
  • Follow-up issue/test link:
    • tests/RoslynSkills.Benchmark.Tests/ToolThinkingSplitScriptTests.cs
    • benchmarks/scripts/Analyze-ToolThinkingSplit.ps1

• 2026-05-14: Hardened solution-first workspace binding and activation guidance using direct source edits

  • Task/Context: ensure future hot workspace hosts load full .sln/.slnx workspaces by default where available, expose solution-vs-project binding telemetry, and sweep CLI/MCP/skill/docs guidance.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+dbaf95b49117d820b1c2125bc6c5c589e4fa40ab)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changed RoslynSkills' own workspace loader, CLI activation text, MCP schema descriptions, tests, and docs. Current RoslynSkills commands can navigate/edit target C# members, but there is no self-hosted maintainer transaction that can safely coordinate a cross-surface behavior + documentation update.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer-grade multi-file command for command-surface/help/schema/doc sweeps, with assertions over generated help text and workspace payload shape.
    • Missing workspace.preload/hot-host command surface that can directly validate solution binding as a first-class workflow.
  • Proposed improvement:
    • Add maintainer workflow tooling for cross-interface command contract changes.
    • Implement the planned hot workspace lifecycle commands with explicit .sln/.slnx preference and project-scoped telemetry.
  • Expected impact:
    • correctness: higher (agents can verify full solution binding via workspace_kind, project_count, and document_count).
    • latency: lower in future hot-host flows (solution bind paid once, warm commands reuse the same workspace).
    • token_count: lower (clearer activation guidance reduces workspace-path retry churn).
  • Follow-up issue/test link:
    • tests/RoslynSkills.Core.Tests/WorkspaceSemanticLoaderTests.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs

• 2026-05-15: Added solution-scope telemetry to remaining scan/ad-hoc diagnostics commands using direct source edits

  • Task/Context: complete the solution workspace activation sweep follow-up by making ctx.search_text and diag.get_solution_snapshot explicitly report scan/ad-hoc analysis mode, while preserving MSBuild solution telemetry on analyzer commands.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+41f7289d7e5868221e6355f88a9d35b0c20569cc)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changed RoslynSkills' own command response contracts, tests, and planning documentation. Current commands do not provide a maintainer workflow for coordinated response-shape edits across command implementations, test assertions, and sweep docs.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer-grade command for schema/telemetry contract evolution that can update command payloads and assert downstream CLI/test/doc expectations together.
  • Proposed improvement:
    • Add a self-hosted contract evolution workflow, for example maint.update_command_output_contract, with semantic anchors for command payload construction and generated test/doc impact hints.
  • Expected impact:
    • correctness: higher (command-scope claims stay explicit and test-backed).
    • latency: lower (less manual sweep work when evolving response contracts).
    • token_count: lower (fewer source reads needed to reconcile command output, CLI pretty output, and docs).
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/SearchTextCommand.cs
    • src/RoslynSkills.Core/Commands/GetSolutionSnapshotCommand.cs
    • tests/RoslynSkills.Core.Tests/BreadthCommandTests.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs

• 2026-05-15: Added first hot-workspace lifecycle commands using direct source edits

  • Task/Context: implement workspace.preload, workspace.status, and workspace.close so persistent hosts can bind full .sln/.slnx workspaces and reject loose-project scope when require_solution is requested.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+41f7289d7e5868221e6355f88a9d35b0c20569cc)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work introduced new command classes, registry wiring, CLI shorthand, tests, and documentation. Existing RoslynSkills edit commands do not yet support self-hosted multi-file feature creation with command registry and CLI argument-surface coordination.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing self-hosted maintainer workflow for adding command families with registry, direct-CLI shorthand, and lifecycle tests in one verified transaction.
  • Proposed improvement:
    • Add a maint.add_command_family workflow that creates command skeletons, registry entries, CLI shorthand mappings, and test stubs from a declared command contract.
  • Expected impact:
    • correctness: higher (new command surfaces consistently wired through registry/CLI/tests).
    • latency: lower (less manual cross-file wiring).
    • token_count: lower (fewer source sweeps for boilerplate command integration).
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/WorkspacePreloadCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceStatusCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceCloseCommand.cs
    • tests/RoslynSkills.Core.Tests/VbCommandTests.cs

• 2026-05-15: Completed hot-workspace handle reuse, benchmark gate wiring, and ad-hoc snapshot disclosure using direct edits

  • Task/Context: finish the remaining Solution Workspace sweep backlog by wiring workspace_handle into high-traffic semantic commands, surfacing handle support in CLI/MCP guidance, adding benchmark validation for solution-scoped hot workspace runs, and making diag.get_solution_snapshot visibly ad-hoc.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+009fbf7477850046b60fd3c364002ae3ef28b30f)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work crossed command loader internals, multiple command contracts, CLI/MCP discovery surfaces, PowerShell benchmark harness metadata extraction, validator models, tests, and planning docs. Current RoslynSkills commands do not provide a self-hosted transaction for coordinated cross-language feature completion.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer-grade workflow for adding and auditing command contract fields across C# command implementations, CLI/MCP schemas, benchmark harness scripts, and docs.
  • Proposed improvement:
    • Add maint.propagate_command_option or equivalent to introduce a new command option and verify registry, CLI help, MCP schema, tests, and benchmark telemetry coverage.
  • Expected impact:
    • correctness: higher (hot workspace handles are now reusable and benchmark-gated for solution scope).
    • latency: lower (repeated semantic calls can reuse process-hot workspace state).
    • token_count: lower (agents can pass handles instead of re-specifying and reloading solution paths).
  • Follow-up issue/test link:
    • tests/RoslynSkills.Core.Tests/VbCommandTests.cs
    • tests/RoslynSkills.Benchmark.Tests/AgentEvalRunValidatorTests.cs
    • tests/RoslynSkills.Benchmark.Tests/PairedRunHarnessScriptTests.cs

• 2026-05-15: Formalized hot workspace host protocol using direct source/docs edits

  • Task/Context: start the comprehensive hot workspace implementation sequence by creating a versioned request/response/freshness protocol contract and a protocol spec document.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+47546a5b193f1c98002161054fb0985ff9e50fdc)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change adds new shared protocol record types, contract tests, and docs. Current RoslynSkills commands do not provide a self-hosted workflow for creating cross-project protocol contracts and matching tests.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for creating a protocol contract from a design document and generating JSON shape tests.
  • Proposed improvement:
    • Add a maintainer command that scaffolds versioned contract records, protocol docs, and serialization tests from a schema description.
  • Expected impact:
    • correctness: higher (future daemon/client implementation has a tested contract).
    • latency: neutral now, lower later once client/host can share stable metadata.
    • token_count: lower in later implementation steps because protocol field names and failure modes are pinned.
  • Follow-up issue/test link:
    • src/RoslynSkills.Contracts/WorkspaceHostProtocolContracts.cs
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProtocolContractTests.cs
    • docs/ROSCLI_WORKSPACE_HOST_PROTOCOL_2026-05-15.md

• 2026-05-15: Created initial hot workspace host executable using direct source edits

  • Task/Context: implement sequence item 2 by adding RoslynSkills.WorkspaceHost, wiring it into the solution, exposing JSON-lines stdio handshake/status/tool-call/workspace lifecycle routing, and adding a process smoke test.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+984aa7e30f176655314fb7b513f9e953def9a14a)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change creates a new executable project, solution entry, process-level test, and protocol adapter around existing command registry behavior. Current RoslynSkills commands do not provide a self-hosted workflow for adding a new project plus executable entry point and cross-project test reference.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for scaffolding a new RoslynSkills process host from an existing protocol contract, including solution registration, stdio harness, and smoke test.
  • Proposed improvement:
    • Add maint.add_host_project to create host projects from protocol contracts, wire solution/test references, and generate JSON-lines process tests.
  • Expected impact:
    • correctness: higher (new host surfaces can be scaffolded with protocol-conformant responses and process coverage).
    • latency: lower (agents can create host-process slices without manual solution/test wiring).
    • token_count: lower (fewer source sweeps for project scaffolding and protocol boilerplate).
  • Follow-up issue/test link:
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • src/RoslynSkills.WorkspaceHost/RoslynSkills.WorkspaceHost.csproj
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProcessTests.cs

• 2026-05-15: Moved hot workspace handle storage behind a service abstraction using direct source edits

  • Task/Context: implement sequence item 3 by replacing direct static handle-store access with an IWorkspaceHostStore abstraction, a default provider, and an in-memory implementation used by preload/status/close and semantic handle resolution.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+c38e7caabb86432f0be8995364da08589b496212)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change is a self-hosted architectural refactor across internal store types, command implementations, and semantic loader plumbing. Current RoslynSkills commands do not yet provide a safe symbol-aware extract-interface/move-implementation workflow for its own command internals.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for extracting an internal service abstraction from an existing static helper and updating all same-symbol call sites with compile/test verification.
  • Proposed improvement:
    • Add maint.extract_internal_service with symbol-backed target selection, constructor/provider strategy options, and automatic same-solution usage validation.
  • Expected impact:
    • correctness: higher (future daemon, transport, and command layers can share the same workspace-store contract).
    • latency: neutral now, lower later when long-running hosts can reuse a hot store cleanly.
    • token_count: lower (future store changes can target an interface boundary instead of rediscovering static call sites).
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/WorkspaceHostStore.cs
    • src/RoslynSkills.Core/Commands/WorkspacePreloadCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceStatusCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceCloseCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceSemanticLoader.cs

• 2026-05-15: Added workspace host pipe/socket transports using direct source edits

  • Task/Context: implement sequence item 4 by extending RoslynSkills.WorkspaceHost beyond stdio to support named-pipe and Unix-domain-socket JSON-lines transports, with transport option validation and process tests.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+ba437eef40d4b5f84ff4db1d505fb00770844817)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change refactors process I/O plumbing, command-line option parsing, stream ownership, cross-platform socket setup, and process tests. Current RoslynSkills commands do not provide self-hosted transport-layer refactoring or executable-process harness generation.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for introducing a new process transport with generated smoke tests and manual validation commands.
  • Proposed improvement:
    • Add maint.add_host_transport to scaffold transport options, server stream loops, process tests, and platform-specific validation notes from a host protocol declaration.
  • Expected impact:
    • correctness: higher (daemon communication can move off stdio without changing the protocol payload).
    • latency: lower once the CLI client can reuse a pipe/socket-backed host.
    • token_count: neutral now, lower later when agents can keep solution state hot across calls.
  • Follow-up issue/test link:
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProcessTests.cs

• 2026-05-15: Added CLI-side workspace host client connection layer using direct source edits

  • Task/Context: implement sequence item 5 by adding a roscli assembly client component that connects to named-pipe or Unix-socket workspace hosts and exchanges JSON-lines WorkspaceHostRequest/WorkspaceHostResponse protocol messages.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+4eb285af22099ca8a81c1c78a8fddcc1a1e42a17)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The change adds new CLI transport/client code plus tests. Current RoslynSkills commands do not provide a self-hosted workflow for adding a cross-process client abstraction and generated protocol round-trip tests.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding a protocol client layer from shared contracts, including named-pipe/socket connection factories and request/response tests.
  • Proposed improvement:
    • Add maint.add_protocol_client to scaffold transport client classes from existing protocol records and generate text-stream plus process-backed smoke tests.
  • Expected impact:
    • correctness: higher (CLI lifecycle commands can call a tested client layer instead of duplicating transport code).
    • latency: neutral now, lower once roscli routes calls through the hot host.
    • token_count: lower later because agents can use daemon-backed commands without repeating workspace-load arguments.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/WorkspaceHostClient.cs
    • tests/RoslynSkills.Cli.Tests/WorkspaceHostClientTests.cs

• 2026-05-15: Added daemon lifecycle commands using direct source edits

  • Task/Context: implement sequence item 6 by adding roscli daemon.start, daemon.status, daemon.stop, and daemon.restart, plus a per-repo endpoint manifest and multi-client host loop so a daemon survives status probes until explicit shutdown.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+490641040d37ab4de12f7709f8495549743afd0c)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work spans CLI argument routing, daemon process management, cross-platform endpoint selection, host transport lifetime behavior, tests, and manual process validation. Current RoslynSkills commands do not provide a self-hosted workflow for lifecycle command addition plus host-loop refactoring.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding daemon lifecycle verbs from a host protocol, including endpoint manifest shape, process start/stop validation, and stale-daemon handling tests.
  • Proposed improvement:
    • Add maint.add_daemon_lifecycle to generate lifecycle command handlers, endpoint identity helpers, process manifests, and start/status/stop smoke tests.
  • Expected impact:
    • correctness: higher (daemon process state is now explicit and status/stop are protocol-backed).
    • latency: lower once workspace commands and read-only commands route through the daemon.
    • token_count: lower later because agents can start a hot host once and reuse it through stable lifecycle commands.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/CliApplication.cs
    • src/RoslynSkills.Cli/WorkspaceHostDaemonManager.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs

• 2026-05-15: Added daemon-backed workspace lifecycle commands using direct source edits

  • Task/Context: implement sequence item 7 by adding top-level workspace.use, workspace.preload, workspace.status, workspace.refresh, workspace.close, and workspace.list, with daemon alias binding, solution-first preload behavior, and full manual lifecycle validation.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+df4fe5dab69174e20dfdbd802bd047549d5ac42a)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work spans CLI verb routing, daemon request construction, host alias resolution, process transport lifetime fixes, workspace-store listing, command registration, and tests. Current RoslynSkills commands do not provide a self-hosted workflow for adding daemon-backed command families with protocol/CLI/host/test changes in one transaction.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding a daemon-backed workspace command family from protocol methods, including alias semantics, timeout policy, command help, and lifecycle smoke validation.
  • Proposed improvement:
    • Add maint.add_daemon_workspace_commands to generate CLI routing, host method mapping, alias handling, request timeout policy, command registration, and focused tests from protocol declarations.
  • Expected impact:
    • correctness: higher (agents can explicitly load and inspect a full solution-scoped hot workspace instead of relying on ambiguous process-local handles).
    • latency: lower after first load because aliases and handles keep solution state hot in the daemon.
    • token_count: lower because repeated workspace calls can use a short alias instead of resending full workspace paths and preload options.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/CliApplication.cs
    • src/RoslynSkills.Cli/WorkspaceHostDaemonManager.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • src/RoslynSkills.Core/Commands/WorkspaceListCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceRefreshCommand.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs

• 2026-05-15: Added client-side workspace alias persistence using direct source edits

  • Task/Context: implement sequence item 8 by persisting hot-workspace routing metadata in .roslynskills/workspaces.json, resolving aliases before daemon status/refresh/close, updating aliases after successful workspace calls, removing aliases on close, and ignoring local client state in git.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+4182677fbdea5ea56a734fe6cd7ea861653b3191)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work spans CLI routing behavior, local JSON persistence, daemon endpoint metadata, tests, and .gitignore. Current RoslynSkills commands do not provide a self-hosted workflow for adding local CLI state stores with request rewriting and lifecycle validation.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding a local client-state store tied to command responses, including schema records, persistence tests, and cleanup/ignore rules.
  • Proposed improvement:
    • Add maint.add_cli_state_store to scaffold JSON state records, load/save helpers, command response extractors, and tests from a declared state schema.
  • Expected impact:
    • correctness: higher (aliases now survive separate roscli invocations as explicit routing metadata).
    • latency: neutral now, lower later when read-only hot-path commands can resolve workspace handles from aliases without repeated preload/status discovery.
    • token_count: lower because agents can keep using default instead of copying full handles or paths across calls.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/WorkspaceAliasStore.cs
    • src/RoslynSkills.Cli/CliApplication.cs
    • src/RoslynSkills.Cli/WorkspaceHostDaemonManager.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs
    • .gitignore

• 2026-05-16: Routed read-only hot-path commands through the daemon using direct source edits

  • Task/Context: implement sequence item 9 by routing daemon-capable read-only commands through the hot workspace host, adding ROSCLI_DAEMON mode handling, --no-daemon, alias-to-handle injection, required-mode fail-closed behavior, and manual verification against the loaded RoslynSkills.slnx workspace.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+5ba4408dfa75e91cd1dba2644aad27e163343fe6)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes the CLI's own top-level invocation pipeline, global option handling, daemon routing policy, environment-variable behavior, and tests. Current RoslynSkills commands do not provide a self-hosted workflow for safely modifying command dispatch and cross-process routing behavior as a single semantic transaction.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding daemon-routing policy to existing command families, including global flag parsing, alias-state injection, fail-closed tests, and live daemon smoke validation.
  • Proposed improvement:
    • Add maint.route_commands_via_daemon to declare daemon-capable command ids, generate routing gates, wire alias resolution, add required/off/auto tests, and emit a manual smoke checklist.
  • Expected impact:
    • correctness: higher (agents can require hot-workspace routing and fail closed instead of silently falling back when semantic state is expected).
    • latency: lower for repeated read-only semantic calls because loaded solution state is reused by the daemon.
    • token_count: lower because agents can use a persisted alias and short command forms rather than resending workspace paths or handles on every call.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/CliApplication.cs
    • tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs

• 2026-05-16: Added hot-workspace file watching and change classification using direct source edits

  • Task/Context: implement sequence item 10 by adding per-workspace filesystem watchers, classifying dirty paths as source, project-structure, analyzer/config, ignored, or membership/unknown changes, surfacing dirty_kinds, dirty_entries, can_incrementally_update, and requires_reload, and validating that .roslynskills client state does not dirty the workspace.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+707c600d211d55bd99c93033cdbfae053342e2af)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes the hot workspace store, process lifetime cleanup, file watcher callbacks, dirty-state response contracts, workspace host metadata projection, and tests. Current RoslynSkills commands do not provide a self-hosted workflow for adding persistent watcher state and cross-command dirty classification safely.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding hot-workspace state services that combine watcher events, timestamp snapshots, response schema updates, and daemon smoke validation.
  • Proposed improvement:
    • Add maint.add_workspace_state_service to scaffold process-scoped services, watcher lifecycle disposal, status/refresh response fields, and watcher-specific regression tests.
  • Expected impact:
    • correctness: higher (agents can distinguish incremental-safe source edits from reload-required project or membership changes).
    • latency: lower later because item 11 can apply source text updates only when classification proves reload is unnecessary.
    • token_count: lower because refresh/status responses explain freshness with compact structured dirty entries instead of requiring manual file inspection.
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/WorkspaceHostStore.cs
    • src/RoslynSkills.Core/Commands/WorkspaceRefreshCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceStatusCommand.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • tests/RoslynSkills.Core.Tests/VbCommandTests.cs

• 2026-05-16: Added incremental source refresh using Roslyn solution document text updates

  • Task/Context: implement sequence item 11 by retaining a Roslyn Solution in hot workspace state, applying known source changes with Solution.WithDocumentText, rebuilding semantic indexes from the updated solution, clearing refreshed dirty paths, and validating daemon-routed semantic lookup after refresh.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+7a3af1eda8b1b09810fe4408f24eb4f8500ca4fb)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes the workspace loader's retained semantic state, hot store mutation contract, refresh command behavior, daemon metadata projection, and tests. Current RoslynSkills commands do not provide a self-hosted workflow for evolving the hot workspace state model while simultaneously validating cross-process daemon behavior.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding Roslyn-backed incremental workspace mutations, including solution-state retention, document-id update wiring, dirty-entry cleanup, and post-refresh semantic lookup smoke tests.
  • Proposed improvement:
    • Add maint.add_incremental_workspace_refresh to generate solution-retention fields, refresh-state transitions, dirty path clearing, and hot semantic lookup validation for source-only changes.
  • Expected impact:
    • correctness: higher (known source edits now update the hot Roslyn solution instead of leaving stale semantic state).
    • latency: lower because source-only edits avoid full solution reloads.
    • token_count: lower because agents can use workspace.refresh as a compact semantic validation step after file edits.
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/StaticAnalysisWorkspace.cs
    • src/RoslynSkills.Core/Commands/WorkspaceHostStore.cs
    • src/RoslynSkills.Core/Commands/WorkspaceRefreshCommand.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • tests/RoslynSkills.Core.Tests/VbCommandTests.cs

• 2026-05-16: Added strict hot-workspace reload mode using direct source edits

  • Task/Context: implement sequence item 12 by adding workspace.refresh --mode strict|reload|balanced|none, preserving workspace load parameters for reload, reloading structural or membership changes in strict mode, and validating symbol visibility after reload.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+fb2c72acf85bdf1ce3d35655fac39cf2f78bc31f)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes the hot workspace store mutation contract, reload lifecycle, CLI daemon request shaping, help text, and tests. Current RoslynSkills commands do not provide a self-hosted workflow for safely changing persistent workspace lifecycle behavior and validating it through live daemon smoke tests.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding workspace refresh modes that updates command validation, CLI shorthand, host lifecycle state, status metadata, and membership-change regression tests together.
  • Proposed improvement:
    • Add maint.add_workspace_refresh_mode to declare a refresh mode, generate validation/help updates, preserve reload parameters, add dirty-state tests, and emit a daemon smoke script for the new mode.
  • Expected impact:
    • correctness: higher because structural and membership changes can be reconciled by a full solution reload before final verification.
    • latency: balanced because source-only changes still use incremental refresh while strict mode pays reload cost only when needed.
    • token_count: lower because agents can ask for a compact strict freshness operation instead of manually inspecting project membership and reloading state.
  • Follow-up issue/test link:
    • src/RoslynSkills.Core/Commands/WorkspaceHostStore.cs
    • src/RoslynSkills.Core/Commands/WorkspaceRefreshCommand.cs
    • src/RoslynSkills.Cli/CliApplication.cs
    • tests/RoslynSkills.Core.Tests/VbCommandTests.cs

• 2026-05-16: Added hot-workspace structured edit support using direct source edits

  • Task/Context: implement sequence item 13 by routing edit.rename_symbol and edit.change_signature through the daemon, allowing those commands to consume workspace_handle, and refreshing the process-hot workspace after an applied structured edit.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+330db906f88834bb14ea503908a96e8468c4ce99)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes daemon routing, command input contracts, internal hot-workspace store APIs, host post-command lifecycle behavior, and host-process tests. Current RoslynSkills commands do not provide a self-hosted workflow for changing the tool's own cross-process edit lifecycle and validating that hot semantic state is refreshed after disk writes.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for promoting a structured edit command to hot-workspace support, including CLI routing, workspace_handle contract updates, post-edit state refresh, and stale-state regression tests.
  • Proposed improvement:
    • Add maint.promote_structured_edit_to_hot_workspace to declare edit commands as daemon-capable, update command schemas/help, wire post-edit refresh from written file paths, and generate host-process stale-state tests.
  • Expected impact:
    • correctness: higher because applied structured edits no longer leave the daemon's semantic workspace stale for the next symbol query.
    • latency: lower because edit/read/edit loops can stay on the process-hot solution instead of reloading after each edit.
    • token_count: lower because agents can keep using ROSCLI_WORKSPACE_ALIAS=default and short edit/read commands without carrying workspace paths or handles repeatedly.
  • Follow-up issue/test link:
    • src/RoslynSkills.Cli/CliApplication.cs
    • src/RoslynSkills.Core/Commands/RenameSymbolCommand.cs
    • src/RoslynSkills.Core/Commands/ChangeSignatureCommand.cs
    • src/RoslynSkills.Core/Commands/WorkspaceHostStore.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProcessTests.cs

• 2026-05-16: Added hot-workspace benchmark gate and reports using direct source edits

  • Task/Context: implement sequence item 14 by adding a benchmark script that compares direct workspace calls against daemon hot-workspace calls, emits JSON/Markdown reports, and gates the hot path on workspace_handle, process_hot, no ad-hoc fallback, direct success, and strict refresh success.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+84d997eca6cb5f55903111617e6c0f66ac199953)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work creates a PowerShell benchmark harness and updates benchmark script tests. Current RoslynSkills commands do not provide a self-hosted workflow for creating benchmark/report scripts and validating PowerShell parser/runtime behavior.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for adding benchmark gates that ties a plan's correctness claims to script output, parser tests, runtime smoke checks, and report fields.
  • Proposed improvement:
    • Add maint.add_benchmark_gate to scaffold benchmark scripts with JSON/Markdown outputs, correctness gate declarations, parser tests, and one-iteration smoke validation.
  • Expected impact:
    • correctness: higher because hot-workspace claims now have explicit pass/fail gate fields rather than informal smoke notes.
    • latency: measurable because the report records direct and daemon hot elapsed samples side by side.
    • token_count: neutral directly, lower indirectly by making benchmark evidence easier to consume from compact JSON/Markdown summaries.
  • Follow-up issue/test link:
    • benchmarks/scripts/Benchmark-HotWorkspaceHost.ps1
    • tests/RoslynSkills.Benchmark.Tests/RoscliVsRgScriptTests.cs

• 2026-05-16: Hardened hot-workspace daemon auth and protocol compatibility using direct source edits

  • Task/Context: implement sequence item 15 by adding daemon request auth tokens, protocol-major compatibility checks, documented auth failure semantics, and host-process auth tests.
  • RoslynSkills version:
    • roscli 1.0.0 (1.0.0+c6abbb0ca4d808ed86898cad955eabecd1d1944b)
  • Fallback action:
    • both
  • Why Roslyn path was not used:
    • The work changes cross-process startup, local daemon manifests, protocol contracts, host request authorization, docs, and process-level tests. Current RoslynSkills commands do not provide a self-hosted workflow for secure daemon lifecycle changes or protocol compatibility hardening.
  • Roslyn command attempted (if any):
    • scripts\roscli.cmd --version
  • Missing command/option hypothesis:
    • Missing maintainer workflow for evolving host protocol fields and security checks across contracts, client launch, host parsing, docs, and process tests in one guarded operation.
  • Proposed improvement:
    • Add maint.evolve_workspace_host_protocol to declare protocol fields/error codes, update JSON contract tests/docs, apply client/host lifecycle wiring, and run daemon auth/lifecycle smoke checks.
  • Expected impact:
    • correctness: higher because stale or incompatible daemon protocol responses fail explicitly instead of being treated as valid hot-workspace answers.
    • latency: neutral for successful hot calls; one manifest read is added to attach the local capability token.
    • token_count: lower when failures occur because clients receive explicit daemon_auth_failed or daemon_protocol_mismatch codes with clear recovery paths.
  • Follow-up issue/test link:
    • src/RoslynSkills.Contracts/WorkspaceHostProtocolContracts.cs
    • src/RoslynSkills.Cli/WorkspaceHostDaemonManager.cs
    • src/RoslynSkills.WorkspaceHost/Program.cs
    • docs/ROSCLI_WORKSPACE_HOST_PROTOCOL_2026-05-15.md
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProcessTests.cs
    • tests/RoslynSkills.Core.Tests/WorkspaceHostProtocolContractTests.cs

2026-05-17 - Tiny helper-spacing cleanup after failed Roslyn exact replacement

• RoslynSkills version:
  • roscli 0.1.6-preview.66
• Exact reason fallback was required/preferred:
  • edit.replace_text failed to match a whitespace-only span between methods because the hand-authored old_text line-ending/blank-line shape did not match the file. The remaining change was a one-line formatting cleanup after the functional Roslyn edit and tests already succeeded.
• Roslyn command attempted:
  • roscli edit.replace_text --input @<temp-json>
• Proposed Roslyn command/option improvement:
  • Add a whitespace-normalized or blank-line-focused formatting cleanup command, or expose a small edit.normalize_blank_lines operation scoped between adjacent members.
  • Expected impact:
    • correctness: low to medium; reduces manual cleanup after structured edits without broad formatter churn.
    • latency: lower for small formatting repair loops.
    • token_count: lower because agents would not need exact invisible whitespace reconstruction.

2026-05-17 - Test formatting cleanup after Roslyn insertion

• RoslynSkills version:
  • roscli 0.1.6-preview.67
• Exact reason fallback was required/preferred:
  • After using edit.replace_text to insert a new member-source regression test, the inserted block needed one blank line before the following [Fact]. This was a whitespace-only cleanup around a generated test insertion.
• Roslyn command attempted:
  • roscli --no-daemon edit.replace_text --input @<temp-json>
• Proposed Roslyn command/option improvement:
  • Add a member/test insertion command that preserves local blank-line conventions around adjacent attributes.
• Expected impact:
  • correctness: low; mostly formatting and readability.
  • latency: lower for test scaffolding edits.
  • token_count: lower because agents would not need a second exact whitespace repair.

2026-05-17 - Member-source startup friction while improving supervised bootstrap

• RoslynSkills version:
  • roscli 0.1.6-preview.73+3cf904bda17f6e7101ec3a2277569f937a435a0e
• Exact reason fallback was required/preferred:
  • Repeated ctx.member_source calls on CliApplication.cs hung in the host after an earlier parallel source-backed invocation, and initial attempts using only type/member names failed because ctx.member_source requires a file path first.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --brief true --include-edit-target-text true
  • roscli ctx.member_source tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs --member-name AgentStart_ReturnsSupervisedFirstCommandProtocol --brief true --include-edit-target-text true
• Proposed Roslyn command/option improvement:
  • Make ctx.member_source usage errors show the --member-name file-path form.
  • Document the type/member-name-to-file path: ctx.search_text -> ctx.file_outline -> ctx.member_source.
  • Investigate bounded timeout/cancellation behavior for member-source calls that hang after source-backed parallel launches.
• Expected impact:
  • correctness: medium; agents are less likely to fall back to raw source reads when they know a symbol name but not the file.
  • latency: lower; fewer invalid command retries and fewer supervision cycles consumed by hung reads.
  • token_count: lower because startup guidance points to capped search and focused member windows.

2026-05-17 - Self-hosted member-source command edit after roscli hang

• RoslynSkills version:
  • roscli 0.1.6-preview.76+6462de2bbdcfd0c90d4e7e75ac4f1b9d3ab0d0d5
• Exact reason fallback was required/preferred:
  • ctx.member_source on src/RoslynSkills.Core/Commands/MemberSourceCommand.cs and then edit.replace_text against the same file hung in the host. The change was a small self-hosted command-surface improvement required before the next release.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/MemberSourceCommand.cs --member-name ExecuteAsync --focus-text "member_not_found" --context-lines-before 12 --context-lines-after 16 --brief true --max-chars 12000
  • roscli edit.replace_text --input @<temp-json>
• Proposed Roslyn command/option improvement:
  • Add explicit timeout/cancellation handling and clearer failure telemetry for long-running daemon-backed ctx.member_source/edit calls.
  • Add a safer multiline edit payload path that reduces PowerShell quoting failures and stale tool-process locks.
• Expected impact:
  • correctness: medium; agents avoid silent hangs and recover with command-specific next steps.
  • latency: lower because failed semantic reads return bounded guidance instead of consuming minutes.
  • token_count: lower because recovery happens from structured error messages instead of external inspection.

2026-05-17 - Replace-in-member guidance edit after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.77+35cd272994a76574a3b0df6e96624719cc09ff7a
• Exact reason fallback was required/preferred:
  • While improving describe-command edit.replace_in_member, ctx.member_source on src/RoslynSkills.Cli/CliApplication.cs hung again. Bounded Get-Content was used to inspect the usage-hint and test locations.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name GenerateUsageHints --focus-text "Successful responses include matches" --context-lines-before 10 --context-lines-after 12 --brief true --max-chars 12000
• Proposed Roslyn command/option improvement:
  • Prioritize timeout/cancellation reporting for ctx.member_source.
  • Add safer multiline payload examples for edit commands so agents choose --input @payload.json or --input-stdin instead of direct here-string shorthand.
• Expected impact:
  • correctness: medium; fewer shell-quoting failures in multi-line C# edits.
  • latency: lower; fewer invalid direct edit retries.
  • token_count: lower by replacing failed here-string trajectories with one structured payload.

2026-05-17 - Direct shorthand comma parser fix after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.78+22c3418e717eac9022d281ba325133e004641872
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET run showed direct edit.replace_in_member treating one-line C# snippets containing comma-separated method arguments as invalid input. ctx.member_source on src/RoslynSkills.Cli/CliApplication.cs hung while inspecting the CLI shorthand parser, so bounded source reads were used for the self-hosted fix.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs 2234 18 member --context-lines-before 10 --context-lines-after 80 --include-edit-target-text true
• Proposed Roslyn command/option improvement:
  • Fix the ctx.member_source hang on large CLI source files and add timeout/partial-result telemetry.
  • Keep direct shorthand comma splitting conservative so source snippets remain strings unless the value is clearly a compact list.
• Expected impact:
  • correctness: high for direct edit commands using C# invocations or constructor calls.
  • latency: lower because agents can use one direct edit command instead of retrying with JSON after invalid input.
  • token_count: lower by avoiding failed direct-edit trajectories.

2026-05-17 - Search-text file-glob alias fix after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.83+2752003cb3cb64ae5600d76c47b172e937b53ba1
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET run showed ctx.search_text --file-glob ShowcaseInteractiveProgram.cs silently searched default C# globs. While fixing the direct shorthand alias, ctx.member_source on src/RoslynSkills.Cli/CliApplication.cs hung again, so bounded source reads were used for the self-hosted CLI parser/help/test edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildDirectCommandInput --focus-text "ctx.search_text" --context-lines-before 20 --context-lines-after 60
• Proposed Roslyn command/option improvement:
  • Add timeout/partial-result telemetry for ctx.member_source on large tool-source files.
  • Add command-surface self-checks that verify every option printed by agent-start and describe-command maps to the actual direct shorthand input schema.
• Expected impact:
  • correctness: high; advertised narrowing options should not silently broaden searches.
  • latency: lower because agents avoid broad search retries and do not wait indefinitely on self-hosted source reads.
  • token_count: lower because file-glob narrowing works on the first try.

2026-05-17 - Broad search payload cap edit after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.85+29d7ea5eb93b705e3fba15b0cf0a931a0932deaf
• Exact reason fallback was required/preferred:
  • A fresh FrankenTui.NET round used roscli successfully but spent large transcripts on repeated broad ctx.search_text/ctx.file_outline calls. While adding broad-search payload caps, ctx.member_source on src/RoslynSkills.Core/Commands/SearchTextCommand.cs hung, so bounded source reads were used for the self-hosted command edit and tests.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/SearchTextCommand.cs --member-name ExecuteAsync --focus-text "result_guidance" --context-lines-before 12 --context-lines-after 40 --max-chars 12000
• Proposed Roslyn command/option improvement:
  • Add timeout/partial-result telemetry for ctx.member_source on command implementation files.
  • Add a maintainer-oriented self-hosted edit path for command payload-policy updates, including tests and CLI guidance surfaces.
• Expected impact:
  • correctness: medium; broad-result truth is preserved through total/omitted counts while reducing preview overload.
  • latency: lower because agents spend fewer cycles scrolling large JSON envelopes.
  • token_count: lower because broad-search results return a capped match payload by default.

2026-05-17 - Compact closeout guidance after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.86+b424d6efecda67474a9a595c3dd052f9258aef29
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round showed agents using ctx.member_source successfully for closeout anchors, but with verbose source payloads. ctx.member_source on src/RoslynSkills.Cli/CliApplication.cs hung while inspecting the guidance method, so bounded rg/Get-Content reads were used for this self-hosted guidance/test edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --focus-text "closeout" --context-lines-before 4 --context-lines-after 8 --include-source-text true
• Proposed Roslyn command/option improvement:
  • Add timeout/partial-result telemetry for ctx.member_source on large tool-source files.
  • Promote compact closeout-anchor examples using --include-source-text false so agents capture line/focus metadata without replaying source code.
• Expected impact:
  • correctness: neutral-to-positive; closeout line evidence remains Roslyn-derived.
  • latency: lower because closeout does not require repeated verbose member snippets.
  • token_count: lower by replacing full source windows with focus/line metadata for post-test evidence.

2026-05-17 - Insert-text recovery hint edit after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.87+ce3a595ec9b8b97510fb85c81eab16a7c457fbf3
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round used roscli correctly but failed an edit.insert_text attempt because the agent supplied a fragile copied multiline anchor_text. While improving direct insert recovery hints, ctx.member_source on src/RoslynSkills.Core/Commands/InsertTextCommand.cs hung, so bounded source reads were used for the self-hosted command and test edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/InsertTextCommand.cs --member-name ExecuteAsync --focus-text "anchor_text" --context-lines-before 10 --context-lines-after 40 --max-chars 12000
• Proposed Roslyn command/option improvement:
  • Add timeout/partial-result telemetry for ctx.member_source on command implementation files.
  • Consider a semantic sibling-member/test insertion command so agents can insert after a member anchor without exact multiline text matching.
• Expected impact:
  • correctness: higher; failed exact-anchor insertions return actionable recovery hints instead of bare errors.
  • latency: lower because agents retry with short unique anchors or member-scoped edits faster.
  • token_count: lower by avoiding copied multiline anchors and repeated failed insert attempts.

2026-05-17 - Startup insert guidance edit after member-source failure

• RoslynSkills version:
  • roscli 0.1.6-preview.88+af751642a5eebc3c5ffd6d1bc702bc2c5a744b70
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round showed the new edit.insert_text short-anchor guidance was only present when explicitly prompted via describe-command, not in the default agent-start/csharp-start workflow. A targeted ctx.member_source probe on src/RoslynSkills.Cli/CliApplication.cs failed without usable output, so bounded source reads were used for this guidance/test edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --focus-text "Use edit.replace_in_member" --context-lines-before 6 --context-lines-after 14 --max-chars 8000
• Proposed Roslyn command/option improvement:
  • Return explicit failure data and timeout/partial-result telemetry when ctx.member_source cannot service large CLI source files.
  • Promote high-churn edit-command caveats directly in startup guidance, not only in describe-command.
• Expected impact:
  • correctness: higher; agents see insertion guardrails before choosing the command.
  • latency: lower by reducing failed multiline-anchor insert attempts.
  • token_count: lower because fewer retries are needed after exact-anchor failures.

2026-05-17 - Startup evidence and multiline replacement guidance after roscli search failure

• RoslynSkills version:
  • roscli 0.1.6-preview.89+a2a46e4971f96d3b58dfae42b3ce4f748432a48c
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round showed the agent began docs/C# exploration before the required edit.claim list, ctx.changed_files, and workspace.preload evidence commands, then later hit a direct edit.replace_in_member quoting failure for multiline replacement text. A roscli ctx.search_text lookup for the startup guidance failed without useful output, so bounded source reads were used for the self-hosted guidance/test edit.
• Roslyn command attempted:
  • roscli ctx.search_text --pattern "Use edit.replace_in_member" --root C:\Work\RoslynSkills --file-glob "*.cs" --max-results 20 --context-lines 2
• Proposed Roslyn command/option improvement:
  • Return explicit failure data for CLI search/parser failures involving backtick-heavy patterns.
  • Make agent-start Turn 2 start with a literal startup command block and surface multiline replacement JSON guidance by default.
• Expected impact:
  • correctness: higher; startup evidence is collected before C# exploration.
  • latency: lower by avoiding corrective supervision and failed direct multiline edit attempts.
  • token_count: lower through fewer retry/correction turns.

2026-05-17 - Upstream reference guidance edit after member-source hang

• RoslynSkills version:
  • roscli 0.1.6-preview.90+3f6fd356313460f115d0c8566552a037868310f2
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round used roscli correctly for C# work but dumped a huge non-C# upstream .external rg result because startup guidance allowed rg -n -C 2 -m 40 <pattern> <path> over broad reference roots. While patching the startup guidance, two self-hosted ctx.member_source calls on CliApplication.cs/CliApplicationTests.cs hung and had to be killed, so bounded source reads were used for the guidance/test edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --include-source-text true --brief false
  • roscli ctx.member_source tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs --member-name CSharpStart_ReturnsOperationalAgentGuide --include-source-text true --brief false
• Proposed Roslyn command/option improvement:
  • Add timeout/partial-result telemetry for self-hosted ctx.member_source calls.
  • Add an upstream/reference lookup helper or startup guidance primitive that encodes the two-step bounded pattern: locate one file with rg -l, then inspect only that file with contextual rg.
• Expected impact:
  • correctness: neutral for C# semantics, positive for supervision quality because agents keep reference evidence focused.
  • latency: lower by avoiding transcript-spilling broad searches.
  • token_count: lower because upstream comparisons no longer dump thousands of irrelevant lines.

2026-05-17 - Final compliance checklist guidance edit after supervised drift

• RoslynSkills version:
  • roscli 0.1.6-preview.91+72a6bca9e47dd744dc777394fd2390d9f38e4e56
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round on preview .91 completed successfully with roscli-only C# work, but skipped the startup evidence block until corrected and initially attempted edit.insert_text with a copied multiline anchor. The fix is a guidance/test update in RoslynSkills itself; no additional Roslyn command was attempted because the preceding self-hosted ctx.member_source calls had just hung in this same guidance-edit loop.
• Roslyn command attempted:
  • None for this incremental guidance edit after the immediately preceding ctx.member_source hang.
• Proposed Roslyn command/option improvement:
  • Keep a compact, tail-visible agent-start final checklist that repeats mandatory startup commands and high-churn edit guardrails.
  • Longer term, add a command/session mode that can verify startup compliance mechanically instead of relying on prompt text.
• Expected impact:
  • correctness: higher because skipped startup evidence becomes easier to catch in collapsed transcripts.
  • latency: lower by reducing corrective supervision turns.
  • token_count: lower by preventing repeated broad orientation and failed multiline-anchor insert attempts.

2026-05-17 - Agent-begin command implementation after repeated startup skip

• RoslynSkills version:
  • roscli 0.1.6-preview.92+7ec9819e8c27e4fb581b00470976cb0fab29f210
• Exact reason fallback was required/preferred:
  • A supervised FrankenTui.NET round still skipped the startup evidence sequence even after the tail checklist, then later reported that the sequence had run before C# exploration although transcript observation showed otherwise. This required a self-hosted CLI implementation change to add agent-begin, a single command that runs the sequence mechanically. RoslynSkills self-hosted ctx.member_source remains unreliable on CliApplication.cs, so bounded source reads and text patching were used.
• Roslyn command attempted:
  • No new attempt in this patch beyond the earlier repeated ctx.member_source hangs in the same file during this session.
• Proposed Roslyn command/option improvement:
  • Add first-class command-level workflow primitives for recurring multi-step rituals, starting with agent-begin.
  • Longer term, add transcript/compliance telemetry that can prove ordering instead of relying on final prose reports.
• Expected impact:
  • correctness: higher because the evidence sequence is executed by one command before work starts.
  • latency: lower because supervisors no longer need to correct skipped individual startup commands.
  • token_count: lower by replacing three command prompts and corrective discussion with one envelope.

2026-05-17 - Agent-begin protocol hint edit after parallel semantic reads

• RoslynSkills version:
  • roscli 0.1.6-preview.93+f24600c7ac128d55e6d100b6cc9389c3aa8df73a
• Exact reason fallback was required/preferred:
  • A fresh FrankenTui.NET round successfully acquired and used agent-begin, but then launched three ctx.file_outline semantic reads in parallel before self-correcting. The fix is a self-hosted CLI guidance/envelope update; current RoslynSkills source editing still relied on direct patching because ctx.member_source on this large CLI file has repeatedly hung in this session.
• Roslyn command attempted:
  • No new self-hosted command attempt for this narrow edit after the repeated ctx.member_source hangs already logged.
• Proposed Roslyn command/option improvement:
  • Surface sequential-only semantic-read protocol directly in the agent-begin result envelope, where agents look immediately after startup.
  • Consider a future safe batched semantic read command if multiple independent outlines are a common need.
• Expected impact:
  • correctness: higher by reducing stale hot-workspace reads and lock/concurrency hazards.
  • latency: lower by avoiding accidental parallel calls and their corrective narration.
  • token_count: lower because agents should not need to self-correct after parallel semantic reads.

2026-05-17 - Supervised startup split after agent-begin evidence scrolled out

• RoslynSkills version:
  • roscli 0.1.6-preview.94+8f522c743c47af30a55af1cca2454d938332b614
• Exact reason fallback was required/preferred:
  • A fresh FrankenTui.NET round reported successful agent-begin, but the decisive startup output could scroll out before closeout, making ordering hard to audit. The change is startup guidance text in the RoslynSkills CLI itself, so direct source patching was used because self-hosted ctx.member_source remains unreliable on this large CLI file.
• Roslyn command attempted:
  • None for this narrow guidance edit after repeated self-hosted ctx.member_source hangs already logged.
• Proposed Roslyn command/option improvement:
  • Split supervised Turn 2 into Turn 2A (agent-begin, stop and report step summaries) and Turn 2B (continue the C# slice from the next instruction).
  • Consider a persistent startup trace command later if transcript-only auditing remains weak.
• Expected impact:
  • correctness: higher because startup evidence is audited before implementation begins.
  • latency: slightly higher by one short supervision turn, but lower than correcting skipped startup later.
  • token_count: lower overall when it prevents long non-compliant trajectories.

2026-05-17 - Mutation-time claim evidence made visible

• RoslynSkills version:
  • roscli 0.1.6-preview.95+1ec0852f70619397671380531533644954ab9ac9
• Exact reason fallback was required/preferred:
  • The supervised FrankenTui.NET round released claims cleanly, but the capture window did not always show the claim command immediately before the first C# edit. The improvement is in the large self-hosted CLI formatter/test file; ctx.member_source hung on both CliApplication.cs and ReplaceInMemberCommand.cs, so bounded source reads plus apply_patch were used.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildClaimStatusSuffix --context-lines-before 8 --context-lines-after 8
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/ReplaceInMemberCommand.cs --member-name ExecuteAsync --focus-text "claim_status" --context-lines-before 12 --context-lines-after 18
• Proposed Roslyn command/option improvement:
  • Keep claimed=<id> or unclaimed directly in write-command summaries so mutation-time claim state remains visible even when earlier transcript lines scroll away.
  • Investigate large-file ctx.member_source hangs as a self-hosting reliability defect.
• Expected impact:
  • correctness: higher because claim-before-edit compliance is auditable at the mutation result.
  • latency: neutral; it reuses existing claim_status payload.
  • token_count: lower by reducing follow-up claim-status verification prompts.

2026-05-17 - Insert edits lacked mutation-time claim summary

• RoslynSkills version:
  • roscli 0.1.6-preview.96+c8b5ec1af1c1d82f3dcdec3db05a675114cdfa98
• Exact reason fallback was required/preferred:
  • The next fresh FrankenTui.NET cycle validated claimed=<id> on edit.replace_text, but edit.insert_text wrote a claimed test file and its summary still lacked claim evidence. This was a narrow self-hosted command-surface edit after recent ctx.member_source hangs on large CLI/core command files, so bounded source reads plus apply_patch were used.
• Roslyn command attempted:
  • rg -n "claim_status|insert_text|wrote_file" src/RoslynSkills.Core/Commands/InsertTextCommand.cs src/RoslynSkills.Cli/CliApplication.cs tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs
• Proposed Roslyn command/option improvement:
  • Add claim_status to edit.insert_text and reuse the CLI claim suffix helper so all direct exact write primitives expose mutation-time claim state.
  • Next consider common summary behavior for future edit commands to avoid command-by-command drift.
• Expected impact:
  • correctness: higher because insert-based edits become auditable like replace-based edits.
  • latency: neutral.
  • token_count: lower by avoiding separate claim list checks after insert writes.

2026-05-17 - Startup guidance missed semantic caller navigation

• RoslynSkills version:
  • roscli 0.1.6-preview.97+a2562699e1f9033132331b1421d7a20fae4bf146
• Exact reason fallback was required/preferred:
  • The fresh FrankenTui.NET cycle stayed on roscli for C# work, but it tried to infer routing paths through repeated ctx.search_text, broad-ish ctx.file_outline, and missed-focus ctx.member_source calls. Existing nav.find_invocations and nav.call_hierarchy would have been a better acquisition path, but startup guidance did not point to them after a method-reference hit. This was a CLI guidance/test edit, so bounded source reads plus apply_patch were used.
• Roslyn command attempted:
  • roscli list-commands --compact | Select-String -Pattern 'nav|reference|call|ctx.search|member'
  • roscli describe-command nav.find_invocations
  • roscli describe-command nav.call_hierarchy
  • roscli describe-command ctx.call_chain_slice
• Proposed Roslyn command/option improvement:
  • Put nav.find_invocations/nav.call_hierarchy examples in agent-start/csharp-start immediately after ctx.search_text discovery examples.
  • Longer term, consider ctx.search_text result guidance that detects method-looking hits and suggests semantic caller navigation with exact line/column anchors.
• Expected impact:
  • correctness: higher because callers/routing are resolved semantically.
  • latency: lower by avoiding multiple focus-miss retries.
  • token_count: lower by replacing large outline/member payloads with targeted nav results.

2026-05-17 - Large block edits replayed through multiline old_text/new_text

• RoslynSkills version:
  • roscli 0.1.6-preview.98+efa2f7132aca58ffa934803b5065ba2202c047a7
• Exact reason fallback was required/preferred:
  • The fresh FrankenTui.NET cycle used roscli correctly and claimed files before mutation, but the large registry rewrite was sent as huge multiline old_text/new_text JSON to edit.replace_in_member, inflating transcript size and increasing stale-context risk. This is a startup guidance change, so bounded source reads plus apply_patch were used.
• Roslyn command attempted:
  • rg -n "replace_span|include-edit-target|include_edit_target|large|old_text/new_text|edit.batch_exact" src/RoslynSkills.Cli/CliApplication.cs tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs
• Proposed Roslyn command/option improvement:
  • Clarify that edit.replace_in_member multiline JSON is for small snippets; large block/member/body rewrites should use ctx.member_source --include-edit-target-text true plus edit.batch_exact replace_span with expected_text.
  • Longer term, consider warning when edit.replace_in_member receives very large old_text/new_text.
• Expected impact:
  • correctness: higher by using span+expected_text for large rewrites.
  • latency: lower by reducing giant argument serialization and retry risk.
  • token_count: lower by avoiding large duplicated code blocks in transcripts.

2026-05-17 - Large replace_in_member guidance needed at mutation time

• RoslynSkills version:
  • roscli 0.1.6-preview.99+0af707ec501f2b5b52c2e723f8ab4f475870de9b
• Exact reason fallback was required/preferred:
  • The .99 fresh FrankenTui.NET cycle was clean and roscli-only, but the prior large-payload pattern showed startup guidance alone can be missed when the agent is already constructing an edit. A self-hosted ctx.member_source call hung on CliApplication.cs, and a second call hung on ReplaceInMemberCommand.cs; both were stopped to avoid host process pressure. Bounded source reads plus apply_patch were used for the narrow command/test edit.
• Roslyn command attempted:
  • roscli ctx.member_source C:\Work\RoslynSkills\src\RoslynSkills.Cli\CliApplication.cs --member-name HandleDirectCommandAsync --focus-text "edit.replace_in_member" --context-lines-before 20 --context-lines-after 70 --include-source-text true
  • roscli ctx.member_source src\RoslynSkills.Core\Commands\ReplaceInMemberCommand.cs --member-name ExecuteAsync --focus-text "diagnostics_after_replace" --context-lines-before 35 --context-lines-after 25 --include-source-text true
• Proposed Roslyn command/option improvement:
  • Add edit.replace_in_member.result_guidance when old_text or new_text exceeds a line/character threshold, suggesting ctx.member_source --include-edit-target-text true and edit.batch_exact replace_span.
  • Continue investigating ctx.member_source hangs on self-hosted command files as a reliability defect.
• Expected impact:
  • correctness: higher by steering large rewrites to span+expected_text anchoring.
  • latency: lower by reducing large JSON construction and stale-context retries.
  • token_count: lower by avoiding duplicated multiline old/new payloads in transcripts.

2026-05-17 - Member-source missing-member recovery was prose-only

• RoslynSkills version:
  • roscli 0.1.6-preview.100+ef08007294f9993810c0a166dd0717ba2b4cd19c
• Exact reason fallback was required/preferred:
  • The fresh FrankenTui.NET cycle stayed on roscli and completed with passing tests, but a ctx.member_source --member-name miss in a large test file forced the agent to infer a recovery path through ctx.file_outline. This was a narrow self-hosted command/test edit; bounded source reads plus apply_patch were used after recent ctx.member_source hangs on self-hosted command files.
• Roslyn command attempted:
  • roscli ctx.search_text --file-path src\RoslynSkills.Core\Commands\MemberSourceCommand.cs --pattern "member_not_found" --max-results 20 --context-lines 4
  • roscli ctx.search_text --solution C:\Work\RoslynSkills\RoslynSkills.slnx --pattern "member_not_found" --file-glob "*.cs" --max-results 40 --context-lines 1
• Proposed Roslyn command/option improvement:
  • Return structured failure data for ctx.member_source member_not_found, including recovery_hint.suggested_commands with exact file-specific ctx.file_outline and ctx.search_text commands.
• Expected impact:
  • correctness: higher because agents recover using exact file-local symbols before retrying.
  • latency: lower by reducing exploratory search after member-name typos or drift.
  • token_count: lower by avoiding broad recovery scans in large test files.

2026-05-17 - Exact replace allowed attribute/member newline join

• RoslynSkills version:
  • roscli 0.1.6-preview.101+7992cc3437e0b3411afe2200c1b22749fd61a658
• Exact reason fallback was required/preferred:
  • The fresh FrankenTui.NET cycle stayed roscli-only and completed quickly, but an edit.replace_text insertion produced [Fact] public void... on one line and required a second formatting repair edit. This was a narrow command/test edit; bounded source reads plus apply_patch were used because self-hosted member-source reliability on command files remains suspect.
• Roslyn command attempted:
  • roscli ctx.search_text --solution C:\Work\RoslynSkills\RoslynSkills.slnx --pattern "class ReplaceTextCommand" --file-glob "*.cs" --max-results 20 --context-lines 0
  • roscli ctx.search_text --solution C:\Work\RoslynSkills\RoslynSkills.slnx --pattern "replace_text" --file-glob "CliApplicationTests.cs" --max-results 30 --context-lines 1
• Proposed Roslyn command/option improvement:
  • Add edit.replace_text.result_guidance when updated C# content contains an attribute and member declaration joined on the same line, with a copy-ready ctx.search_text inspection command.
• Expected impact:
  • correctness: higher by catching syntax/formatting hazards immediately after edit.
  • latency: lower by reducing repair loops after insertion-style replacements.
  • token_count: lower by avoiding an extra read/edit cycle for common test-method insertion mistakes.

2026-05-17 - Large scoped replace threshold was too permissive

• RoslynSkills version:
  • roscli 0.1.6-preview.102+77d7c2a8986d8f1c774ae58c04e1aa7c0cfdd471
• Exact reason fallback was required/preferred:
  • The fresh FrankenTui.NET cycle stayed roscli-only and passed focused/wider Kanban tests, but it sent a bulky edit.replace_in_member JSON payload with around a dozen changed lines and did not trip the existing large-payload guidance. This was a tiny threshold/test edit, so bounded source reads plus apply_patch were used.
• Roslyn command attempted:
  • Get-Content src\RoslynSkills.Core\Commands\ReplaceInMemberCommand.cs | Select-Object -First 20
  • Get-Content tests\RoslynSkills.Core.Tests\CommandTests.cs | Select-Object -Skip 999 -First 45
• Proposed Roslyn command/option improvement:
  • Lower edit.replace_in_member large text line threshold from 20 to 10 and update the regression to prove 12-line payloads now receive span-edit guidance.
• Expected impact:
  • correctness: higher by steering medium-large member edits to guarded spans earlier.
  • latency: lower by reducing repeated large JSON exact-replace calls.
  • token_count: lower by catching transcript-expensive edits before they become habitual.

2026-05-17 - Self-hosted member_source hung while tuning focus-miss guidance

• RoslynSkills version:
  • roscli 0.1.6-preview.103+057347e27bad23976b81780bde0fc622771189ff
• Exact reason fallback was required/preferred:
  • ctx.member_source hung while reading src/RoslynSkills.Core/Commands/MemberSourceCommand.cs to tune the same command's focus-miss guidance. The roscli process was stopped and bounded shell reads were used for this self-hosted implementation edit.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Core/Commands/MemberSourceCommand.cs --member-name BuildPayloadGuidance --include-edit-target-text true --context-lines-before 20 --context-lines-after 30
• Proposed Roslyn command/option improvement:
  • Fix the self-hosted ctx.member_source hang on large command files and add a timeout/error envelope so agents get a structured recovery path instead of a silent wait.
• Expected impact:
  • correctness: higher by keeping command-surface edits inside Roslyn context.
  • latency: lower by avoiding manual process inspection and kill steps.
  • token_count: lower by eliminating fallback logging and duplicate reads for roscli implementation work.

2026-05-17 - Large matched member windows needed acquisition guidance

• RoslynSkills version:
  • roscli 0.1.6-preview.104+59fb211d3b7999de0b75eac662bf30709dfe603a
• Exact reason fallback was required/preferred:
  • Fresh-start FrankenTui.NET cycle 1 acquired roscli successfully and used no C# fallback, but it requested matched ctx.member_source windows with high context counts. The required roscli implementation edit touched ctx.member_source itself, which is still known to hang on self-hosted reads, so bounded shell reads plus apply_patch were used.
• Roslyn command attempted:
  • roscli ctx.search_text --root src --pattern "BuildPayloadGuidance" --max-results 20 --context-lines 2
  • Prior failed self-hosted command remains: roscli ctx.member_source src/RoslynSkills.Core/Commands/MemberSourceCommand.cs --member-name BuildPayloadGuidance --include-edit-target-text true --context-lines-before 20 --context-lines-after 30
• Proposed Roslyn command/option improvement:
  • Add ctx.member_source payload guidance for matched focus windows over 50 lines, recommending a tighter rerun or metadata-only source suppression.
• Expected impact:
  • correctness: neutral to higher by preserving focus evidence while discouraging broad-window edit planning.
  • latency: lower by reducing repeated large semantic reads.
  • token_count: lower by steering fresh agents toward smaller context windows after successful focus acquisition.

2026-05-17 - Fixed-width UI repair used ad hoc shell text measurement

• RoslynSkills version:
  • roscli 0.1.6-preview.106+2aaceb449009bfd1823fe29726c0d92abe2c387b
• Exact reason fallback was required/preferred:
  • Fresh-start FrankenTui.NET cycle 3 stayed roscli-only for C# reads/edits, but after a fixed-width render assertion failed it used ad hoc PowerShell string length checks to pick a shorter UI footer. This did not read or edit .cs, but the roscli implementation pass touched CliApplication.cs, so bounded shell reads plus apply_patch were used.
• Roslyn command attempted:
  • rg -n "HandleVersionAsync|TryGetOption\\(|HasOption\\(" src/RoslynSkills.Cli/CliApplication.cs tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs
  • Bounded Get-Content reads of src/RoslynSkills.Cli/CliApplication.cs and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.
• Proposed Roslyn command/option improvement:
  • Add a small roscli text.measure helper for candidate UI strings so fresh agents can keep fixed-width repair loops inside roscli instead of shell snippets.
• Expected impact:
  • correctness: higher for terminal UI edits by making label length evidence explicit.
  • latency: lower by replacing trial shell snippets with a stable helper.
  • token_count: lower by avoiding multiple ad hoc command variants during width repair.

2026-05-17 - Validation-only slice counted as implementation

• RoslynSkills version:
  • roscli 0.1.6-preview.107+a162ed3b64506782eaa70966574b661bb7f8f69a
• Exact reason fallback was required/preferred:
  • Fresh-start FrankenTui.NET cycle 4 acquired roscli correctly and used no C# fallback, but it validated an already-present dirty slice without implementing a new increment. The roscli guidance update touched CliApplication.cs, so bounded shell reads plus apply_patch were used.
• Roslyn command attempted:
  • rg -n "Continue one narrow|First-slice budget|next = ok|WriteAgentBeginResultAsync" src/RoslynSkills.Cli/CliApplication.cs tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs docs/PIT_OF_SUCCESS.md
  • Bounded Get-Content reads of src/RoslynSkills.Cli/CliApplication.cs, docs/PIT_OF_SUCCESS.md, and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.
• Proposed Roslyn command/option improvement:
  • Tighten fresh-slice guidance so passing tests on existing dirty work must be reported as validation-only unless the user explicitly asked only to validate; otherwise choose a different smallest unimplemented increment.
• Expected impact:
  • correctness: higher by preventing no-op validation from being counted as implementation progress.
  • latency: lower by steering fresh agents away from already-complete dirty slices.
  • token_count: lower by reducing exploratory loops that end without a mutation.

2026-05-17 - Agent-start batched with docs orientation

• RoslynSkills version:
  • roscli 0.1.6-preview.108+e205f8c91fcd667792e6b3d31d6c157f99cdda28
• Exact reason fallback was required/preferred:
  • Fresh-start FrankenTui.NET cycle 5 acquired roscli and completed a real Ctrl+T slice, but its final caveat said it read root/docs orientation in the same initial batch as agent-start, before agent-begin. This is a startup acquisition issue; the roscli guidance edit touched CliApplication.cs, so bounded shell reads plus apply_patch were used.
• Roslyn command attempted:
  • rg -n "Turn 1 prompt|agent-start|before any docs|before docs" src/RoslynSkills.Cli/CliApplication.cs tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs docs/PIT_OF_SUCCESS.md
  • Bounded Get-Content reads of src/RoslynSkills.Cli/CliApplication.cs and tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs.
• Proposed Roslyn command/option improvement:
  • Make the Turn 1 agent-start prompt explicitly forbid docs, git, file listing, or repo exploration in the same response, and reject batched startup/exploration transcripts.
• Expected impact:
  • correctness: higher by making startup evidence uncontaminated.
  • latency: lower by preventing early off-protocol exploration that may need interruption.
  • token_count: lower by separating bootstrap from repo orientation.

2026-05-17 - Claim closeout guidance location fallback

• RoslynSkills version:
  • roscli 0.1.6-preview.109+da83f53c6294d63c2fc345dca0f6c37a950bad7d
• Exact reason fallback was required/preferred:
  • Cycle 6 completed a real FrankenTui.NET Kanban slice but left active edit claims until a second closeout prompt. While tightening RoslynSkills startup guidance, the first ctx.member_source attempt failed with daemon_unavailable before workspace.use; a bounded rg search was used to locate claim-closeout wording across CLI/tests/docs before retrying Roslyn context reads.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --focus-text "release claims" ...
  • Result: daemon_unavailable; then roscli workspace.use RoslynSkills.slnx and the same ctx.member_source succeeded.
• Proposed Roslyn command/option improvement:
  • Allow ctx.member_source to auto-suggest or invoke workspace.use when exactly one solution file is present, or make the daemon-unavailable error include the detected solution path.
• Expected impact:
  • correctness: neutral; fallback was read-only location discovery.
  • latency: lower by avoiding a failed first Roslyn context read.
  • token_count: lower by reducing shell search plus retry chatter.

2026-05-17 - Focus-not-found guidance fallback

• RoslynSkills version:
  • roscli 0.1.6-preview.110+8afef38b90942669c2a16c490d0c2c4a95ad968e
• Exact reason fallback was required/preferred:
  • Cycle 7 completed successfully but showed an 80-line ctx.member_source read with focus=not-found, indicating the startup guide should tell agents to rerun tighter before consuming large source. While implementing that wording in RoslynSkills, repeated ctx.member_source attempts failed with daemon_unavailable after the global tool reinstall; bounded Get-Content and rg reads were used to locate and verify the exact guidance strings.
• Roslyn command attempted:
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --focus-text "ctx.member_source with small focus windows" ...
  • roscli ctx.member_source tests/RoslynSkills.Cli.Tests/CliApplicationTests.cs --member-name CSharpStartSupervised_ReturnsTwoTurnProtocol --focus-text "start 3-12 lines, not 80+" ...
  • Both returned daemon_unavailable and recommended roscli workspace.use <solution>.
• Proposed Roslyn command/option improvement:
  • Make ctx.member_source recover automatically when the cwd has a single solution, or include a ready-to-run workspace.use <detected-solution> hint in daemon_unavailable.
• Expected impact:
  • correctness: neutral; edits remained small and test-gated.
  • latency: lower by avoiding a failed context-read chain.
  • token_count: lower by reducing fallback and retry output.

2026-05-17 - Agent-begin hard-gate location fallback

• RoslynSkills version:
  • roscli 0.1.6-preview.111+2119460d7116996a767ade216bb49c78a656f155
• Exact reason fallback was required/preferred:
  • Cycle 8 completed a real Table Theme Gallery slice but reported reading root docs in parallel with agent-start before agent-begin. A bounded rg search was used to locate startup compliance wording before reattaching the Roslyn workspace and applying the C# changes with edit.replace_in_member.
• Roslyn command attempted:
  • roscli workspace.use RoslynSkills.slnx
  • roscli ctx.member_source src/RoslynSkills.Cli/CliApplication.cs --member-name BuildCSharpStartGuide --focus-text "## First Moves" ...
  • roscli edit.replace_in_member for production and test updates.
• Proposed Roslyn command/option improvement:
  • Add a command-surface search/read helper for guidance strings that automatically attaches the only solution in cwd, reducing fallback to rg for small docstring/navigation changes.
• Expected impact:
  • correctness: higher by making agent-begin an explicit hard gate after agent-start.
  • latency: lower by preventing docs orientation before the startup evidence command.
  • token_count: lower by avoiding root-doc reads before the C# protocol is established.

2026-05-24 - CI-only path separator test fallback

• RoslynSkills version:
  • roscli 1.0.0+d263128a5749b0f45cc98437af94a8d782df2e92
• Exact reason fallback was required/preferred:
  • The NuGet preview workflow failed on Linux because BuildDataSummary_UsesNestedHostEnvelopeDataForDaemonRoutedExactEdit expected Demo.cs, while the summarizer preserved a Windows-style C:\Temp\Demo.cs path on non-Windows hosts. A Roslyn ctx.member_source lookup was attempted first but did not return in a useful time for this test method, so bounded rg/Get-Content reads and a narrow patch were used to fix the cross-platform display helper.
• Roslyn command attempted:
  • scripts\roscli.cmd ctx.member_source tests\RoslynSkills.Cli.Tests\CliApplicationTests.cs --member-name BuildDataSummary_UsesNestedHostEnvelopeDataForDaemonRoutedExactEdit --workspace-path RoslynSkills.slnx --require-workspace true --mode member
• Proposed Roslyn command/option improvement:
  • Make ctx.member_source --member-name return quickly for large test classes or provide progress/error output when workspace-backed member lookup stalls, especially in release-publish repair loops.
• Expected impact:
  • correctness: higher by keeping CLI summaries stable across Windows and Linux payload paths.
  • latency: lower by avoiding manual fallback during CI-only release failures.
  • token_count: lower by reducing failed command output and repeated text searches.