releases/ClaudeDo
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 39 Wiki Activity

Merge branch 'main' into feat/poweruse-list-handler

Browse Source 
Kollision mit #264 (Handoff-Budget im Brief sichtbar machen): beide Seiten haben
HandoffRoundTracker, HandoffMcpTools und InteractiveLaunchSpecService angefasst.

Der Konflikt war inhaltlich, nicht nur textuell. #264 liest den Cap an zwei
Stellen aus der Konstante (GetStatus und das roundInfo-Rendering), waehrend
dieser Branch ihn zum Parameter aus app_settings gemacht hat. Ein reiner
Text-Merge haette kompiliert und trotzdem gelogen: Register haette den
konfigurierten Cap durchgesetzt, waehrend der Brief dem Modell weiter "2 Runden
uebrig" gemeldet haette, obwohl es 39 hat.

Aufgeloest so, dass der Cap eine einzige Quelle hat:
- GetStatus(taskId, maxHandoffs) nimmt den Cap als Parameter, mit demselben
  Clamp wie Register. Die Rechnerei liegt damit an einer Stelle.
- GetHandoffStatus liest das Setting und gibt es weiter.
- Das roundInfo-Rendering benutzt GetStatus statt eigener Arithmetik.

Zwei Tests nageln genau diesen Drift fest, damit er beim naechsten Merge nicht
unbemerkt zurueckkommt: einer auf GetHandoffStatus, einer auf den Brief.

MaxHandoffs -> DefaultMaxHandoffs in #264s vier Test-Referenzen; die laufen alle
mit Default-Settings, die Semantik bleibt.
This commit is contained in:
Mika Kuns
2026-09-02 15:48:43 +02:00
parent 416997d7e0 b00bdf28ae
commit 675b36e923
41 changed files with 2323 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ClaudeDo.Worker.Tests/External/HandoffMcpToolsTests.cs
Vendored
+141
View File
@@ -209,6 +209,63 @@ public sealed class HandoffMcpToolsTests : IDisposable
secondSut.HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None));
}
[Theory]
[InlineData(1, 3)]
[InlineData(2, 2)]
[InlineData(4, 0)]
public void HandoffRoundTracker_GetState_ReportsCountAfterNRegistrations(int registrations, int expectedRemaining)
{
var tracker = new HandoffRoundTracker();
var taskId = Guid.NewGuid().ToString();
for (var i = 0; i < registrations; i++)
tracker.Register(taskId, "wait");
var (count, sealedState) = tracker.GetState(taskId);
Assert.Equal(registrations, count);
Assert.Equal(expectedRemaining, HandoffRoundTracker.DefaultMaxHandoffs - count);
Assert.False(sealedState);
}
[Fact]
public void HandoffRoundTracker_GetState_UnregisteredTask_ReturnsZero()
{
var tracker = new HandoffRoundTracker();
var (count, sealedState) = tracker.GetState(Guid.NewGuid().ToString());
Assert.Equal(0, count);
Assert.False(sealedState);
}
[Fact]
public void HandoffRoundTracker_Register_DoesNotMutateStateVisibleFromGetState_BeyondItsOwnCall()
{
var tracker = new HandoffRoundTracker();
var taskId = Guid.NewGuid().ToString();
tracker.Register(taskId, "wait");
var (beforeCount, _) = tracker.GetState(taskId);
Assert.Equal(1, beforeCount);
// GetState itself must be read-only -- calling it repeatedly must not advance the round.
tracker.GetState(taskId);
tracker.GetState(taskId);
var (afterCount, _) = tracker.GetState(taskId);
Assert.Equal(beforeCount, afterCount);
}
[Fact]
public void HandoffRoundTracker_RejectedHandoff_ErrorNamesTheNextAction()
{
var tracker = new HandoffRoundTracker();
var taskId = Guid.NewGuid().ToString();
tracker.Register(taskId, "merge_final");
var result = tracker.Register(taskId, "wait");
Assert.True(result.Rejected);
Assert.Contains("new handler run", result.Error, StringComparison.OrdinalIgnoreCase);
}
[Fact]
public async Task HandoffListHandler_RaisedCapSetting_AllowsMoreRoundsBeforeCoercing()
{
@@ -258,6 +315,30 @@ public sealed class HandoffMcpToolsTests : IDisposable
Assert.Equal("merge_final", second.NextPhase);
}
/// GetHandoffStatus must report against the SAME cap HandoffListHandler enforces. Reading it
/// off the constant would understate a raised budget and make the tool lie about how much room
/// the chain has left.
[Fact]
public async Task GetHandoffStatus_RaisedCap_ReportsConfiguredRemaining()
{
await SetMaxHandoffsAsync(40);
var listId = await SeedListAsync();
var handlerTask = await SeedTaskAsync(listId);
var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
var tracker = new HandoffRoundTracker();
var survivors = new[] { survivor.Id };
await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None);
await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge", CancellationToken.None);
var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
Assert.Equal(2, status.Round);
Assert.Equal(38, status.Remaining);
Assert.False(status.Final);
}
[Fact]
public async Task HandoffListHandler_TwoHandlerTasks_DoNotShareACounter()
{
@@ -280,4 +361,64 @@ public sealed class HandoffMcpToolsTests : IDisposable
Assert.False(resultB.Coerced);
Assert.Equal("wait", resultB.NextPhase);
}
[Fact]
public async Task GetHandoffStatus_NeverHandedOff_ReportsZeroRoundFullBudget()
{
var listId = await SeedListAsync();
var handlerTask = await SeedTaskAsync(listId);
var sut = BuildSut();
var status = await sut.GetHandoffStatus(handlerTask.Id, CancellationToken.None);
Assert.Equal(handlerTask.Id, status.TaskId);
Assert.Equal(handlerTask.Number, status.Number);
Assert.Equal(0, status.Round);
Assert.Equal(HandoffRoundTracker.DefaultMaxHandoffs, status.Remaining);
Assert.False(status.Final);
}
[Fact]
public async Task GetHandoffStatus_AfterHandoffs_ReflectsTrackerState()
{
var listId = await SeedListAsync();
var handlerTask = await SeedTaskAsync(listId);
var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
var tracker = new HandoffRoundTracker();
var survivors = new[] { survivor.Id };
await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None);
await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge", CancellationToken.None);
var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
Assert.Equal(2, status.Round);
Assert.Equal(HandoffRoundTracker.DefaultMaxHandoffs - 2, status.Remaining);
Assert.False(status.Final);
}
[Fact]
public async Task GetHandoffStatus_AfterMergeFinal_ReportsFinal()
{
var listId = await SeedListAsync();
var handlerTask = await SeedTaskAsync(listId);
var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
var tracker = new HandoffRoundTracker();
var survivors = new[] { survivor.Id };
await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge_final", CancellationToken.None);
var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
Assert.True(status.Final);
Assert.Equal(1, status.Round);
}
[Fact]
public async Task GetHandoffStatus_UnknownTask_Throws()
{
var sut = BuildSut();
await Assert.ThrowsAsync<InvalidOperationException>(() =>
sut.GetHandoffStatus("missing", CancellationToken.None));
}
}