feat: implement Foundation V1 walking skeleton
CI / test (push) Successful in 7m31s

This commit is contained in:
m
2026-08-16 15:22:49 +03:00
commit 9b136621ef
205 changed files with 6345 additions and 0 deletions
+72
View File
@@ -0,0 +1,72 @@
package action_commit_test
import (
"errors"
"testing"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/capability"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"git.cin.su/m/Assistant/contracts/identity"
"git.cin.su/m/Assistant/contracts/work"
authoritydomain "git.cin.su/m/Assistant/modules/authority/domain"
commitdomain "git.cin.su/m/Assistant/modules/commit/domain"
"git.cin.su/m/Assistant/modules/commit/ports"
"git.cin.su/m/Assistant/platform/ids"
)
type validator struct{}
func (validator) Validate(context authority.AuthorizationContext) error {
return authoritydomain.ValidateGrant(context.Binding, context.Scope, context.Grant)
}
type unknownExecutor struct{}
func (unknownExecutor) Execute(commitcontract.AuthorizedAction) ports.ExecutionResult {
return ports.ExecutionResult{Known: false}
}
func TestWS003RejectsRevokedGrantAndNeverExecutesProposalDirectly(t *testing.T) {
context, proposal := testContextAndProposal()
context.Grant.Active = false
_, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
if !errors.Is(err, authoritydomain.ErrInvalidGrant) {
t.Fatalf("authorization error = %v, want invalid grant", err)
}
}
func TestWS003RejectsMissingActorPrincipalBinding(t *testing.T) {
context, proposal := testContextAndProposal()
context.Binding.Active = false
_, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
if !errors.Is(err, authoritydomain.ErrInvalidGrant) {
t.Fatalf("authorization error = %v, want invalid grant", err)
}
}
func TestWS003UnknownOutcomeBlocksBlindRetry(t *testing.T) {
context, proposal := testContextAndProposal()
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
if err != nil {
t.Fatal(err)
}
attempt, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-one")), unknownExecutor{})
if !errors.Is(err, commitdomain.ErrUnknownOutcome) || attempt.State != commitcontract.ActionUnknownOutcome {
t.Fatalf("unknown result = %#v, %v", attempt, err)
}
action.State = commitcontract.ActionUnknownOutcome
if _, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-two")), unknownExecutor{}); !errors.Is(err, commitdomain.ErrUnknownOutcome) {
t.Fatalf("blind retry error = %v, want unknown outcome", err)
}
}
func testContextAndProposal() (commitdomain.AuthorizationContext, commitcontract.ActionProposal) {
actor := identity.ActorID(ids.ID("creator-actor"))
principal := identity.PrincipalID(ids.ID("creator-principal"))
scope := authority.Scope{ID: authority.ScopeID(ids.ID("global")), Global: true, Label: "all"}
grant := authority.AuthorityGrant{ID: authority.GrantID(ids.ID("grant")), ActorID: actor, PrincipalID: principal, ScopeID: scope.ID, Class: authority.GrantClassCreator, Revision: 1, Active: true}
context := commitdomain.AuthorizationContext{Binding: identity.PrincipalBinding{ActorID: actor, PrincipalID: principal, Active: true}, Scope: scope, Grant: grant}
proposal := commitcontract.ActionProposal{IntentID: commitcontract.ActionIntentID(ids.ID("intent")), ActorID: actor, CapabilityID: capability.CapabilityID(ids.ID("executor")), Target: work.TaskTarget{TaskID: work.TaskID(ids.ID("task")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: scope.ID, Revision: 1}, Operation: "mutate-external-world"}
return context, proposal
}
@@ -0,0 +1,45 @@
package action_commit_test
import (
"errors"
"testing"
"git.cin.su/m/Assistant/adapters/testexecutor"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
commitdomain "git.cin.su/m/Assistant/modules/commit/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestWS003UnknownOutcomeReconcilesWithoutDuplicateEffect(t *testing.T) {
context, proposal := testContextAndProposal()
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized-reconcile")))
if err != nil {
t.Fatal(err)
}
executor := testexecutor.New(true)
unknown, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-execute")), executor)
if !errors.Is(err, commitdomain.ErrUnknownOutcome) || unknown.State != commitcontract.ActionUnknownOutcome || executor.EffectCount() != 1 {
t.Fatalf("execute = %#v, %v, effects=%d", unknown, err, executor.EffectCount())
}
verified, err := commitdomain.Reconcile(action, unknown, commitcontract.ActionAttemptID(ids.ID("attempt-reconcile")), executor)
if err != nil || verified.State != commitcontract.ActionSucceeded || executor.EffectCount() != 1 {
t.Fatalf("reconcile = %#v, %v, effects=%d", verified, err, executor.EffectCount())
}
// Even an adversarial duplicate delivery is idempotent at the external boundary.
_, _ = commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-duplicate")), executor)
if executor.EffectCount() != 1 {
t.Fatalf("duplicate delivery created %d effects", executor.EffectCount())
}
}
func TestWS003ReconciliationRequiresUnknownOutcome(t *testing.T) {
context, proposal := testContextAndProposal()
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized-invalid-reconcile")))
if err != nil {
t.Fatal(err)
}
previous := commitcontract.ActionAttempt{ID: "attempt-failed", AuthorizedID: action.ID, IntentID: action.Proposal.IntentID, State: commitcontract.ActionFailed}
if _, err = commitdomain.Reconcile(action, previous, "attempt-next", testexecutor.New(false)); !errors.Is(err, commitdomain.ErrInvalidReconciliation) {
t.Fatalf("reconciliation error = %v", err)
}
}
+21
View File
@@ -0,0 +1,21 @@
package architecture_test
import (
"encoding/json"
"os"
"testing"
)
func TestArchitectureRegistryParses(t *testing.T) {
b, err := os.ReadFile("../../architecture/architecture-registry.json")
if err != nil {
t.Fatal(err)
}
var v map[string]any
if err := json.Unmarshal(b, &v); err != nil {
t.Fatal(err)
}
if v["semantic_generation"] == nil {
t.Fatal("semantic_generation missing")
}
}
@@ -0,0 +1,24 @@
package cognitive_fake_test
import (
"testing"
"git.cin.su/m/Assistant/adapters/models"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/capability"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"git.cin.su/m/Assistant/contracts/identity"
"git.cin.su/m/Assistant/contracts/work"
"git.cin.su/m/Assistant/platform/ids"
)
func TestDeterministicFakeEmitsCandidateOnly(t *testing.T) {
request := models.DeterministicRequest{ActorID: identity.ActorID(ids.ID("creator")), CapabilityID: capability.CapabilityID(ids.ID("fake")), Target: work.TaskTarget{TaskID: work.TaskID(ids.ID("task")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: authority.ScopeID(ids.ID("scope")), Revision: 1}, Operation: commitcontract.ExternalOperation("test-operation")}
first, second := models.Propose(request), models.Propose(request)
if first.Proposal.IntentID != second.Proposal.IntentID || first.Seed != second.Seed {
t.Fatal("same request produced different candidate")
}
if first.Proposal.State != commitcontract.ActionProposed {
t.Fatalf("state = %s, want PROPOSED", first.Proposal.State)
}
}
+44
View File
@@ -0,0 +1,44 @@
package creator_auth_test
import (
"encoding/json"
"git.cin.su/m/Assistant/modules/identity/domain"
"strings"
"testing"
"time"
)
func TestCreatorSessionIsTimeBoundAndDoesNotCarryAuthority(t *testing.T) {
now := time.Unix(1000, 0)
token, session, err := domain.IssueCreatorSession([]byte("01234567890123456789012345678901"), now, time.Minute)
if err != nil || session.ExpiresAtUnix != 1060 {
t.Fatal("issue failed")
}
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token, now); err != nil {
t.Fatal(err)
}
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token, now.Add(time.Minute)); err == nil {
t.Fatal("expired session accepted")
}
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token+"tampered", now); err == nil {
t.Fatal("tampered session accepted")
}
payload, err := json.Marshal(session)
if err != nil {
t.Fatal(err)
}
if strings.Contains(string(payload), "Grant") || strings.Contains(string(payload), "Scope") {
t.Fatal("identity session must not carry authority")
}
}
func TestCreatorBootstrapCredentialMustMatch(t *testing.T) {
if !domain.BootstrapMatches("expected", "expected") {
t.Fatal("matching bootstrap credential rejected")
}
for _, supplied := range []string{"", "wrong"} {
if domain.BootstrapMatches("expected", supplied) {
t.Fatalf("invalid bootstrap credential %q accepted", supplied)
}
}
}
@@ -0,0 +1,33 @@
package creator_authority_test
import (
"testing"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/identity"
authoritydomain "git.cin.su/m/Assistant/modules/authority/domain"
identitydomain "git.cin.su/m/Assistant/modules/identity/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestCreatorRequiresDistinctActiveBindingAndGlobalGrant(t *testing.T) {
binding := identity.PrincipalBinding{ActorID: identity.ActorID(ids.ID("creator-actor")), PrincipalID: identity.PrincipalID(ids.ID("creator-principal")), Active: true}
scope := authority.Scope{ID: authority.ScopeID(ids.ID("all-domovoy")), Label: "All Domovoy scopes", Global: true}
grant := authority.AuthorityGrant{ID: authority.GrantID(ids.ID("creator-grant")), ActorID: binding.ActorID, PrincipalID: binding.PrincipalID, ScopeID: scope.ID, Class: authority.GrantClassCreator, Revision: 1, Active: true}
if err := identitydomain.ValidateCreatorBinding(binding); err != nil {
t.Fatal(err)
}
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err != nil {
t.Fatal(err)
}
grant.Active = false
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err == nil {
t.Fatal("revoked creator grant was accepted")
}
grant.Active = true
scope.Global = false
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err == nil {
t.Fatal("non-global creator grant was accepted")
}
}
@@ -0,0 +1,39 @@
package degraded_continuity_test
import (
"testing"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/modules/capability/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestCognitiveProviderLossIsExplicitDegradedCapability(t *testing.T) {
observed := int64(1)
status := capability.Health{
CapabilityID: capability.CapabilityID(ids.ID("cognitive-proposal")),
State: capability.HealthDegraded,
Reason: capability.ReasonCognitiveProvidersUnavailable,
Revision: 1,
SemanticVersion: capability.HealthV2,
ObservedAtUnixMillis: &observed,
}
if err := domain.ValidateHealth(status); err != nil {
t.Fatalf("valid degraded health rejected: %v", err)
}
}
func TestAvailableCapabilityCannotClaimDegradedReason(t *testing.T) {
observed := int64(1)
status := capability.Health{
CapabilityID: capability.CapabilityID(ids.ID("cognitive-proposal")),
State: capability.HealthAvailable,
Reason: capability.ReasonCognitiveProvidersUnavailable,
Revision: 1,
SemanticVersion: capability.HealthV2,
ObservedAtUnixMillis: &observed,
}
if err := domain.ValidateHealth(status); err == nil {
t.Fatal("available status with degraded reason was accepted")
}
}
+25
View File
@@ -0,0 +1,25 @@
param(
[string]$DockerContext = "docker-prod",
[string]$PostgresContainer = "assistant-postgres-1"
)
$ErrorActionPreference = "Stop"
$environment = docker --context $DockerContext inspect --format '{{range .Config.Env}}{{println .}}{{end}}' $PostgresContainer
$userLine = $environment | Where-Object { $_.StartsWith("POSTGRES_USER=") } | Select-Object -First 1
$databaseLine = $environment | Where-Object { $_.StartsWith("POSTGRES_DB=") } | Select-Object -First 1
if (-not $userLine -or -not $databaseLine) { throw "PostgreSQL bootstrap identity is unavailable" }
$user = $userLine.Substring("POSTGRES_USER=".Length)
$database = $databaseLine.Substring("POSTGRES_DB=".Length)
$previousErrorAction = $ErrorActionPreference
$ErrorActionPreference = "Continue"
$denied = "SET ROLE continuity_role; INSERT INTO work.tasks (task_id, goal_id, scope_id, revision) VALUES ('acl-negative-probe', 'goal', 'scope', 1);" | docker --context $DockerContext exec -i $PostgresContainer psql -U $user -d $database -v ON_ERROR_STOP=1 2>&1
$deniedExitCode = $LASTEXITCODE
$ErrorActionPreference = $previousErrorAction
if ($deniedExitCode -eq 0) { throw "cross-owner write unexpectedly succeeded" }
"SET ROLE work_role; SELECT count(*) FROM work.tasks;" | docker --context $DockerContext exec -i $PostgresContainer psql -U $user -d $database -v ON_ERROR_STOP=1 | Out-Null
if ($LASTEXITCODE -ne 0) { throw "owner-local read failed" }
Write-Output "INV-OWN-001 owner ACL verification: PASS"
+39
View File
@@ -0,0 +1,39 @@
package prospective_memory_test
import (
"errors"
"testing"
"git.cin.su/m/Assistant/contracts/authority"
contract "git.cin.su/m/Assistant/contracts/continuity"
"git.cin.su/m/Assistant/contracts/identity"
"git.cin.su/m/Assistant/contracts/work"
"git.cin.su/m/Assistant/modules/continuity/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestWS002SurvivesSchedulerLossAndRevalidatesBeforeDelivery(t *testing.T) {
item := contract.ProspectiveItem{ID: contract.ProspectiveItemID(ids.ID("reminder")), CommitmentID: contract.CommitmentID(ids.ID("commitment")), OwnerPrincipalID: identity.PrincipalID(ids.ID("creator")), ScopeID: authority.ScopeID(ids.ID("global")), GoalID: work.GoalID(ids.ID("goal")), TriggerAtUnixMillis: 1_800_000_000_000, State: contract.ProspectiveArmed, Revision: 1}
store := domain.Recover([]contract.ProspectiveItem{item})
// Scheduler state is discarded; only the canonical snapshot reconstructs work.
recovered := domain.Recover(store.Snapshot())
triggered, err := recovered.Trigger(item.ID, 1)
if err != nil {
t.Fatal(err)
}
if _, err := recovered.Trigger(item.ID, 1); !errors.Is(err, domain.ErrProspectiveRevision) {
t.Fatalf("duplicate trigger error = %v, want revision conflict", err)
}
revalidating, err := recovered.BeginRevalidation(item.ID, triggered.Revision)
if err != nil {
t.Fatal(err)
}
suppressed, err := recovered.FinishRevalidation(item.ID, revalidating.Revision, false)
if err != nil {
t.Fatal(err)
}
if suppressed.State != contract.ProspectiveSuppressed {
t.Fatalf("state = %s, want SUPPRESSED", suppressed.State)
}
}
@@ -0,0 +1,32 @@
package semantic_evolution_test
import (
"errors"
"testing"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/modules/capability/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestHistoricalV1HealthRemainsExplicitlyInterpretable(t *testing.T) {
historical := capability.Health{CapabilityID: capability.CapabilityID(ids.ID("historical")), State: capability.HealthDegraded, Reason: capability.ReasonCognitiveProvidersUnavailable, Revision: 1, SemanticVersion: capability.HealthV1}
if err := domain.ValidateHealth(historical); err != nil {
t.Fatalf("historical V1 health rejected: %v", err)
}
if historical.ObservedAtUnixMillis != nil {
t.Fatal("V1 must preserve the absence of V2 observation time")
}
}
func TestV2RequiresObservationTimeAndRejectsUnknownVersion(t *testing.T) {
observed := int64(1720000000000)
v2 := capability.Health{CapabilityID: capability.CapabilityID(ids.ID("current")), State: capability.HealthAvailable, Reason: capability.ReasonNone, Revision: 2, SemanticVersion: capability.HealthV2, ObservedAtUnixMillis: &observed}
if err := domain.ValidateHealth(v2); err != nil {
t.Fatalf("V2 health rejected: %v", err)
}
v2.SemanticVersion = 3
if err := domain.ValidateHealth(v2); !errors.Is(err, domain.ErrUnsupportedHealthVersion) {
t.Fatalf("unknown version error = %v", err)
}
}
+23
View File
@@ -0,0 +1,23 @@
package topology_equivalence_test
import (
"encoding/json"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"git.cin.su/m/Assistant/platform/ids"
"testing"
)
func TestWS004UnknownOutcomeSurvivesSerialization(t *testing.T) {
attempt := commitcontract.ActionAttempt{ID: commitcontract.ActionAttemptID(ids.ID("attempt")), AuthorizedID: commitcontract.AuthorizedActionID(ids.ID("authorized")), IntentID: commitcontract.ActionIntentID(ids.ID("intent")), State: commitcontract.ActionUnknownOutcome}
raw, err := json.Marshal(attempt)
if err != nil {
t.Fatal(err)
}
var restored commitcontract.ActionAttempt
if err := json.Unmarshal(raw, &restored); err != nil {
t.Fatal(err)
}
if restored != attempt || restored.State != commitcontract.ActionUnknownOutcome {
t.Fatalf("semantic state changed: %#v", restored)
}
}
+36
View File
@@ -0,0 +1,36 @@
package topology_equivalence_test
import (
"encoding/json"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/identity"
situationcontract "git.cin.su/m/Assistant/contracts/situation"
"git.cin.su/m/Assistant/contracts/work"
situation "git.cin.su/m/Assistant/modules/situation/domain"
"git.cin.su/m/Assistant/platform/ids"
"testing"
)
func TestWS004FocusContractSurvivesSerialization(t *testing.T) {
binding := situationcontract.FocusBinding{ID: situationcontract.FocusBindingID(ids.ID("focus")), ActorID: identity.ActorID(ids.ID("actor")), SessionID: situationcontract.SessionID(ids.ID("session")), Workspace: situationcontract.WorkspaceID(ids.ID("workspace")), ProjectID: situationcontract.ProjectID(ids.ID("project")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: authority.ScopeID(ids.ID("scope")), Active: true}
runtime := situationcontract.RuntimeBinding{SessionID: binding.SessionID, Workspace: binding.Workspace}
direct, err := situation.NewResolver([]situationcontract.FocusBinding{binding}).Resolve(runtime)
if err != nil {
t.Fatal(err)
}
encoded, err := json.Marshal([]situationcontract.FocusBinding{binding})
if err != nil {
t.Fatal(err)
}
var remote []situationcontract.FocusBinding
if err := json.Unmarshal(encoded, &remote); err != nil {
t.Fatal(err)
}
extracted, err := situation.NewResolver(remote).Resolve(runtime)
if err != nil {
t.Fatal(err)
}
if direct != extracted {
t.Fatalf("topology changed focus: %#v != %#v", direct, extracted)
}
}
@@ -0,0 +1,81 @@
param([string]$DockerContext = "docker-prod")
$ErrorActionPreference = "Stop"
function Post-Json([string]$container, [string]$url, [object]$body) {
$json = $body | ConvertTo-Json -Depth 8 -Compress
$local = New-TemporaryFile
$remote = "/tmp/domovoy-$([guid]::NewGuid().ToString('N')).json"
try {
[IO.File]::WriteAllText($local, $json, [Text.UTF8Encoding]::new($false))
docker --context $DockerContext cp $local "${container}:$remote" | Out-Null
docker --context $DockerContext exec $container wget -qO- --header "Content-Type: application/json" --post-file $remote $url
if ($LASTEXITCODE -ne 0) { throw "POST $url failed" }
} finally {
docker --context $DockerContext exec --user root $container rm -f $remote 2>$null
Remove-Item -LiteralPath $local -Force
}
}
function Expect-PostStatus([string]$container, [string]$url, [object]$body, [int]$status) {
$json = $body | ConvertTo-Json -Depth 8 -Compress
$local = New-TemporaryFile
$remote = "/tmp/domovoy-$([guid]::NewGuid().ToString('N')).json"
try {
[IO.File]::WriteAllText($local, $json, [Text.UTF8Encoding]::new($false))
docker --context $DockerContext cp $local "${container}:$remote" | Out-Null
$previous = $ErrorActionPreference
$ErrorActionPreference = "Continue"
$response = (docker --context $DockerContext exec $container wget -S -O /dev/null --header "Content-Type: application/json" --post-file $remote $url 2>&1) -join "`n"
$ErrorActionPreference = $previous
if (-not $response.Contains("$status")) { throw "POST $url did not return $status" }
} finally {
docker --context $DockerContext exec --user root $container rm -f $remote 2>$null
Remove-Item -LiteralPath $local -Force
}
}
$suffix = [guid]::NewGuid().ToString("N")
$scope = "domovoy-global-scope"
$goal = "goal-$suffix"
$task = "task-$suffix"
$session = "session-$suffix"
$workspace = "workspace-$suffix"
Post-Json assistant-core-runtime-1 http://localhost:8080/v1/focus-bindings @{
ID="focus-$suffix"; ActorID="domovoy-creator-actor"; SessionID=$session; Workspace=$workspace
ProjectID="project-$suffix"; GoalID=$goal; ScopeID=$scope; Active=$true
} | Out-Null
Post-Json assistant-core-runtime-1 http://localhost:8080/v1/tasks @{
TaskID=$task; GoalID=$goal; ScopeID=$scope; Revision=1
} | Out-Null
$wrongCommit = @{ SessionID=$session; Workspace=$workspace; Target=@{TaskID=$task;GoalID="wrong-$goal";ScopeID=$scope;Revision=1} }
Expect-PostStatus assistant-core-runtime-1 http://localhost:8080/v1/focus-task-commits $wrongCommit 409
$rightCommit = @{ SessionID=$session; Workspace=$workspace; Target=@{TaskID=$task;GoalID=$goal;ScopeID=$scope;Revision=1} }
$commitResult = Post-Json assistant-core-runtime-1 http://localhost:8080/v1/focus-task-commits $rightCommit
if (($commitResult | ConvertFrom-Json).Revision -ne 2) { throw "remote task revision did not advance" }
$prospectiveID = "prospective-$suffix"
Post-Json assistant-continuity-runtime-1 http://localhost:8081/v1/prospective-items @{
ID=$prospectiveID; CommitmentID="commitment-$suffix"; OwnerPrincipalID="domovoy-creator-principal"
ScopeID=$scope; GoalID=$goal; TriggerAtUnixMillis=1800000000000; State="ARMED"; Revision=1
} | Out-Null
docker --context $DockerContext restart assistant-continuity-runtime-1 | Out-Null
for ($attempt=0; $attempt -lt 15; $attempt++) {
$restored = docker --context $DockerContext exec assistant-continuity-runtime-1 wget -qO- "http://localhost:8081/v1/prospective-items/$prospectiveID" 2>$null
if ($LASTEXITCODE -eq 0) { break }
Start-Sleep -Seconds 2
}
if ($LASTEXITCODE -ne 0 -or $restored -notmatch $prospectiveID) { throw "prospective item did not survive restart" }
$intent = "intent-$suffix"
$authorized = "authorized-$suffix"
Post-Json assistant-commit-runtime-1 http://localhost:8082/v1/authorized-actions @{
Proposal=@{IntentID=$intent;ActorID="domovoy-creator-actor";CapabilityID="test-executor";Target=@{TaskID=$task;GoalID=$goal;ScopeID=$scope;Revision=2};Operation="test-idempotent-effect"}
AuthorizedID=$authorized;GrantID="domovoy-creator-grant";PrincipalID="domovoy-creator-principal"
} | Out-Null
Post-Json assistant-commit-runtime-1 http://localhost:8082/v1/action-attempts @{
ID="attempt-$suffix";AuthorizedID=$authorized;IntentID=$intent;State="UNKNOWN_OUTCOME"
} | Out-Null
Write-Output "WS-004 remote topology verification: PASS"
+5
View File
@@ -0,0 +1,5 @@
# Walking skeleton tests
Black-box semantic acceptance tests go here. They must test properties rather than implementation call sequences.
Initial scenario IDs are defined in `architecture/WALKING_SKELETON_SPEC.md`.
@@ -0,0 +1,84 @@
package walking_skeleton_test
import (
"errors"
"testing"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/identity"
situationcontract "git.cin.su/m/Assistant/contracts/situation"
workcontract "git.cin.su/m/Assistant/contracts/work"
situation "git.cin.su/m/Assistant/modules/situation/domain"
work "git.cin.su/m/Assistant/modules/work/domain"
"git.cin.su/m/Assistant/platform/ids"
)
func TestWS001FocusIsolationPreventsWrongProjectMutation(t *testing.T) {
actor := identity.ActorID(ids.ID("actor"))
scope := authority.ScopeID(ids.ID("scope"))
project := situationcontract.ProjectID(ids.ID("same-repository"))
goalA := workcontract.GoalID(ids.ID("goal-a"))
goalB := workcontract.GoalID(ids.ID("goal-b"))
bindings := []situationcontract.FocusBinding{
{ID: situationcontract.FocusBindingID(ids.ID("focus-a")), ActorID: actor, SessionID: situationcontract.SessionID(ids.ID("session-a")), Workspace: situationcontract.WorkspaceID(ids.ID("worktree-a")), ProjectID: project, GoalID: goalA, ScopeID: scope, Active: true},
{ID: situationcontract.FocusBindingID(ids.ID("focus-b")), ActorID: actor, SessionID: situationcontract.SessionID(ids.ID("session-b")), Workspace: situationcontract.WorkspaceID(ids.ID("worktree-b")), ProjectID: project, GoalID: goalB, ScopeID: scope, Active: true},
}
resolver := situation.NewResolver(bindings)
store := work.NewStore([]work.Task{
{ID: workcontract.TaskID(ids.ID("task-a")), GoalID: goalA, ScopeID: scope, Revision: 1},
{ID: workcontract.TaskID(ids.ID("task-b")), GoalID: goalB, ScopeID: scope, Revision: 1},
})
// The identical phrase is intentionally not supplied to resolution: runtime
// session/workspace bindings, including two worktrees of one repository,
// are the only project-selection inputs.
focusA, err := resolver.Resolve(situationcontract.RuntimeBinding{SessionID: bindings[0].SessionID, Workspace: bindings[0].Workspace})
if err != nil {
t.Fatal(err)
}
focusB, err := resolver.Resolve(situationcontract.RuntimeBinding{SessionID: bindings[1].SessionID, Workspace: bindings[1].Workspace})
if err != nil {
t.Fatal(err)
}
if focusA.GoalID == focusB.GoalID {
t.Fatal("two worktrees resolved to the same goal")
}
wrongTarget := workcontract.TaskTarget{TaskID: workcontract.TaskID(ids.ID("task-b")), GoalID: goalB, ScopeID: scope, Revision: 1}
if err := situation.ValidateTaskTarget(focusA, wrongTarget); !errors.Is(err, situation.ErrTargetMismatch) {
t.Fatalf("wrong cognition target error = %v, want ErrTargetMismatch", err)
}
targetA := workcontract.TaskTarget{TaskID: workcontract.TaskID(ids.ID("task-a")), GoalID: goalA, ScopeID: scope, Revision: 1}
if err := situation.ValidateTaskTarget(focusA, targetA); err != nil {
t.Fatal(err)
}
committed, err := store.Commit(targetA)
if err != nil {
t.Fatal(err)
}
if committed.Revision != 2 {
t.Fatalf("revision = %d, want 2", committed.Revision)
}
if _, err := store.Commit(targetA); !errors.Is(err, work.ErrRevisionConflict) {
t.Fatalf("stale revision error = %v, want ErrRevisionConflict", err)
}
if _, err := store.Commit(wrongTarget); err != nil {
t.Fatalf("other context must retain its original revision: %v", err)
}
}
func TestWS001RejectsStaleAndAmbiguousFocusWithoutMutation(t *testing.T) {
runtime := situationcontract.RuntimeBinding{SessionID: situationcontract.SessionID(ids.ID("session")), Workspace: situationcontract.WorkspaceID(ids.ID("workspace"))}
stale := situation.NewResolver([]situationcontract.FocusBinding{{SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: false}})
if _, err := stale.Resolve(runtime); !errors.Is(err, situation.ErrStaleFocus) {
t.Fatalf("stale error = %v, want ErrStaleFocus", err)
}
ambiguous := situation.NewResolver([]situationcontract.FocusBinding{
{ID: situationcontract.FocusBindingID(ids.ID("one")), SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: true},
{ID: situationcontract.FocusBindingID(ids.ID("two")), SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: true},
})
if _, err := ambiguous.Resolve(runtime); !errors.Is(err, situation.ErrAmbiguousFocus) {
t.Fatalf("ambiguity error = %v, want ErrAmbiguousFocus", err)
}
}