feat(work): link task evaluation worker execution

docs: record gpu adapter invocation qualification

adapters/models/openai_compatible_local.go

@@ -96,11 +96,15 @@ func (a *OpenAICompatibleLocalAdapter) Discover(ctx context.Context) ([]Discover
 }
 
 type compatibleChatRequest struct {
-	Model       string              `json:"model"`
-	Messages    []compatibleMessage `json:"messages"`
-	Temperature int                 `json:"temperature"`
-	Stream      bool                `json:"stream"`
-	MaxTokens   int                 `json:"max_tokens"`
+	Model              string                   `json:"model"`
+	Messages           []compatibleMessage      `json:"messages"`
+	Temperature        int                      `json:"temperature"`
+	Stream             bool                     `json:"stream"`
+	MaxTokens          int                      `json:"max_tokens"`
+	ChatTemplateKwargs compatibleTemplateKwargs `json:"chat_template_kwargs"`
+}
+type compatibleTemplateKwargs struct {
+	EnableThinking bool `json:"enable_thinking"`
 }
 type compatibleMessage struct {
 	Role    string `json:"role"`
@@ -121,7 +125,7 @@ func (a *OpenAICompatibleLocalAdapter) Advise(ctx context.Context, request cogni
 	if err := ValidateAdvisoryRequest(request); err != nil || request.ProviderModelID == "" || len(request.Context) != 0 {
 		return cognitive.AdvisoryResponse{}, ErrInvalidAdvisory
 	}
-	payload := compatibleChatRequest{Model: string(request.ProviderModelID), Messages: []compatibleMessage{{Role: "system", Content: "Provide non-canonical advisory text only. Never claim that an action occurred."}, {Role: "user", Content: request.Message}}, Temperature: 0, Stream: false, MaxTokens: request.MaxOutputBytes / 4}
+	payload := compatibleChatRequest{Model: string(request.ProviderModelID), Messages: []compatibleMessage{{Role: "system", Content: "Provide non-canonical advisory text only. Never claim that an action occurred."}, {Role: "user", Content: request.Message}}, Temperature: 0, Stream: false, MaxTokens: request.MaxOutputBytes / 4, ChatTemplateKwargs: compatibleTemplateKwargs{EnableThinking: false}}
 	var result compatibleChatResponse
 	status, err := a.requestJSON(ctx, http.MethodPost, "/chat/completions", payload, &result)
 	if err != nil {

adapters/models/openai_compatible_local_test.go

@@ -2,15 +2,20 @@ package models
 
 import (
 	"context"
+	"encoding/json"
 	"io"
 	"net/http"
 	"strings"
 	"testing"
 	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/cognitive"
 )
 
 type captureRoundTripper struct {
 	authorization string
+	body          []byte
 }
 
 func TestOpenAICompatibleLocalAdapterUsesConfiguredTimeout(t *testing.T) {
@@ -31,7 +36,14 @@ func TestOpenAICompatibleLocalAdapterRejectsNonPositiveTimeout(t *testing.T) {
 
 func (t *captureRoundTripper) RoundTrip(request *http.Request) (*http.Response, error) {
 	t.authorization = request.Header.Get("Authorization")
-	return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(`{"data":[]}`)), Header: make(http.Header), Request: request}, nil
+	if request.Body != nil {
+		t.body, _ = io.ReadAll(request.Body)
+	}
+	body := `{"data":[]}`
+	if strings.HasSuffix(request.URL.Path, "/chat/completions") {
+		body = `{"choices":[{"finish_reason":"stop","message":{"role":"assistant","content":"ok"}}],"usage":{"prompt_tokens":1,"completion_tokens":1}}`
+	}
+	return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(body)), Header: make(http.Header), Request: request}, nil
 }
 
 func TestOpenAICompatibleLocalAdapterUsesResolvedAPIKey(t *testing.T) {
@@ -57,3 +69,26 @@ func TestOpenAICompatibleLocalAdapterDoesNotSendAuthorizationWithoutKey(t *testi
 		t.Fatalf("unexpected authorization header")
 	}
 }
+
+func TestOpenAICompatibleLocalAdapterDisablesTemplateThinkingForBoundedAdvisory(t *testing.T) {
+	transport := &captureRoundTripper{}
+	adapter, err := NewOpenAICompatibleLocalAdapter("http://gateway/v1", transport)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = adapter.Advise(context.Background(), cognitive.AdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: "request-1", ActorID: "actor", PrincipalID: "principal", ScopeID: "scope", Message: "help", Locale: "ru-RU", MaxOutputBytes: 256, ProviderBindingID: "binding-1", ProviderBindingRevision: 1, ProviderInstanceID: "provider-1", ModelDescriptorID: "model-1", ProviderModelID: capability.ProviderModelID("medium-model")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var payload struct {
+		ChatTemplateKwargs struct {
+			EnableThinking bool `json:"enable_thinking"`
+		} `json:"chat_template_kwargs"`
+	}
+	if err := json.Unmarshal(transport.body, &payload); err != nil {
+		t.Fatal(err)
+	}
+	if payload.ChatTemplateKwargs.EnableThinking {
+		t.Fatal("expected bounded advisory to disable template thinking")
+	}
+}

adapters/postgres/capability_repository.go

@@ -430,6 +430,32 @@ func (r *CapabilityRepository) SaveCognitiveBinding(ctx context.Context, value c
 }
 
 func (r *CapabilityRepository) LoadCognitiveCandidates(ctx context.Context, capabilityID capability.CapabilityID, owner identity.PrincipalID) ([]capability.ResolvedCognitiveBinding, error) {
+	return r.loadCognitiveCandidates(ctx, capabilityID, owner, "")
+}
+
+func (r *CapabilityRepository) LoadCognitiveCandidatesForProfile(ctx context.Context, capabilityID capability.CapabilityID, owner identity.PrincipalID, profileID capability.TaskEvaluationProfileID) ([]capability.ResolvedCognitiveBinding, error) {
+	return r.loadCognitiveCandidates(ctx, capabilityID, owner, profileID)
+}
+
+func (r *CapabilityRepository) LoadCognitiveCandidate(ctx context.Context, bindingID capability.CapabilityBindingID, revision int64) (capability.ResolvedCognitiveBinding, error) {
+	var capabilityID capability.CapabilityID
+	var owner identity.PrincipalID
+	if err := r.pool.QueryRow(ctx, `SELECT capability_id,owner_principal_id FROM capability.cognitive_bindings WHERE binding_id=$1 AND revision=$2`, bindingID, revision).Scan(&capabilityID, &owner); err != nil {
+		return capability.ResolvedCognitiveBinding{}, err
+	}
+	candidates, err := r.loadCognitiveCandidates(ctx, capabilityID, owner, "")
+	if err != nil {
+		return capability.ResolvedCognitiveBinding{}, err
+	}
+	for _, candidate := range candidates {
+		if candidate.Binding.ID == bindingID && candidate.Binding.Revision == revision {
+			return candidate, nil
+		}
+	}
+	return capability.ResolvedCognitiveBinding{}, pgx.ErrNoRows
+}
+
+func (r *CapabilityRepository) loadCognitiveCandidates(ctx context.Context, capabilityID capability.CapabilityID, owner identity.PrincipalID, profileID capability.TaskEvaluationProfileID) ([]capability.ResolvedCognitiveBinding, error) {
 	rows, err := r.pool.Query(ctx, `SELECT
 		b.binding_id,b.revision,b.capability_id,b.owner_principal_id,b.provider_instance_id,b.provider_revision,b.model_descriptor_id,b.model_revision,b.data_policy,b.qualification,b.activation,b.health,b.limit_policy_ref,
 		p.provider_instance_id,p.revision,p.provider_kind,p.endpoint_ref,COALESCE(p.credential_ref,''),p.enabled,p.qualification,COALESCE(ph.health,p.health),GREATEST(p.observed_at_unix_millis,COALESCE(ph.observed_at_unix_millis,0)),p.billing_mode,p.auth_mode,p.input_cost_micros,p.output_cost_micros,p.request_cost_micros,
@@ -454,7 +480,7 @@ func (r *CapabilityRepository) LoadCognitiveCandidates(ctx context.Context, capa
 		if err != nil {
 			return nil, err
 		}
-		if err = r.loadCognitiveEvidence(ctx, &value); err != nil {
+		if err = r.loadCognitiveEvidence(ctx, &value, profileID); err != nil {
 			return nil, err
 		}
 		result = append(result, value)
@@ -462,7 +488,7 @@ func (r *CapabilityRepository) LoadCognitiveCandidates(ctx context.Context, capa
 	return result, rows.Err()
 }
 
-func (r *CapabilityRepository) loadCognitiveEvidence(ctx context.Context, value *capability.ResolvedCognitiveBinding) error {
+func (r *CapabilityRepository) loadCognitiveEvidence(ctx context.Context, value *capability.ResolvedCognitiveBinding, profileID capability.TaskEvaluationProfileID) error {
 	var evaluation capability.EvaluatedCapability
 	err := r.pool.QueryRow(ctx, `SELECT evaluation_id,binding_id,binding_revision,capability_id,result,quality_score_millis,critical_failure_millis,benchmark_version,artifact_id,observed_at_unix_millis FROM capability.cognitive_evaluated_capabilities WHERE binding_id=$1 AND binding_revision=$2 ORDER BY observed_at_unix_millis DESC LIMIT 1`, value.Binding.ID, value.Binding.Revision).Scan(&evaluation.ID, &evaluation.BindingID, &evaluation.BindingRevision, &evaluation.CapabilityID, &evaluation.Result, &evaluation.QualityScoreMillis, &evaluation.CriticalFailureMillis, &evaluation.BenchmarkVersion, &evaluation.ArtifactID, &evaluation.ObservedAtUnixMillis)
 	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
@@ -479,6 +505,16 @@ func (r *CapabilityRepository) loadCognitiveEvidence(ctx context.Context, value
 	if err == nil {
 		value.Performance = &performance
 	}
+	if profileID != "" {
+		var taskEvaluation capability.TaskEvaluation
+		err = r.pool.QueryRow(ctx, `SELECT evaluation_id,task_profile_id,binding_id,binding_revision,capability_id,result,quality_score_millis,reliability_score_millis,latency_score_millis,overall_score_millis,critical_failure_millis,benchmark_version,artifact_id,observed_at_unix_millis FROM capability.cognitive_task_evaluations WHERE task_profile_id=$1 AND binding_id=$2 AND binding_revision=$3 ORDER BY observed_at_unix_millis DESC LIMIT 1`, profileID, value.Binding.ID, value.Binding.Revision).Scan(&taskEvaluation.ID, &taskEvaluation.ProfileID, &taskEvaluation.BindingID, &taskEvaluation.BindingRevision, &taskEvaluation.CapabilityID, &taskEvaluation.Result, &taskEvaluation.QualityScoreMillis, &taskEvaluation.ReliabilityScoreMillis, &taskEvaluation.LatencyScoreMillis, &taskEvaluation.OverallScoreMillis, &taskEvaluation.CriticalFailureMillis, &taskEvaluation.BenchmarkVersion, &taskEvaluation.ArtifactID, &taskEvaluation.ObservedAtUnixMillis)
+		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+			return err
+		}
+		if err == nil {
+			value.TaskEvaluation = &taskEvaluation
+		}
+	}
 	return nil
 }
 
@@ -592,3 +628,8 @@ func (r *CapabilityRepository) SavePerformanceEvidence(ctx context.Context, valu
 	_, err := r.pool.Exec(ctx, `INSERT INTO capability.cognitive_performance_evidence (evidence_id,binding_id,binding_revision,model_descriptor_id,model_revision,hardware_profile,runtime,quantization,context_units,thinking_enabled,generation_tps_millis,prompt_tps_millis,ttft_micros,latency_micros,memory_bytes,reliability_millis,benchmark_version,artifact_id,observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19) ON CONFLICT DO NOTHING`, value.ID, value.BindingID, value.BindingRevision, value.ModelDescriptorID, value.ModelRevision, value.HardwareProfile, value.Runtime, value.Quantization, value.ContextUnits, value.ThinkingEnabled, value.GenerationTPSMillis, value.PromptTPSMillis, value.TTFTMicros, value.LatencyMicros, value.MemoryBytes, value.ReliabilityMillis, value.BenchmarkVersion, value.ArtifactID, value.ObservedAtUnixMillis)
 	return err
 }
+
+func (r *CapabilityRepository) SaveTaskEvaluation(ctx context.Context, value capability.TaskEvaluation) error {
+	_, err := r.pool.Exec(ctx, `INSERT INTO capability.cognitive_task_evaluations (evaluation_id,task_profile_id,binding_id,binding_revision,capability_id,result,quality_score_millis,reliability_score_millis,latency_score_millis,overall_score_millis,critical_failure_millis,benchmark_version,artifact_id,observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`, value.ID, value.ProfileID, value.BindingID, value.BindingRevision, value.CapabilityID, value.Result, value.QualityScoreMillis, value.ReliabilityScoreMillis, value.LatencyScoreMillis, value.OverallScoreMillis, value.CriticalFailureMillis, value.BenchmarkVersion, value.ArtifactID, value.ObservedAtUnixMillis)
+	return err
+}

adapters/postgres/work_repository.go

@@ -2,10 +2,14 @@ package postgres
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
+	"reflect"
+	"slices"
 	"time"
 
+	"git.cin.su/m/Assistant/contracts/capability"
 	"git.cin.su/m/Assistant/contracts/work"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -14,9 +18,10 @@ import (
 type WorkRepository struct{ pool *pgxpool.Pool }
 
 var (
-	ErrDispatchIntentConflict = errors.New("dispatch intent idempotency conflict")
-	ErrAgentLeaseUnavailable  = errors.New("agent lease unavailable")
-	ErrAgentCallbackRejected  = errors.New("agent callback rejected")
+	ErrDispatchIntentConflict  = errors.New("dispatch intent idempotency conflict")
+	ErrAgentLeaseUnavailable   = errors.New("agent lease unavailable")
+	ErrAgentCallbackRejected   = errors.New("agent callback rejected")
+	ErrDevelopmentGateConflict = errors.New("development gate revision conflict")
 )
 
 func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, error) {
@@ -49,33 +54,113 @@ func (r *WorkRepository) Load(ctx context.Context, id work.TaskID) (work.TaskTar
 	return target, nil
 }
 
+func (r *WorkRepository) LoadDevelopmentGate(ctx context.Context, id string) (work.DevelopmentGate, error) {
+	var gate work.DevelopmentGate
+	var evidence, producer, verifier []string
+	err := r.pool.QueryRow(ctx, `SELECT gate_id,revision,updated_at_unix_millis,stage,evidence_refs,proposal_ref,task_packet_ref,worktree_ref,producer_run_refs,verifier_run_refs,verification_evidence,canary_evidence,promotion_ref,rollback_ref FROM work.development_gates WHERE gate_id=$1`, id).Scan(
+		&gate.ID, &gate.Revision, &gate.UpdatedAtUnixMillis, &gate.Stage, &evidence, &gate.ProposalRef, &gate.TaskPacketRef, &gate.WorktreeRef, &producer, &verifier, &gate.VerificationEvidence, &gate.CanaryEvidence, &gate.PromotionRef, &gate.RollbackRef)
+	if err != nil {
+		return work.DevelopmentGate{}, fmt.Errorf("load development gate: %w", err)
+	}
+	gate.EvidenceRefs = append([]string(nil), evidence...)
+	for _, run := range producer {
+		gate.ProducerRunRefs = append(gate.ProducerRunRefs, work.AgentRunID(run))
+	}
+	for _, run := range verifier {
+		gate.VerifierRunRefs = append(gate.VerifierRunRefs, work.AgentRunID(run))
+	}
+	return gate, nil
+}
+
+func (r *WorkRepository) SaveDevelopmentGate(ctx context.Context, gate work.DevelopmentGate, expectedRevision int64) error {
+	if gate.ID == "" || expectedRevision < 0 || gate.Revision < 1 || gate.UpdatedAtUnixMillis < 1 {
+		return ErrDevelopmentGateConflict
+	}
+	producer := make([]string, 0, len(gate.ProducerRunRefs))
+	for _, run := range gate.ProducerRunRefs {
+		producer = append(producer, string(run))
+	}
+	verifier := make([]string, 0, len(gate.VerifierRunRefs))
+	for _, run := range gate.VerifierRunRefs {
+		verifier = append(verifier, string(run))
+	}
+	if expectedRevision == 0 {
+		command, err := r.pool.Exec(ctx, `INSERT INTO work.development_gates(gate_id,revision,updated_at_unix_millis,stage,evidence_refs,proposal_ref,task_packet_ref,worktree_ref,producer_run_refs,verifier_run_refs,verification_evidence,canary_evidence,promotion_ref,rollback_ref) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT(gate_id) DO NOTHING`, gate.ID, gate.Revision, gate.UpdatedAtUnixMillis, gate.Stage, gate.EvidenceRefs, gate.ProposalRef, gate.TaskPacketRef, gate.WorktreeRef, producer, verifier, gate.VerificationEvidence, gate.CanaryEvidence, gate.PromotionRef, gate.RollbackRef)
+		if err != nil {
+			return err
+		}
+		if command.RowsAffected() != 1 {
+			return ErrDevelopmentGateConflict
+		}
+		return nil
+	}
+	command, err := r.pool.Exec(ctx, `UPDATE work.development_gates SET revision=$1,updated_at_unix_millis=$2,stage=$3,evidence_refs=$4,proposal_ref=$5,task_packet_ref=$6,worktree_ref=$7,producer_run_refs=$8,verifier_run_refs=$9,verification_evidence=$10,canary_evidence=$11,promotion_ref=$12,rollback_ref=$13 WHERE gate_id=$14 AND revision=$15`, gate.Revision, gate.UpdatedAtUnixMillis, gate.Stage, gate.EvidenceRefs, gate.ProposalRef, gate.TaskPacketRef, gate.WorktreeRef, producer, verifier, gate.VerificationEvidence, gate.CanaryEvidence, gate.PromotionRef, gate.RollbackRef, gate.ID, expectedRevision)
+	if err != nil {
+		return err
+	}
+	if command.RowsAffected() != 1 {
+		return ErrDevelopmentGateConflict
+	}
+	return nil
+}
+
 func (r *WorkRepository) SaveDispatchIntent(ctx context.Context, intent work.AgentDispatchIntent) error {
 	tx, err := r.pool.Begin(ctx)
 	if err != nil {
 		return err
 	}
 	defer tx.Rollback(ctx)
-	_, err = tx.Exec(ctx, `INSERT INTO work.agent_dispatch_intents(dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(idempotency_key) DO NOTHING`, intent.DispatchID, intent.IdempotencyKey, intent.DelegationID, intent.RunID, intent.ImplementationID, intent.ImplementationRevision, intent.SourceRevision, intent.WorktreeID, intent.VerificationPlanRef, intent.CreatedAtUnixMillis)
+	profileJSON, casesJSON, err := marshalTaskPayload(intent.TaskEvaluationProfile, intent.TaskEvaluationCases)
+	if err != nil {
+		return err
+	}
+	executionJSON, err := json.Marshal(intent.TaskEvaluationExecution)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(ctx, `INSERT INTO work.agent_dispatch_intents(dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis,specialist_purpose,task_evaluation_profile_id,task_evaluation_binding_id,task_evaluation_case_ids,task_evaluation_profile,task_evaluation_cases,task_evaluation_execution) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17) ON CONFLICT(idempotency_key) DO NOTHING`, intent.DispatchID, intent.IdempotencyKey, intent.DelegationID, intent.RunID, intent.ImplementationID, intent.ImplementationRevision, intent.SourceRevision, intent.WorktreeID, intent.VerificationPlanRef, intent.CreatedAtUnixMillis, intent.SpecialistPurpose, intent.TaskEvaluationProfileID, intent.TaskEvaluationBindingID, intent.TaskEvaluationCaseIDs, profileJSON, casesJSON, executionJSON)
 	if err != nil {
 		return fmt.Errorf("save dispatch intent: %w", err)
 	}
 	var existing work.AgentDispatchIntent
-	err = tx.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis FROM work.agent_dispatch_intents WHERE idempotency_key=$1`, intent.IdempotencyKey).Scan(&existing.DispatchID, &existing.IdempotencyKey, &existing.DelegationID, &existing.RunID, &existing.ImplementationID, &existing.ImplementationRevision, &existing.SourceRevision, &existing.WorktreeID, &existing.VerificationPlanRef, &existing.CreatedAtUnixMillis)
+	var profileJSONExisting, casesJSONExisting, executionJSONExisting []byte
+	err = tx.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis,specialist_purpose,task_evaluation_profile_id,task_evaluation_binding_id,task_evaluation_case_ids,task_evaluation_profile,task_evaluation_cases,task_evaluation_execution FROM work.agent_dispatch_intents WHERE idempotency_key=$1`, intent.IdempotencyKey).Scan(&existing.DispatchID, &existing.IdempotencyKey, &existing.DelegationID, &existing.RunID, &existing.ImplementationID, &existing.ImplementationRevision, &existing.SourceRevision, &existing.WorktreeID, &existing.VerificationPlanRef, &existing.CreatedAtUnixMillis, &existing.SpecialistPurpose, &existing.TaskEvaluationProfileID, &existing.TaskEvaluationBindingID, &existing.TaskEvaluationCaseIDs, &profileJSONExisting, &casesJSONExisting, &executionJSONExisting)
 	if err != nil {
 		return fmt.Errorf("read dispatch intent: %w", err)
 	}
-	if existing != intent {
+	if err := unmarshalTaskPayload(profileJSONExisting, casesJSONExisting, &existing.TaskEvaluationProfile, &existing.TaskEvaluationCases); err != nil {
+		return err
+	}
+	if len(executionJSONExisting) > 0 && string(executionJSONExisting) != "null" {
+		if err := json.Unmarshal(executionJSONExisting, &existing.TaskEvaluationExecution); err != nil {
+			return err
+		}
+	}
+	if !sameDispatchIntent(existing, intent) {
 		return ErrDispatchIntentConflict
 	}
 	return tx.Commit(ctx)
 }
 
+func sameDispatchIntent(left, right work.AgentDispatchIntent) bool {
+	return left.DispatchID == right.DispatchID && left.IdempotencyKey == right.IdempotencyKey && left.DelegationID == right.DelegationID && left.RunID == right.RunID && left.ImplementationID == right.ImplementationID && left.ImplementationRevision == right.ImplementationRevision && left.SourceRevision == right.SourceRevision && left.WorktreeID == right.WorktreeID && left.VerificationPlanRef == right.VerificationPlanRef && left.CreatedAtUnixMillis == right.CreatedAtUnixMillis && left.SpecialistPurpose == right.SpecialistPurpose && left.TaskEvaluationProfileID == right.TaskEvaluationProfileID && left.TaskEvaluationBindingID == right.TaskEvaluationBindingID && slices.Equal(left.TaskEvaluationCaseIDs, right.TaskEvaluationCaseIDs) && reflect.DeepEqual(left.TaskEvaluationProfile, right.TaskEvaluationProfile) && slices.Equal(left.TaskEvaluationCases, right.TaskEvaluationCases) && reflect.DeepEqual(left.TaskEvaluationExecution, right.TaskEvaluationExecution)
+}
+
 func (r *WorkRepository) LoadDispatchIntent(ctx context.Context, dispatchID string) (work.AgentDispatchIntent, error) {
 	var intent work.AgentDispatchIntent
-	err := r.pool.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis FROM work.agent_dispatch_intents WHERE dispatch_id=$1`, dispatchID).Scan(&intent.DispatchID, &intent.IdempotencyKey, &intent.DelegationID, &intent.RunID, &intent.ImplementationID, &intent.ImplementationRevision, &intent.SourceRevision, &intent.WorktreeID, &intent.VerificationPlanRef, &intent.CreatedAtUnixMillis)
+	var profileJSON, casesJSON, executionJSON []byte
+	err := r.pool.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis,specialist_purpose,task_evaluation_profile_id,task_evaluation_binding_id,task_evaluation_case_ids,task_evaluation_profile,task_evaluation_cases,task_evaluation_execution FROM work.agent_dispatch_intents WHERE dispatch_id=$1`, dispatchID).Scan(&intent.DispatchID, &intent.IdempotencyKey, &intent.DelegationID, &intent.RunID, &intent.ImplementationID, &intent.ImplementationRevision, &intent.SourceRevision, &intent.WorktreeID, &intent.VerificationPlanRef, &intent.CreatedAtUnixMillis, &intent.SpecialistPurpose, &intent.TaskEvaluationProfileID, &intent.TaskEvaluationBindingID, &intent.TaskEvaluationCaseIDs, &profileJSON, &casesJSON, &executionJSON)
 	if err != nil {
 		return work.AgentDispatchIntent{}, fmt.Errorf("load dispatch intent: %w", err)
 	}
+	if err := unmarshalTaskPayload(profileJSON, casesJSON, &intent.TaskEvaluationProfile, &intent.TaskEvaluationCases); err != nil {
+		return work.AgentDispatchIntent{}, err
+	}
+	if len(executionJSON) > 0 && string(executionJSON) != "null" {
+		if err := json.Unmarshal(executionJSON, &intent.TaskEvaluationExecution); err != nil {
+			return work.AgentDispatchIntent{}, err
+		}
+	}
 	return intent, nil
 }
 
@@ -140,11 +225,15 @@ func (r *WorkRepository) SaveWorkGraph(ctx context.Context, graph work.WorkGraph
 		return err
 	}
 	defer tx.Rollback(ctx)
-	if _, err := tx.Exec(ctx, `INSERT INTO work.graphs(graph_id,revision,state,max_parallel,max_attempts) VALUES($1,$2,$3,$4,$5) ON CONFLICT(graph_id,revision) DO NOTHING`, graph.ID, graph.Revision, graph.State, graph.Budget.MaxParallel, graph.Budget.MaxAttempts); err != nil {
+	if _, err := tx.Exec(ctx, `INSERT INTO work.graphs(graph_id,revision,state,max_parallel,max_attempts,parent_graph_id,parent_graph_revision,trigger_evidence_ref) VALUES($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(graph_id,revision) DO NOTHING`, graph.ID, graph.Revision, graph.State, graph.Budget.MaxParallel, graph.Budget.MaxAttempts, graph.ParentGraphID, graph.ParentGraphRevision, graph.TriggerEvidenceRef); err != nil {
 		return err
 	}
 	for _, node := range graph.Nodes {
-		if _, err := tx.Exec(ctx, `INSERT INTO work.graph_nodes(graph_id,revision,node_id,dispatch_id,idempotency_key,state,attempts) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(graph_id,revision,node_id) DO NOTHING`, graph.ID, graph.Revision, node.ID, node.DispatchID, node.IdempotencyKey, node.State, node.Attempts); err != nil {
+		profileJSON, casesJSON, err := marshalTaskPayload(node.TaskProfile, node.TaskCases)
+		if err != nil {
+			return err
+		}
+		if _, err := tx.Exec(ctx, `INSERT INTO work.graph_nodes(graph_id,revision,node_id,dispatch_id,idempotency_key,state,attempts,purpose,task_profile_id,binding_id,case_ids,task_evaluation_profile,task_evaluation_cases) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) ON CONFLICT(graph_id,revision,node_id) DO NOTHING`, graph.ID, graph.Revision, node.ID, node.DispatchID, node.IdempotencyKey, node.State, node.Attempts, node.Purpose, node.TaskProfileID, node.BindingID, node.CaseIDs, profileJSON, casesJSON); err != nil {
 			return err
 		}
 	}
@@ -158,17 +247,22 @@ func (r *WorkRepository) SaveWorkGraph(ctx context.Context, graph work.WorkGraph
 
 func (r *WorkRepository) LoadWorkGraph(ctx context.Context, graphID string, revision int64) (work.WorkGraph, error) {
 	var graph work.WorkGraph
-	err := r.pool.QueryRow(ctx, `SELECT graph_id,revision,state,max_parallel,max_attempts FROM work.graphs WHERE graph_id=$1 AND revision=$2`, graphID, revision).Scan(&graph.ID, &graph.Revision, &graph.State, &graph.Budget.MaxParallel, &graph.Budget.MaxAttempts)
+	err := r.pool.QueryRow(ctx, `SELECT graph_id,revision,state,max_parallel,max_attempts,parent_graph_id,parent_graph_revision,trigger_evidence_ref FROM work.graphs WHERE graph_id=$1 AND revision=$2`, graphID, revision).Scan(&graph.ID, &graph.Revision, &graph.State, &graph.Budget.MaxParallel, &graph.Budget.MaxAttempts, &graph.ParentGraphID, &graph.ParentGraphRevision, &graph.TriggerEvidenceRef)
 	if err != nil {
 		return work.WorkGraph{}, fmt.Errorf("load graph: %w", err)
 	}
-	rows, err := r.pool.Query(ctx, `SELECT node_id,dispatch_id,idempotency_key,state,attempts FROM work.graph_nodes WHERE graph_id=$1 AND revision=$2 ORDER BY node_id`, graphID, revision)
+	rows, err := r.pool.Query(ctx, `SELECT node_id,dispatch_id,idempotency_key,state,attempts,purpose,task_profile_id,binding_id,case_ids,task_evaluation_profile,task_evaluation_cases FROM work.graph_nodes WHERE graph_id=$1 AND revision=$2 ORDER BY node_id`, graphID, revision)
 	if err != nil {
 		return work.WorkGraph{}, err
 	}
 	for rows.Next() {
 		var node work.GraphNode
-		if err := rows.Scan(&node.ID, &node.DispatchID, &node.IdempotencyKey, &node.State, &node.Attempts); err != nil {
+		var profileJSON, casesJSON []byte
+		if err := rows.Scan(&node.ID, &node.DispatchID, &node.IdempotencyKey, &node.State, &node.Attempts, &node.Purpose, &node.TaskProfileID, &node.BindingID, &node.CaseIDs, &profileJSON, &casesJSON); err != nil {
+			rows.Close()
+			return work.WorkGraph{}, err
+		}
+		if err := unmarshalTaskPayload(profileJSON, casesJSON, &node.TaskProfile, &node.TaskCases); err != nil {
 			rows.Close()
 			return work.WorkGraph{}, err
 		}
@@ -514,3 +608,32 @@ func latestRowErr(err error) error {
 	}
 	return err
 }
+
+func marshalTaskPayload(profile *capability.TaskEvaluationProfile, cases []capability.TaskEvaluationCase) ([]byte, []byte, error) {
+	var profileJSON []byte
+	var err error
+	if profile != nil {
+		profileJSON, err = json.Marshal(profile)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	casesJSON, err := json.Marshal(cases)
+	return profileJSON, casesJSON, err
+}
+
+func unmarshalTaskPayload(profileJSON, casesJSON []byte, profile **capability.TaskEvaluationProfile, cases *[]capability.TaskEvaluationCase) error {
+	if len(profileJSON) > 0 && string(profileJSON) != "null" {
+		var value capability.TaskEvaluationProfile
+		if err := json.Unmarshal(profileJSON, &value); err != nil {
+			return err
+		}
+		*profile = &value
+	}
+	if len(casesJSON) > 0 && string(casesJSON) != "null" {
+		if err := json.Unmarshal(casesJSON, cases); err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/agent-canary/main.go

@@ -6,12 +6,16 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"
 	"time"
 
 	"git.cin.su/m/Assistant/adapters/postgres"
+	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
 	"git.cin.su/m/Assistant/contracts/work"
 	"git.cin.su/m/Assistant/modules/work/application"
 	"git.cin.su/m/Assistant/modules/work/ports"
+	platformsecrets "git.cin.su/m/Assistant/platform/secrets"
 )
 
 type memoryStore struct{ writes int }
@@ -30,14 +34,24 @@ func main() {
 	enabled := flag.Bool("enable-canary", false, "explicitly enable the manual canary")
 	implementation := flag.String("implementation", "fake-worker", "allowlisted deterministic implementation")
 	postgresMode := flag.Bool("postgres", false, "use the Work PostgreSQL repository instead of in-memory storage")
+	runID := flag.String("run-id", "", "optional unique canary run suffix; generated when omitted")
 	flag.Parse()
 
-	now := time.UnixMilli(1_700_000_000_000)
-	intent := work.AgentDispatchIntent{DispatchID: "manual-dispatch-1", IdempotencyKey: "manual-idempotency-1", DelegationID: "manual-delegation-1", RunID: "manual-run-1", ImplementationID: *implementation, ImplementationRevision: 1, SourceRevision: "manual-source-1", WorktreeID: "manual-worktree-1", VerificationPlanRef: "manual-verification-1", CreatedAtUnixMillis: now.UnixMilli()}
+	suffix := *runID
+	if suffix == "" {
+		suffix = fmt.Sprintf("%d", time.Now().UnixNano())
+	}
+	now := time.Now().UTC()
+	intent := work.AgentDispatchIntent{DispatchID: "manual-dispatch-" + suffix, IdempotencyKey: "manual-idempotency-" + suffix, DelegationID: work.DelegationID("manual-delegation-" + suffix), RunID: work.AgentRunID("manual-run-" + suffix), ImplementationID: *implementation, ImplementationRevision: 1, SourceRevision: "manual-source-" + suffix, WorktreeID: "manual-worktree-" + suffix, VerificationPlanRef: "manual-verification-" + suffix, CreatedAtUnixMillis: now.UnixMilli()}
 	var store ports.ExecutionStore = &memoryStore{}
 	var closeStore func()
 	if *postgresMode {
-		repository, err := postgres.OpenWork(context.Background(), postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: os.Getenv("WORK_POSTGRES_USER"), Password: os.Getenv("WORK_POSTGRES_PASSWORD")})
+		password, err := resolveDatabasePassword()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		repository, err := postgres.OpenWork(context.Background(), postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: os.Getenv("WORK_POSTGRES_USER"), Password: password})
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
@@ -67,3 +81,27 @@ func main() {
 		os.Exit(1)
 	}
 }
+
+func resolveDatabasePassword() (string, error) {
+	if _, ok := os.LookupEnv("WORK_POSTGRES_PASSWORD"); ok {
+		return "", fmt.Errorf("WORK_POSTGRES_PASSWORD direct environment secret is forbidden")
+	}
+	path, ref := os.Getenv("WORK_POSTGRES_PASSWORD_FILE"), os.Getenv("WORK_POSTGRES_CREDENTIAL_REF")
+	if path == "" || ref == "" {
+		return "", fmt.Errorf("WORK_POSTGRES_PASSWORD_FILE and WORK_POSTGRES_CREDENTIAL_REF are required")
+	}
+	root := os.Getenv("SECRET_BACKEND_ROOT")
+	if root == "" {
+		root = "/run/secrets"
+	}
+	cleanRoot := filepath.Clean(root)
+	cleanPath := filepath.Clean(path)
+	if cleanPath != cleanRoot && !strings.HasPrefix(cleanPath, cleanRoot+string(os.PathSeparator)) {
+		return "", fmt.Errorf("database password file escapes protected secret root")
+	}
+	resolver, err := platformsecrets.NewFileResolver(cleanRoot)
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeDatabasePassword, Consumer: secretcontracts.RuntimeConsumerWorkWorker, Path: cleanPath})
+}

cmd/agent-canary/main_test.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveDatabasePasswordRejectsDirectEnvironmentSecret(t *testing.T) {
+	t.Setenv("WORK_POSTGRES_PASSWORD", "literal-secret")
+	if _, err := resolveDatabasePassword(); err == nil {
+		t.Fatal("direct database password environment variable was accepted")
+	}
+}
+
+func TestResolveDatabasePasswordRejectsPathOutsideProtectedRoot(t *testing.T) {
+	root := t.TempDir()
+	t.Setenv("SECRET_BACKEND_ROOT", root)
+	t.Setenv("WORK_POSTGRES_PASSWORD_FILE", filepath.Join(root, "..", "outside"))
+	t.Setenv("WORK_POSTGRES_CREDENTIAL_REF", "credential://domovoy/work/db-password/v1")
+	if _, err := resolveDatabasePassword(); err == nil {
+		t.Fatal("database password path outside protected root was accepted")
+	}
+}

cmd/agent-worker/local_fallback.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+// localFallbackExecutor keeps the durable work path alive when no external
+// executor is reachable. It never claims that an external action happened.
+// The work owner records the WAITING callback and can retry after a bridge is
+// configured or a human chooses the next step.
+type localFallbackExecutor struct {
+	now func() time.Time
+}
+
+func newLocalFallbackExecutor() localFallbackExecutor {
+	return localFallbackExecutor{now: time.Now}
+}
+
+func (e localFallbackExecutor) Execute(_ context.Context, request work.AgentExecutionRequest) (work.AgentExecutionResult, error) {
+	now := time.Now()
+	if e.now != nil {
+		now = e.now()
+	}
+	return work.AgentExecutionResult{
+		State:                work.AgentExecutionWaiting,
+		Summary:              "Внешний Agent Execution Bridge недоступен; локальный fallback сохранил durable работу и ожидает исполнителя.",
+		ObservedAtUnixMillis: now.UnixMilli(),
+	}, nil
+}

cmd/agent-worker/local_fallback_test.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+func TestLocalFallbackNeverClaimsExternalExecution(t *testing.T) {
+	when := time.UnixMilli(1_700_000_000_000)
+	executor := localFallbackExecutor{now: func() time.Time { return when }}
+	result, err := executor.Execute(context.Background(), work.AgentExecutionRequest{Intent: work.AgentDispatchIntent{DispatchID: "dispatch-1"}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.State != work.AgentExecutionWaiting || result.ObservedAtUnixMillis != when.UnixMilli() {
+		t.Fatalf("unexpected fallback result: %+v", result)
+	}
+	if result.OutcomeRef != "" || result.Summary == "" {
+		t.Fatalf("fallback must not claim an outcome: %+v", result)
+	}
+}

cmd/agent-worker/main.go

@@ -41,6 +41,7 @@ func main() {
 	}
 	defer repository.Close()
 	var executor ports.AgentExecutor
+	localFallback := false
 	if bridgeURL, bridgeConfigured := loadProtectedBridgeURL(); bridgeConfigured {
 		executor, err = agentbridge.NewHTTPExecutor(bridgeURL, &http.Client{Timeout: *leaseTTL})
 		if err != nil {
@@ -48,10 +49,11 @@ func main() {
 			os.Exit(1)
 		}
 	} else {
-		fmt.Fprintln(os.Stderr, "protected agent execution bridge URL is not configured; dispatch claims are disabled; recovery-only mode")
+		executor = newTaskEvaluationExecutor(envOr("COGNITIVE_WORKER_URL", "http://cognitive-worker:8083"), envOr("WORK_GRAPH_RUNTIME_URL", "http://work-graph-runtime:8088"), &http.Client{Timeout: *leaseTTL})
+		fmt.Fprintln(os.Stderr, "protected agent execution bridge URL is not configured; task evaluations use the local durable evaluator, other work remains in fallback")
 	}
 	go func() {
-		if serveErr := http.ListenAndServe(*statusAddr, workerStatusHandler(executor != nil)); serveErr != nil {
+		if serveErr := http.ListenAndServe(*statusAddr, workerStatusHandler(executor != nil && !localFallback, localFallback)); serveErr != nil {
 			fmt.Fprintln(os.Stderr, "agent worker status server:", serveErr)
 		}
 	}()
@@ -104,6 +106,13 @@ func loadProtectedBridgeURLFrom(root, path string) (string, bool) {
 	return value, true
 }
 
+func envOr(name, fallback string) string {
+	if value := strings.TrimSpace(os.Getenv(name)); value != "" {
+		return value
+	}
+	return fallback
+}
+
 func resolveDatabasePassword(name, refName string, consumer secretcontracts.RuntimeConsumer) (string, error) {
 	if _, ok := os.LookupEnv(name); ok {
 		return "", fmt.Errorf("%s direct environment secret is forbidden", name)

cmd/agent-worker/status.go

@@ -11,15 +11,22 @@ type workerStatusResponse struct {
 	Mode               string `json:"mode"`
 	Ready              bool   `json:"ready"`
 	Reason             string `json:"reason"`
+	LocalFallback      bool   `json:"local_fallback"`
 }
 
-func workerStatusHandler(executorConfigured bool) http.Handler {
+func workerStatusHandler(executorConfigured bool, localFallback ...bool) http.Handler {
+	local := len(localFallback) > 0 && localFallback[0]
 	status := workerStatusResponse{
 		Runtime:            "agent-worker",
 		ExecutorConfigured: executorConfigured,
 		Mode:               "recovery-only",
 		Ready:              false,
 		Reason:             "protected agent execution bridge URL is not configured",
+		LocalFallback:      local,
+	}
+	if local {
+		status.Mode = "local-fallback"
+		status.Reason = "external bridge unavailable; durable work is retained without external mutation"
 	}
 	if executorConfigured {
 		status.Mode = "execution"

cmd/agent-worker/status_test.go

@@ -38,6 +38,18 @@ func TestWorkerStatusReportsRecoveryOnlyWithoutExecutor(t *testing.T) {
 	}
 }
 
+func TestWorkerStatusReportsLocalFallback(t *testing.T) {
+	response := httptest.NewRecorder()
+	workerStatusHandler(false, true).ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/status", nil))
+	var value workerStatusResponse
+	if err := json.NewDecoder(response.Body).Decode(&value); err != nil {
+		t.Fatal(err)
+	}
+	if response.Code != http.StatusOK || value.Ready || value.Mode != "local-fallback" || !value.LocalFallback {
+		t.Fatalf("unexpected status: code=%d value=%+v", response.Code, value)
+	}
+}
+
 func TestWorkerReadyzRequiresExecutor(t *testing.T) {
 	response := httptest.NewRecorder()
 	workerStatusHandler(false).ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/readyz", nil))

cmd/agent-worker/task_evaluation_executor.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/artifact"
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+	capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+)
+
+type taskEvaluationExecutor struct {
+	cognitiveURL string
+	callbackURL  string
+	client       *http.Client
+	fallback     localFallbackExecutor
+}
+
+func newTaskEvaluationExecutor(cognitiveURL, callbackURL string, client *http.Client) taskEvaluationExecutor {
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return taskEvaluationExecutor{cognitiveURL: strings.TrimRight(cognitiveURL, "/"), callbackURL: strings.TrimRight(callbackURL, "/"), client: client, fallback: newLocalFallbackExecutor()}
+}
+
+func (e taskEvaluationExecutor) Execute(ctx context.Context, request work.AgentExecutionRequest) (work.AgentExecutionResult, error) {
+	intent := request.Intent
+	if intent.TaskEvaluationExecution == nil || intent.TaskEvaluationProfile == nil || len(intent.TaskEvaluationCases) == 0 {
+		return e.fallback.Execute(ctx, request)
+	}
+	execution := intent.TaskEvaluationExecution
+	if execution.GraphID == "" || execution.NodeID == "" || execution.BindingRevision < 1 || execution.ActorID == "" || execution.PrincipalID == "" || execution.ScopeID == "" {
+		return e.fallback.Execute(ctx, request)
+	}
+	if e.cognitiveURL == "" || e.callbackURL == "" {
+		return e.fallback.Execute(ctx, request)
+	}
+	payload := capability.TaskEvaluationExecutionRequest{Profile: *intent.TaskEvaluationProfile, CapabilityID: intent.TaskEvaluationProfile.CapabilityID, BindingID: intent.TaskEvaluationBindingID, BindingRevision: execution.BindingRevision, ActorID: execution.ActorID, PrincipalID: execution.PrincipalID, ScopeID: execution.ScopeID, Cases: intent.TaskEvaluationCases, MaxOutputBytes: 4096}
+	response, err := postJSON[capability.TaskEvaluationExecutionResponse](ctx, e.client, e.cognitiveURL+"/v1/task-evaluations/execute", payload)
+	if err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	if len(response.Observations) == 0 || response.ObservedAtUnixMillis < 1 {
+		return work.AgentExecutionResult{}, fmt.Errorf("task evaluation returned no observations")
+	}
+	if len(intent.TaskEvaluationCases) == 0 {
+		return work.AgentExecutionResult{}, fmt.Errorf("task evaluation cases are missing")
+	}
+	evaluation, err := capabilitydomain.BuildTaskEvaluation(*intent.TaskEvaluationProfile, capability.TaskEvaluationID("evaluation:"+intent.DispatchID), response.BindingID, response.BindingRevision, intent.TaskEvaluationProfile.CapabilityID, response.Observations, artifact.ArtifactID(intent.TaskEvaluationCases[0].EvidenceArtifactRef), response.ObservedAtUnixMillis)
+	if err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	callback := work.TaskEvaluationEvidenceCallback{GraphID: execution.GraphID, Revision: execution.GraphRevision, NodeID: execution.NodeID, Evaluation: evaluation, Succeeded: true}
+	if _, err := postJSON[json.RawMessage](ctx, e.client, e.callbackURL+"/v1/work-graphs/task-evaluations/callback", callback); err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	return work.AgentExecutionResult{State: work.AgentExecutionCompleted, Summary: "task evaluation executed, aggregated and accepted by Work Graph callback", OutcomeRef: string(evaluation.ID), ArtifactRefs: []string{string(evaluation.ArtifactID)}, ObservedAtUnixMillis: time.Now().UnixMilli()}, nil
+}
+
+func postJSON[T any](ctx context.Context, client *http.Client, url string, payload any) (T, error) {
+	var result T
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return result, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return result, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := client.Do(req)
+	if err != nil {
+		return result, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return result, fmt.Errorf("POST %s: status %s", url, resp.Status)
+	}
+	if resp.StatusCode == http.StatusNoContent {
+		return result, nil
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return result, err
+	}
+	return result, nil
+}

cmd/agent-worker/task_evaluation_executor_test.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+func TestTaskEvaluationExecutorInvokesAggregatesAndCallbacks(t *testing.T) {
+	profile := capability.TaskEvaluationProfile{ID: "profile-1", Revision: 1, CapabilityID: "capability-1", Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "general-v1", RequiredCaseIDs: []string{"case-1"}, QualityWeightMillis: 600, ReliabilityWeightMillis: 300, LatencyWeightMillis: 100}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/v1/task-evaluations/execute" {
+			_ = json.NewEncoder(w).Encode(capability.TaskEvaluationExecutionResponse{ProfileID: profile.ID, BindingID: "binding-1", BindingRevision: 3, Observations: []capability.TaskCaseObservation{{CaseID: "case-1", Result: capability.EvaluationSupported, EvidenceArtifactRef: "artifact-1"}}, ObservedAtUnixMillis: 10})
+			return
+		}
+		if r.URL.Path == "/v1/work-graphs/task-evaluations/callback" {
+			var callback work.TaskEvaluationEvidenceCallback
+			if err := json.NewDecoder(r.Body).Decode(&callback); err != nil || callback.GraphID != "graph-1" || callback.NodeID != "node-1" || callback.Evaluation.Result != capability.EvaluationSupported {
+				http.Error(w, "invalid callback", http.StatusBadRequest)
+				return
+			}
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		http.NotFound(w, r)
+	}))
+	defer server.Close()
+	executor := newTaskEvaluationExecutor(server.URL, server.URL, server.Client())
+	result, err := executor.Execute(context.Background(), work.AgentExecutionRequest{Intent: work.AgentDispatchIntent{DispatchID: "dispatch-1", TaskEvaluationBindingID: "binding-1", TaskEvaluationProfile: &profile, TaskEvaluationCases: []capability.TaskEvaluationCase{{CaseID: "case-1", Prompt: "answer", EvidenceArtifactRef: "artifact-1"}}, TaskEvaluationExecution: &work.TaskEvaluationDispatchContext{GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", BindingRevision: 3, ActorID: "actor-1", PrincipalID: "principal-1", ScopeID: "scope-1"}}})
+	if err != nil || result.State != work.AgentExecutionCompleted || result.OutcomeRef == "" {
+		t.Fatalf("result=%+v err=%v", result, err)
+	}
+}

cmd/cognitive-worker/gateway.go

@@ -26,6 +26,10 @@ type bindingResolver interface {
 	RegisterDiscovery(context.Context, capability.CognitiveDiscoverySnapshot) (capability.CognitiveDiscoveryRegistration, error)
 }
 
+type candidateBindingResolver interface {
+	ResolveCandidate(context.Context, capability.CapabilityBindingID, int64) (capability.ResolvedCognitiveBinding, error)
+}
+
 type admissionClient interface {
 	Admit(context.Context, string, capability.AdmissionRequest) (capability.AdmissionDecision, capability.AdmissionLease, error)
 	Release(context.Context, capability.AdmissionLease) error
@@ -341,6 +345,26 @@ func (r *httpBindingResolver) Resolve(ctx context.Context, value capability.Cogn
 	return result, err
 }
 
+func (r *httpBindingResolver) ResolveCandidate(ctx context.Context, bindingID capability.CapabilityBindingID, revision int64) (capability.ResolvedCognitiveBinding, error) {
+	var result capability.ResolvedCognitiveBinding
+	target := *r.base
+	target.Path = "/v1/cognitive-bindings/" + url.PathEscape(string(bindingID)) + "/revisions/" + fmt.Sprint(revision) + "/snapshot"
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, target.String(), nil)
+	if err != nil {
+		return result, err
+	}
+	response, err := r.client.Do(request)
+	if err != nil {
+		return result, err
+	}
+	defer response.Body.Close()
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return result, fmt.Errorf("candidate status %d", response.StatusCode)
+	}
+	err = json.NewDecoder(io.LimitReader(response.Body, 64<<10)).Decode(&result)
+	return result, err
+}
+
 func (r *httpBindingResolver) Observe(ctx context.Context, value capability.CognitiveUsageObservation) error {
 	return r.post(ctx, "/v1/cognitive-usage-observations", value, nil)
 }

cmd/cognitive-worker/main.go

@@ -166,6 +166,7 @@ func main() {
 	mux.HandleFunc("POST /v1/advisory-policy", gateway.policyHandler)
 	mux.HandleFunc("POST /v1/advisories", gateway.advisoryHandler)
 	mux.HandleFunc("POST /v1/interpretations", gateway.interpretationHandler)
+	mux.HandleFunc("POST /v1/task-evaluations/execute", gateway.taskEvaluationHandler)
 	discovery := discoveryService{resolver: resolver, providers: discoveries, owner: identity.PrincipalID(envOr("COGNITIVE_OWNER_PRINCIPAL_ID", "domovoy-creator-principal")), now: time.Now}
 	mux.HandleFunc("POST /v1/provider-discovery/{provider}", discovery.handler)
 	refreshProviderDiscoveries(resolver, discovery)

cmd/cognitive-worker/task_evaluation.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/cognitive"
+)
+
+func (g cognitiveGateway) taskEvaluationHandler(w http.ResponseWriter, r *http.Request) {
+	var request capability.TaskEvaluationExecutionRequest
+	if !decodeJSON(w, r, 256<<10, &request) {
+		return
+	}
+	if err := request.Profile.Validate(); err != nil || request.CapabilityID == "" || request.CapabilityID != request.Profile.CapabilityID || request.BindingID == "" || request.BindingRevision < 1 || request.ActorID == "" || request.PrincipalID == "" || request.ScopeID == "" || request.MaxOutputBytes < 1 || len(request.Cases) != len(request.Profile.RequiredCaseIDs) {
+		http.Error(w, "invalid task evaluation execution request", http.StatusBadRequest)
+		return
+	}
+	resolver, ok := g.resolver.(candidateBindingResolver)
+	if !ok {
+		http.Error(w, "exact candidate resolver unavailable", http.StatusServiceUnavailable)
+		return
+	}
+	selected, err := resolver.ResolveCandidate(r.Context(), request.BindingID, request.BindingRevision)
+	if err != nil || selected.Binding.ID != request.BindingID || selected.Binding.Revision != request.BindingRevision || selected.Binding.CapabilityID != request.CapabilityID || selected.Binding.OwnerPrincipalID != request.PrincipalID {
+		http.Error(w, "cognitive binding snapshot unavailable", http.StatusConflict)
+		return
+	}
+	if selected.Binding.DataPolicy != capability.DataPolicyLocalOnly && !request.EgressAcknowledged {
+		http.Error(w, "external egress acknowledgement required", http.StatusBadRequest)
+		return
+	}
+	provider := g.provider(selected)
+	if provider == nil {
+		http.Error(w, "cognitive provider unavailable", http.StatusServiceUnavailable)
+		return
+	}
+	caseSet := make(map[string]struct{}, len(request.Profile.RequiredCaseIDs))
+	for _, id := range request.Profile.RequiredCaseIDs {
+		caseSet[id] = struct{}{}
+	}
+	observations := make([]capability.TaskCaseObservation, len(request.Cases))
+	var wg sync.WaitGroup
+	seenCases := make(map[string]struct{}, len(request.Cases))
+	for i, item := range request.Cases {
+		if item.CaseID == "" || item.Prompt == "" || item.EvidenceArtifactRef == "" {
+			http.Error(w, "invalid task evaluation case", http.StatusBadRequest)
+			return
+		}
+		if _, exists := caseSet[item.CaseID]; !exists {
+			http.Error(w, "task evaluation case is not in profile", http.StatusBadRequest)
+			return
+		}
+		if _, exists := seenCases[item.CaseID]; exists {
+			http.Error(w, "duplicate task evaluation case", http.StatusBadRequest)
+			return
+		}
+		seenCases[item.CaseID] = struct{}{}
+		wg.Add(1)
+		go func(index int, item capability.TaskEvaluationCase) {
+			defer wg.Done()
+			started := time.Now()
+			invocation := cognitive.AdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(fmt.Sprintf("task-evaluation:%s:%s", request.Profile.ID, item.CaseID)), ActorID: request.ActorID, PrincipalID: request.PrincipalID, ScopeID: request.ScopeID, Message: item.Prompt, MaxOutputBytes: int(request.MaxOutputBytes), ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, ProviderInstanceID: selected.Provider.ID, ModelDescriptorID: selected.Model.ID, ProviderModelID: selected.Model.ProviderModelID}
+			response, invokeErr := g.invokeAdmitted(r.Context(), string(invocation.RequestID), provider, invocation, int(request.MaxOutputBytes))
+			observation := capability.TaskCaseObservation{CaseID: item.CaseID, LatencyMicros: time.Since(started).Microseconds(), EvidenceArtifactRef: item.EvidenceArtifactRef}
+			if invokeErr == nil && response.FinishReason == cognitive.FinishCompleted && response.AdvisoryText != "" {
+				observation.Result = capability.EvaluationSupported
+				// Invocation success proves reachability/support for this case,
+				// not semantic answer quality. A verifier may score quality later.
+				observation.QualityScoreMillis = 0
+			} else {
+				observation.Result = capability.EvaluationUnknown
+				observation.CriticalFailure = invokeErr != nil
+			}
+			observations[index] = observation
+		}(i, item)
+	}
+	if len(seenCases) != len(caseSet) {
+		http.Error(w, "task evaluation case set is incomplete", http.StatusBadRequest)
+		return
+	}
+	wg.Wait()
+	writeTaskEvaluationJSON(w, capability.TaskEvaluationExecutionResponse{ProfileID: request.Profile.ID, BindingID: selected.Binding.ID, BindingRevision: selected.Binding.Revision, Observations: observations, ObservedAtUnixMillis: time.Now().UnixMilli()})
+}
+
+func writeTaskEvaluationJSON(w http.ResponseWriter, value any) {
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(value)
+}

cmd/cognitive-worker/task_evaluation_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/authority"
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/cognitive"
+	"git.cin.su/m/Assistant/contracts/identity"
+)
+
+type candidateRegistryStub struct {
+	registryStub
+	selected capability.ResolvedCognitiveBinding
+}
+
+func (s *candidateRegistryStub) ResolveCandidate(context.Context, capability.CapabilityBindingID, int64) (capability.ResolvedCognitiveBinding, error) {
+	return s.selected, nil
+}
+
+func TestTaskEvaluationHandlerInvokesEveryBoundedCase(t *testing.T) {
+	selected := gatewaySelection()
+	registry := &candidateRegistryStub{selected: selected}
+	provider := &stubAdvisoryProvider{response: cognitive.AdvisoryResponse{Version: cognitive.CreatorAdvisoryV1, FinishReason: cognitive.FinishCompleted, AdvisoryText: "observed response"}}
+	gateway := cognitiveGateway{
+		resolver: registry,
+		providers: map[capability.ProviderKind][]providerRegistration{
+			selected.Provider.Kind: {{ProviderInstanceID: selected.Provider.ID, Kind: selected.Provider.Kind, EndpointRef: selected.Provider.EndpointRef, CredentialRef: selected.Provider.CredentialRef, Provider: provider}},
+		},
+		now: func() time.Time { return time.UnixMilli(1000) },
+	}
+	profile := capability.TaskEvaluationProfile{ID: "profile-general", Revision: 1, CapabilityID: selected.Binding.CapabilityID, Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "general-v1", RequiredCaseIDs: []string{"case-a", "case-b"}, QualityWeightMillis: 600, ReliabilityWeightMillis: 300, LatencyWeightMillis: 100}
+	request := capability.TaskEvaluationExecutionRequest{Profile: profile, CapabilityID: selected.Binding.CapabilityID, BindingID: selected.Binding.ID, BindingRevision: selected.Binding.Revision, ActorID: identity.ActorID("actor-1"), PrincipalID: selected.Binding.OwnerPrincipalID, ScopeID: authority.ScopeID("scope-1"), MaxOutputBytes: 512, EgressAcknowledged: true, Cases: []capability.TaskEvaluationCase{{CaseID: "case-a", Prompt: "one", EvidenceArtifactRef: "artifact:a"}, {CaseID: "case-b", Prompt: "two", EvidenceArtifactRef: "artifact:b"}}}
+	payload, _ := json.Marshal(request)
+	recorder := httptest.NewRecorder()
+	gateway.taskEvaluationHandler(recorder, httptest.NewRequest(http.MethodPost, "/v1/task-evaluations/execute", bytes.NewReader(payload)))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	var response capability.TaskEvaluationExecutionResponse
+	if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Fatal(err)
+	}
+	if len(response.Observations) != 2 || response.Observations[0].Result != capability.EvaluationSupported || response.Observations[1].Result != capability.EvaluationSupported {
+		t.Fatalf("unexpected observations: %+v", response.Observations)
+	}
+}

cmd/core-runtime/main.go

@@ -834,6 +834,20 @@ func main() {
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(binding)
 	})
+	mux.HandleFunc("GET /v1/cognitive-bindings/{id}/revisions/{revision}/snapshot", func(w http.ResponseWriter, r *http.Request) {
+		revision, err := strconv.ParseInt(r.PathValue("revision"), 10, 64)
+		if err != nil || revision < 1 {
+			http.Error(w, "invalid cognitive binding revision", http.StatusBadRequest)
+			return
+		}
+		snapshot, err := capabilityRepository.LoadCognitiveCandidate(r.Context(), capability.CapabilityBindingID(r.PathValue("id")), revision)
+		if err != nil {
+			http.Error(w, "cognitive binding snapshot not found", http.StatusNotFound)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(snapshot)
+	})
 	mux.HandleFunc("POST /v1/cognitive-bindings/resolve", func(w http.ResponseWriter, r *http.Request) {
 		var requirement capability.CognitiveRequirement
 		decoder := json.NewDecoder(io.LimitReader(r.Body, 16*1024+1))
@@ -842,7 +856,13 @@ func main() {
 			http.Error(w, "invalid cognitive requirement", http.StatusBadRequest)
 			return
 		}
-		candidates, err := capabilityRepository.LoadCognitiveCandidates(r.Context(), requirement.CapabilityID, requirement.OwnerPrincipalID)
+		var candidates []capability.ResolvedCognitiveBinding
+		var err error
+		if requirement.TaskProfileID != "" {
+			candidates, err = capabilityRepository.LoadCognitiveCandidatesForProfile(r.Context(), requirement.CapabilityID, requirement.OwnerPrincipalID, requirement.TaskProfileID)
+		} else {
+			candidates, err = capabilityRepository.LoadCognitiveCandidates(r.Context(), requirement.CapabilityID, requirement.OwnerPrincipalID)
+		}
 		if err != nil {
 			http.Error(w, "cognitive registry unavailable", http.StatusServiceUnavailable)
 			return
@@ -891,6 +911,20 @@ func main() {
 		}
 		w.WriteHeader(http.StatusCreated)
 	})
+	mux.HandleFunc("POST /v1/cognitive-registry/task-evaluations", func(w http.ResponseWriter, r *http.Request) {
+		var value capability.TaskEvaluation
+		decoder := json.NewDecoder(io.LimitReader(r.Body, 64<<10))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&value); err != nil || capabilitydomain.ValidateTaskEvaluation(value) != nil {
+			http.Error(w, "invalid task evaluation", http.StatusBadRequest)
+			return
+		}
+		if err := capabilityRepository.SaveTaskEvaluation(r.Context(), value); err != nil {
+			http.Error(w, "save task evaluation", http.StatusInternalServerError)
+			return
+		}
+		w.WriteHeader(http.StatusCreated)
+	})
 	mux.HandleFunc("POST /v1/creator/cognitive-canary", func(w http.ResponseWriter, r *http.Request) {
 		session, ok := authenticateCreator(w, r)
 		if !ok {

cmd/work-graph-runtime/main.go

@@ -7,9 +7,11 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"time"
 
 	"git.cin.su/m/Assistant/adapters/postgres"
 	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
+	"git.cin.su/m/Assistant/contracts/work"
 	"git.cin.su/m/Assistant/modules/work/application"
 	"git.cin.su/m/Assistant/platform/secrets"
 	"git.cin.su/m/Assistant/runtime/health"
@@ -26,6 +28,10 @@ func main() {
 		log.Fatal(err)
 	}
 	defer repository.Close()
+	evidenceSink, err := newCoreTaskEvaluationSink(envOr("CORE_RUNTIME_URL", "http://core-runtime:8080"), &http.Client{Timeout: 12 * time.Second})
+	if err != nil {
+		log.Fatal(err)
+	}
 	mux := http.NewServeMux()
 	mux.Handle("/healthz", health.Handler{Runtime: "work-graph-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
 	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "work-graph-runtime", Probes: []health.Probe{{Name: "work-postgres", Check: func(ctx context.Context) error { return repository.Ping(ctx) }}}})
@@ -42,6 +48,19 @@ func main() {
 		}
 		writeJSON(w, map[string]any{"graph": graph, "scheduled_nodes": ready})
 	})
+	mux.HandleFunc("POST /v1/work-graphs/task-evaluations/schedule", func(w http.ResponseWriter, r *http.Request) {
+		var request application.TaskEvaluationScheduleRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<20)).Decode(&request); err != nil {
+			http.Error(w, "invalid task evaluation graph request", http.StatusBadRequest)
+			return
+		}
+		graph, ready, err := application.AdmitAndScheduleTaskEvaluation(r.Context(), repository, request)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		writeJSON(w, map[string]any{"graph": graph, "scheduled_nodes": ready})
+	})
 	mux.HandleFunc("POST /v1/work-graphs/complete", func(w http.ResponseWriter, r *http.Request) {
 		var request application.GraphCompleteRequest
 		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 64<<10)).Decode(&request); err != nil {
@@ -55,6 +74,19 @@ func main() {
 		}
 		writeJSON(w, graph)
 	})
+	mux.HandleFunc("POST /v1/work-graphs/task-evaluations/callback", func(w http.ResponseWriter, r *http.Request) {
+		var request work.TaskEvaluationEvidenceCallback
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)).Decode(&request); err != nil {
+			http.Error(w, "invalid task evaluation callback", http.StatusBadRequest)
+			return
+		}
+		graph, err := application.CompleteTaskEvaluationNode(r.Context(), repository, evidenceSink, request)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		writeJSON(w, graph)
+	})
 	mux.HandleFunc("POST /v1/work-graphs/synthesis", func(w http.ResponseWriter, r *http.Request) {
 		var request application.GraphSynthesisRequest
 		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<20)).Decode(&request); err != nil {
@@ -76,6 +108,13 @@ func main() {
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
 
+func envOr(name, fallback string) string {
+	if value := os.Getenv(name); value != "" {
+		return value
+	}
+	return fallback
+}
+
 func writeJSON(w http.ResponseWriter, value any) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(value)

cmd/work-graph-runtime/task_evaluation_sink.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+type coreTaskEvaluationSink struct {
+	baseURL string
+	client  *http.Client
+}
+
+func newCoreTaskEvaluationSink(baseURL string, client *http.Client) (*coreTaskEvaluationSink, error) {
+	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
+	if baseURL == "" {
+		return nil, fmt.Errorf("core runtime URL is required")
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return &coreTaskEvaluationSink{baseURL: baseURL, client: client}, nil
+}
+
+func (s *coreTaskEvaluationSink) SaveTaskEvaluation(ctx context.Context, value capability.TaskEvaluation) error {
+	payload, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, s.baseURL+"/v1/cognitive-registry/task-evaluations", bytes.NewReader(payload))
+	if err != nil {
+		return err
+	}
+	request.Header.Set("Content-Type", "application/json")
+	response, err := s.client.Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return fmt.Errorf("save task evaluation: status %s", response.Status)
+	}
+	return nil
+}

contracts/capability/cognitive_registry.go

@@ -160,28 +160,32 @@ type CognitiveRequirement struct {
 	ExcludedBindingIDs   []CapabilityBindingID
 	Objective            SelectionObjective
 	MaxCostMicros        *int64
+	TaskProfileID        TaskEvaluationProfileID
 }
 
 // ResolvedCognitiveBinding is a provider-neutral invocation snapshot selected
 // by Capability. It contains references and declared metadata, never secrets.
 type ResolvedCognitiveBinding struct {
-	Binding     CognitiveBinding
-	Provider    ProviderInstance
-	Model       ModelDescriptor
-	Evaluation  *EvaluatedCapability
-	Performance *PerformanceEvidence
-	Rating      *ModelRating
+	Binding        CognitiveBinding
+	Provider       ProviderInstance
+	Model          ModelDescriptor
+	Evaluation     *EvaluatedCapability
+	Performance    *PerformanceEvidence
+	TaskEvaluation *TaskEvaluation
+	Rating         *ModelRating
 }
 
 // ModelRating is a derived, provider-neutral explanation of why an eligible
 // model is routed. It never grants qualification or activation authority.
 type ModelRating struct {
-	Category               ModelRatingCategory `json:"category"`
-	OverallScoreMillis     int64               `json:"overall_score_millis"`
-	QualityScoreMillis     int64               `json:"quality_score_millis"`
-	ReliabilityScoreMillis int64               `json:"reliability_score_millis"`
-	LatencyScoreMillis     int64               `json:"latency_score_millis"`
-	EvidenceScoreMillis    int64               `json:"evidence_score_millis"`
+	TaskProfileID          TaskEvaluationProfileID `json:"task_profile_id,omitempty"`
+	TaskScoreMillis        int64                   `json:"task_score_millis,omitempty"`
+	Category               ModelRatingCategory     `json:"category"`
+	OverallScoreMillis     int64                   `json:"overall_score_millis"`
+	QualityScoreMillis     int64                   `json:"quality_score_millis"`
+	ReliabilityScoreMillis int64                   `json:"reliability_score_millis"`
+	LatencyScoreMillis     int64                   `json:"latency_score_millis"`
+	EvidenceScoreMillis    int64                   `json:"evidence_score_millis"`
 }
 
 type CognitiveResultClass string

contracts/capability/task_evaluation.go

@@ -0,0 +1,102 @@
+package capability
+
+import (
+	"errors"
+
+	"git.cin.su/m/Assistant/contracts/artifact"
+	"git.cin.su/m/Assistant/platform/ids"
+)
+
+type TaskEvaluationProfileID ids.ID
+type TaskEvaluationID ids.ID
+type TaskEvaluationProfileStage string
+
+const (
+	TaskEvaluationGeneral    TaskEvaluationProfileStage = "GENERAL"
+	TaskEvaluationAdditional TaskEvaluationProfileStage = "ADDITIONAL"
+)
+
+// TaskEvaluationProfile is the extensible, provider-neutral description of a
+// task-specific qualification run. Case payloads live in Artifact; the
+// profile stores only stable case references and scoring policy.
+type TaskEvaluationProfile struct {
+	ID                      TaskEvaluationProfileID
+	Revision                int64
+	CapabilityID            CapabilityID
+	Stage                   TaskEvaluationProfileStage
+	ParentProfileID         TaskEvaluationProfileID
+	TriggerEvidenceRef      string
+	BenchmarkVersion        string
+	RequiredCaseIDs         []string
+	QualityWeightMillis     int64
+	ReliabilityWeightMillis int64
+	LatencyWeightMillis     int64
+}
+
+func (p TaskEvaluationProfile) Validate() error {
+	if p.ID == "" || p.Revision < 1 || p.CapabilityID == "" || (p.Stage != TaskEvaluationGeneral && p.Stage != TaskEvaluationAdditional) || p.BenchmarkVersion == "" || len(p.RequiredCaseIDs) == 0 {
+		return errors.New("task evaluation profile identity and cases are incomplete")
+	}
+	if p.Stage == TaskEvaluationGeneral && (p.ParentProfileID != "" || p.TriggerEvidenceRef != "") {
+		return errors.New("general task evaluation profile cannot have an expansion parent")
+	}
+	if p.Stage == TaskEvaluationAdditional && (p.ParentProfileID == "" || p.TriggerEvidenceRef == "") {
+		return errors.New("additional task evaluation profile requires parent and trigger evidence")
+	}
+	if p.QualityWeightMillis < 0 || p.ReliabilityWeightMillis < 0 || p.LatencyWeightMillis < 0 || p.QualityWeightMillis+p.ReliabilityWeightMillis+p.LatencyWeightMillis != 1000 {
+		return errors.New("task evaluation profile weights must be non-negative and sum to 1000")
+	}
+	seen := make(map[string]struct{}, len(p.RequiredCaseIDs))
+	for _, caseID := range p.RequiredCaseIDs {
+		if caseID == "" {
+			return errors.New("task evaluation profile contains an empty case")
+		}
+		if _, ok := seen[caseID]; ok {
+			return errors.New("task evaluation profile contains duplicate cases")
+		}
+		seen[caseID] = struct{}{}
+	}
+	return nil
+}
+
+// TaskEvaluationExpansionRequest is emitted after a task remains unresolved
+// with the current best eligible candidate. It creates only a bounded new
+// profile; it never silently rewrites the general benchmark.
+type TaskEvaluationExpansionRequest struct {
+	ParentProfileID    TaskEvaluationProfileID
+	CapabilityID       CapabilityID
+	TriggerEvidenceRef string
+	NewCaseIDs         []string
+	BenchmarkVersion   string
+}
+
+// TaskCaseObservation is produced by the bounded evaluator and verifier. A
+// score without a case result and evidence reference is not accepted as
+// qualification evidence.
+type TaskCaseObservation struct {
+	CaseID              string
+	Result              EvaluationResult
+	QualityScoreMillis  int64
+	LatencyMicros       int64
+	CriticalFailure     bool
+	EvidenceArtifactRef string
+}
+
+// TaskEvaluation is durable evidence for one model/binding revision under one
+// task profile. It is not activation authority.
+type TaskEvaluation struct {
+	ID                     TaskEvaluationID
+	ProfileID              TaskEvaluationProfileID
+	BindingID              CapabilityBindingID
+	BindingRevision        int64
+	CapabilityID           CapabilityID
+	Result                 EvaluationResult
+	QualityScoreMillis     int64
+	ReliabilityScoreMillis int64
+	LatencyScoreMillis     int64
+	OverallScoreMillis     int64
+	CriticalFailureMillis  int64
+	BenchmarkVersion       string
+	ArtifactID             artifact.ArtifactID
+	ObservedAtUnixMillis   int64
+}

contracts/capability/task_evaluation_execution.go

@@ -0,0 +1,35 @@
+package capability
+
+import (
+	"git.cin.su/m/Assistant/contracts/authority"
+	"git.cin.su/m/Assistant/contracts/identity"
+)
+
+// TaskEvaluationCase carries one bounded prompt selected by the evaluator.
+// The prompt is an input artifact, not a model-produced fact.
+type TaskEvaluationCase struct {
+	CaseID              string
+	Prompt              string
+	EvidenceArtifactRef string
+}
+
+type TaskEvaluationExecutionRequest struct {
+	Profile            TaskEvaluationProfile
+	CapabilityID       CapabilityID
+	BindingID          CapabilityBindingID
+	BindingRevision    int64
+	ActorID            identity.ActorID
+	PrincipalID        identity.PrincipalID
+	ScopeID            authority.ScopeID
+	Cases              []TaskEvaluationCase
+	MaxOutputBytes     int64
+	EgressAcknowledged bool
+}
+
+type TaskEvaluationExecutionResponse struct {
+	ProfileID            TaskEvaluationProfileID
+	BindingID            CapabilityBindingID
+	BindingRevision      int64
+	Observations         []TaskCaseObservation
+	ObservedAtUnixMillis int64
+}

contracts/work/graph.go

@@ -1,11 +1,17 @@
 package work
 
+import "git.cin.su/m/Assistant/contracts/capability"
+
 type GraphNodeID string
 
 type GraphState string
 type GraphNodeState string
+type GraphNodePurpose string
 
 const (
+	GraphNodePurposeTaskEvaluation GraphNodePurpose = "TASK_EVALUATION_SPECIALIST"
+	GraphNodePurposeGeneric        GraphNodePurpose = "GENERIC"
+
 	GraphDraft     GraphState = "DRAFT"
 	GraphAdmitted  GraphState = "ADMITTED"
 	GraphRunning   GraphState = "RUNNING"
@@ -31,11 +37,17 @@ type GraphBudget struct {
 }
 
 type GraphNode struct {
-	ID             GraphNodeID    `json:"id"`
-	DispatchID     string         `json:"dispatch_id"`
-	IdempotencyKey string         `json:"idempotency_key"`
-	State          GraphNodeState `json:"state"`
-	Attempts       int            `json:"attempts"`
+	ID             GraphNodeID                        `json:"id"`
+	DispatchID     string                             `json:"dispatch_id"`
+	IdempotencyKey string                             `json:"idempotency_key"`
+	State          GraphNodeState                     `json:"state"`
+	Attempts       int                                `json:"attempts"`
+	Purpose        GraphNodePurpose                   `json:"purpose,omitempty"`
+	TaskProfileID  capability.TaskEvaluationProfileID `json:"task_profile_id,omitempty"`
+	BindingID      capability.CapabilityBindingID     `json:"binding_id,omitempty"`
+	CaseIDs        []string                           `json:"case_ids,omitempty"`
+	TaskProfile    *capability.TaskEvaluationProfile  `json:"task_profile,omitempty"`
+	TaskCases      []capability.TaskEvaluationCase    `json:"task_cases,omitempty"`
 }
 
 type GraphEdge struct {
@@ -44,12 +56,47 @@ type GraphEdge struct {
 }
 
 type WorkGraph struct {
-	ID       string      `json:"id"`
-	Revision int64       `json:"revision"`
-	State    GraphState  `json:"state"`
-	Nodes    []GraphNode `json:"nodes"`
-	Edges    []GraphEdge `json:"edges"`
-	Budget   GraphBudget `json:"budget"`
+	ID                  string      `json:"id"`
+	Revision            int64       `json:"revision"`
+	State               GraphState  `json:"state"`
+	Nodes               []GraphNode `json:"nodes"`
+	Edges               []GraphEdge `json:"edges"`
+	Budget              GraphBudget `json:"budget"`
+	ParentGraphID       string      `json:"parent_graph_id,omitempty"`
+	ParentGraphRevision int64       `json:"parent_graph_revision,omitempty"`
+	TriggerEvidenceRef  string      `json:"trigger_evidence_ref,omitempty"`
+}
+
+// TaskEvaluationGraphRequest describes a durable fan-out. The graph contains
+// one specialist node per binding; each node receives the profile's bounded
+// cases and reports evidence back to Capability for fan-in aggregation.
+type TaskEvaluationGraphRequest struct {
+	GraphID             string                           `json:"graph_id"`
+	Profile             capability.TaskEvaluationProfile `json:"profile"`
+	BindingIDs          []capability.CapabilityBindingID `json:"binding_ids"`
+	DispatchIDs         []string                         `json:"dispatch_ids"`
+	IdempotencyPrefix   string                           `json:"idempotency_prefix"`
+	Budget              GraphBudget                      `json:"budget"`
+	ParentGraphID       string                           `json:"parent_graph_id,omitempty"`
+	ParentGraphRevision int64                            `json:"parent_graph_revision,omitempty"`
+	ParentGraphState    GraphState                       `json:"parent_graph_state,omitempty"`
+	TriggerEvidenceRef  string                           `json:"trigger_evidence_ref,omitempty"`
+	Cases               []capability.TaskEvaluationCase  `json:"cases,omitempty"`
+	BindingRevision     int64                            `json:"binding_revision,omitempty"`
+	ActorID             string                           `json:"actor_id,omitempty"`
+	PrincipalID         string                           `json:"principal_id,omitempty"`
+	ScopeID             string                           `json:"scope_id,omitempty"`
+}
+
+// TaskEvaluationEvidenceCallback is emitted by a specialist after it has
+// completed the bounded case set. Capability remains the evidence owner;
+// Work only advances its matching graph node after the evidence is accepted.
+type TaskEvaluationEvidenceCallback struct {
+	GraphID    string                    `json:"graph_id"`
+	Revision   int64                     `json:"revision"`
+	NodeID     GraphNodeID               `json:"node_id"`
+	Evaluation capability.TaskEvaluation `json:"evaluation"`
+	Succeeded  bool                      `json:"succeeded"`
 }
 
 type ResultCandidate struct {

contracts/work/lease.go

@@ -1,6 +1,12 @@
 package work
 
-import "time"
+import (
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/authority"
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/identity"
+)
 
 type AgentLeaseID string
 type AgentFencingToken uint64
@@ -50,14 +56,31 @@ type IndependentVerification struct {
 }
 
 type AgentDispatchIntent struct {
-	DispatchID             string       `json:"dispatch_id"`
-	IdempotencyKey         string       `json:"idempotency_key"`
-	DelegationID           DelegationID `json:"delegation_id"`
-	RunID                  AgentRunID   `json:"run_id"`
-	ImplementationID       string       `json:"implementation_id"`
-	ImplementationRevision int64        `json:"implementation_revision"`
-	SourceRevision         string       `json:"source_revision"`
-	WorktreeID             string       `json:"worktree_id"`
-	VerificationPlanRef    string       `json:"verification_plan_ref"`
-	CreatedAtUnixMillis    int64        `json:"created_at_unix_millis"`
+	DispatchID              string                             `json:"dispatch_id"`
+	IdempotencyKey          string                             `json:"idempotency_key"`
+	DelegationID            DelegationID                       `json:"delegation_id"`
+	RunID                   AgentRunID                         `json:"run_id"`
+	ImplementationID        string                             `json:"implementation_id"`
+	ImplementationRevision  int64                              `json:"implementation_revision"`
+	SourceRevision          string                             `json:"source_revision"`
+	WorktreeID              string                             `json:"worktree_id"`
+	VerificationPlanRef     string                             `json:"verification_plan_ref"`
+	CreatedAtUnixMillis     int64                              `json:"created_at_unix_millis"`
+	SpecialistPurpose       string                             `json:"specialist_purpose,omitempty"`
+	TaskEvaluationProfileID capability.TaskEvaluationProfileID `json:"task_evaluation_profile_id,omitempty"`
+	TaskEvaluationBindingID capability.CapabilityBindingID     `json:"task_evaluation_binding_id,omitempty"`
+	TaskEvaluationCaseIDs   []string                           `json:"task_evaluation_case_ids,omitempty"`
+	TaskEvaluationProfile   *capability.TaskEvaluationProfile  `json:"task_evaluation_profile,omitempty"`
+	TaskEvaluationCases     []capability.TaskEvaluationCase    `json:"task_evaluation_cases,omitempty"`
+	TaskEvaluationExecution *TaskEvaluationDispatchContext     `json:"task_evaluation_execution,omitempty"`
+}
+
+type TaskEvaluationDispatchContext struct {
+	GraphID         string               `json:"graph_id"`
+	GraphRevision   int64                `json:"graph_revision"`
+	NodeID          GraphNodeID          `json:"node_id"`
+	BindingRevision int64                `json:"binding_revision"`
+	ActorID         identity.ActorID     `json:"actor_id"`
+	PrincipalID     identity.PrincipalID `json:"principal_id"`
+	ScopeID         authority.ScopeID    `json:"scope_id"`
 }

contracts/work/self_development.go

@@ -17,6 +17,8 @@ const (
 
 type DevelopmentGate struct {
 	ID                   string
+	Revision             int64
+	UpdatedAtUnixMillis  int64
 	Stage                DevelopmentStage
 	EvidenceRefs         []string
 	ProposalRef          string

database/migrations/037_work_development_gates.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS work.development_gates (
+  gate_id TEXT PRIMARY KEY,
+  revision BIGINT NOT NULL CHECK (revision > 0),
+  updated_at_unix_millis BIGINT NOT NULL CHECK (updated_at_unix_millis > 0),
+  stage TEXT NOT NULL,
+  evidence_refs TEXT[] NOT NULL,
+  proposal_ref TEXT NOT NULL,
+  task_packet_ref TEXT NOT NULL,
+  worktree_ref TEXT NOT NULL,
+  producer_run_refs TEXT[] NOT NULL,
+  verifier_run_refs TEXT[] NOT NULL,
+  verification_evidence TEXT NOT NULL,
+  canary_evidence TEXT NOT NULL,
+  promotion_ref TEXT NOT NULL,
+  rollback_ref TEXT NOT NULL
+);

database/migrations/038_work_development_gates_privileges.sql

@@ -0,0 +1,6 @@
+BEGIN;
+
+ALTER TABLE work.development_gates OWNER TO work_role;
+GRANT SELECT, INSERT, UPDATE ON work.development_gates TO work_role;
+
+COMMIT;

database/migrations/039_capability_task_evaluations.sql

@@ -0,0 +1,35 @@
+BEGIN;
+SET ROLE capability_role;
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_task_evaluations (
+  evaluation_id TEXT PRIMARY KEY,
+  task_profile_id TEXT NOT NULL,
+  binding_id TEXT NOT NULL,
+  binding_revision BIGINT NOT NULL,
+  capability_id TEXT NOT NULL,
+  result TEXT NOT NULL,
+  quality_score_millis BIGINT NOT NULL,
+  reliability_score_millis BIGINT NOT NULL,
+  latency_score_millis BIGINT NOT NULL,
+  overall_score_millis BIGINT NOT NULL,
+  critical_failure_millis BIGINT NOT NULL,
+  benchmark_version TEXT NOT NULL,
+  artifact_id TEXT NOT NULL,
+  observed_at_unix_millis BIGINT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (binding_revision > 0),
+  CHECK (result IN ('UNKNOWN','SUPPORTED','UNSUPPORTED')),
+  CHECK (quality_score_millis BETWEEN 0 AND 1000),
+  CHECK (reliability_score_millis BETWEEN 0 AND 1000),
+  CHECK (latency_score_millis BETWEEN 0 AND 1000),
+  CHECK (overall_score_millis BETWEEN 0 AND 1000),
+  CHECK (critical_failure_millis BETWEEN 0 AND 1000),
+  CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE INDEX IF NOT EXISTS cognitive_task_evaluations_lookup
+  ON capability.cognitive_task_evaluations(task_profile_id, binding_id, binding_revision, observed_at_unix_millis DESC);
+
+GRANT SELECT, INSERT ON capability.cognitive_task_evaluations TO capability_role;
+RESET ROLE;
+COMMIT;

database/migrations/040_task_evaluation_dispatch.sql

@@ -0,0 +1,23 @@
+BEGIN;
+
+SET ROLE work_role;
+
+ALTER TABLE work.agent_dispatch_intents
+  ADD COLUMN IF NOT EXISTS specialist_purpose TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS task_evaluation_profile_id TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS task_evaluation_binding_id TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS task_evaluation_case_ids TEXT[] NOT NULL DEFAULT '{}';
+
+ALTER TABLE work.graphs
+  ADD COLUMN IF NOT EXISTS parent_graph_id TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS parent_graph_revision BIGINT NOT NULL DEFAULT 0,
+  ADD COLUMN IF NOT EXISTS trigger_evidence_ref TEXT NOT NULL DEFAULT '';
+
+ALTER TABLE work.graph_nodes
+  ADD COLUMN IF NOT EXISTS purpose TEXT NOT NULL DEFAULT 'GENERIC',
+  ADD COLUMN IF NOT EXISTS task_profile_id TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS binding_id TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS case_ids TEXT[] NOT NULL DEFAULT '{}';
+
+RESET ROLE;
+COMMIT;

database/migrations/041_task_evaluation_payload.sql

@@ -0,0 +1,16 @@
+BEGIN;
+
+SET ROLE work_role;
+
+ALTER TABLE work.agent_dispatch_intents
+  ADD COLUMN IF NOT EXISTS task_evaluation_profile JSONB,
+  ADD COLUMN IF NOT EXISTS task_evaluation_cases JSONB NOT NULL DEFAULT '[]',
+  ADD COLUMN IF NOT EXISTS task_evaluation_execution JSONB;
+
+ALTER TABLE work.graph_nodes
+  ADD COLUMN IF NOT EXISTS task_evaluation_profile JSONB,
+  ADD COLUMN IF NOT EXISTS task_evaluation_cases JSONB NOT NULL DEFAULT '[]',
+  ADD COLUMN IF NOT EXISTS task_evaluation_execution JSONB;
+
+RESET ROLE;
+COMMIT;

deploy/docker-compose.prod.yml

@@ -99,8 +99,12 @@ services:
       POSTGRES_PORT: "5432"
       POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
       WORK_POSTGRES_USER: work_role
-      WORK_POSTGRES_PASSWORD: ${WORK_DB_PASSWORD}
+      WORK_POSTGRES_CREDENTIAL_REF: credential://domovoy/work/db-password/v1
+      WORK_POSTGRES_PASSWORD_FILE: /run/secrets/work_db_password
+      SECRET_BACKEND_ROOT: /run/secrets
     depends_on: { postgres: { condition: service_healthy } }
+    volumes:
+      - assistant_core_secrets:/run/secrets:ro
 
   agent-worker:
     build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: agent-worker, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }

dev/ACTIVE_TASK.json

@@ -1,5 +1,5 @@
 {
-  "task_file": "dev/tasks/DEV-000190-live-audit-status-sync.json",
-  "task_id": "DEV-000190",
+  "task_file": "dev/tasks/DEV-000213-worker-evaluator-link.json",
+  "task_id": "DEV-000213",
   "task_revision": 1
 }

dev/tasks/DEV-000191-cleanup-obsolete-audit-descriptions.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000191",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "5d9124d0dff3777814291c0cd9a69c9d74974cb7",
+  "risk_tier": "E",
+  "intent": "Remove obsolete historical status prose and one superseded unreferenced fleet evidence duplicate while retaining current positive and negative direction evidence, governance lineage and runtime artifacts.",
+  "requirement_ids": ["content hygiene", "current audit directions", "preserve good/bad evidence"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/audit-runtime-status-2026-08-23-v1.json", "docs/evidence/wp-200-wp-301-fleet-execution-status-2026-08-22-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000191-cleanup-obsolete-audit-descriptions.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "cmd/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["governance lineage and current audit evidence"], "may_change": ["status projection and retained evidence index"]},
+  "semantic_owner": "project-governance",
+  "canonical_state": ["docs/PROJECT_STATUS.md", "docs/evidence/audit-runtime-status-2026-08-23-v1.json"],
+  "state_transitions": ["historical verbose status -> concise current good/bad direction status", "superseded duplicate evidence -> removed after reference check"],
+  "side_effects_and_privileges": ["documentation deletion only; no runtime, schema, secret or deployment mutation"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["retain any file with an active reference or unique evidence; deletion is limited to the named unreferenced duplicate"],
+  "assumptions": ["historical task packets and evidence referenced by them remain retained for provenance"],
+  "acceptance_scenarios": ["status file contains only current direction summaries and governance pointer", "production revision is current", "old status sections are absent", "only the explicitly superseded unreferenced fleet duplicate is removed", "all runtime and architecture files remain unchanged"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_CONFLICT", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000192-reflection-live-reconciliation-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000192",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "413a432e8c661ff702779c5288049eaede948c1b",
+  "risk_tier": "E",
+  "intent": "Record live reconciliation evidence for the durable Learning reflection worker and update the audit direction without changing runtime behavior.",
+  "requirement_ids": ["Learning reflection loop", "reflection backlog reconciliation", "live evidence provenance"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/reflection-runtime-reconciliation-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000192-reflection-live-reconciliation-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "cmd/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["reflection worker status contract", "epistemics reflection candidate state"], "may_change": ["audit status projection", "append-only live evidence record"]},
+  "semantic_owner": "project-governance",
+  "canonical_state": ["epistemics.reflection_candidates"],
+  "state_transitions": ["open backlog assessment -> reconciled resolved state evidence"],
+  "side_effects_and_privileges": ["documentation and evidence only; no database mutation"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["worker no-op and durable state query are retained as evidence; no inferred candidate resolution"],
+  "assumptions": ["the production worker's one-shot no-candidate result and the authoritative state query were captured from docker.cin.su"],
+  "acceptance_scenarios": ["worker runs without a pending candidate", "database state reports 31 RESOLVED reflection candidates and no OPEN backlog", "status marks the reflection loop reconciled", "Agent Execution and UI gaps remain explicit"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000193-fleet-live-degraded-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000193",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "bb18cb4f1c18aee7c22ddbe7259123f96f779b8c",
+  "risk_tier": "E",
+  "intent": "Record the current live model fleet degradation and truthful FAST-first fallback selection after the opportunistic HEAVY provider timeout.",
+  "requirement_ids": ["model fleet/failover", "CPU-first current operation", "truthful degraded readiness"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/audit-runtime-status-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000193-fleet-live-degraded-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "cmd/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["live /v1/fleet/readiness response", "existing FleetReadiness and fallback policy"], "may_change": ["fleet evidence projection"]},
+  "semantic_owner": "project-governance",
+  "canonical_state": ["cognitive-worker fleet readiness projection"],
+  "state_transitions": ["HEAVY ready -> timeout/unavailable", "preferred FAST remains selected", "LIFEBOAT remains fallback tier"],
+  "side_effects_and_privileges": ["documentation and evidence only; no provider activation or deployment configuration mutation"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["provider timeout remains degraded evidence; no unavailable model is claimed ready"],
+  "assumptions": ["the live endpoint response was captured from docker.cin.su after the current production deployment"],
+  "acceptance_scenarios": ["FAST/MEDIUM/LIFEBOAT are ready", "HEAVY timeout is explicit", "FAST is selected for CPU-first operation", "LIFEBOAT is the declared fallback", "Agent bridge and authenticated UI gaps remain unchanged"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000194-agent-canary-protected-storage.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000194",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "c1db571a39514e65156123b7f9394645183cf2ab",
+  "risk_tier": "E",
+  "intent": "Move the explicit production Agent Execution dry-run canary from direct database secret environment input to protected file/CredentialRef storage and preserve durable lease/callback evidence.",
+  "requirement_ids": ["Agent Execution runtime and recovery", "protected canary configuration", "durable lease/callback canary"],
+  "allowed_change_scope": {"modules": ["agent-canary", "deployment"], "paths": ["cmd/agent-canary/main.go", "cmd/agent-canary/main_test.go", "deploy/docker-compose.prod.yml", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000194-agent-canary-protected-storage.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 1, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["existing protected secret resolver", "existing ExecutionStore and dry-run canary contract"], "may_change": ["agent-canary runtime configuration"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.agent_dispatch_intents", "work.agent_leases", "work.agent_callback_heads"],
+  "state_transitions": ["explicit canary -> durable dispatch intent -> lease -> heartbeat callback -> result callback"],
+  "side_effects_and_privileges": ["manual opt-in dry-run only; protected database credential read; no external provider or source mutation"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["missing/invalid protected secret fails before database open; direct secret env is rejected; canary remains explicit opt-in"],
+  "assumptions": ["the production compose secret volume already contains the work database credential reference used by agent-worker"],
+  "acceptance_scenarios": ["direct password environment is rejected", "path outside protected root is rejected", "compose renders canary with protected file/ref only", "production opt-in canary writes lease and callback evidence", "normal agent-worker remains recovery-only without an external bridge"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production canary and public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000195-replayable-agent-canary-run-ids.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000195",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "7252296a74ab7ff236fae865d63692e0fc6a777d",
+  "risk_tier": "E",
+  "intent": "Make the explicit Agent Execution dry-run canary replayable by generating unique dispatch, lease and callback identities per invocation while retaining durable evidence.",
+  "requirement_ids": ["Agent Execution runtime and recovery", "replayable durable canary", "lease/callback evidence"],
+  "allowed_change_scope": {"modules": ["agent-canary"], "paths": ["cmd/agent-canary/main.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000195-replayable-agent-canary-run-ids.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["existing canary dry-run contract", "existing durable Work execution records"], "may_change": ["canary identity generation"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.agent_dispatch_intents", "work.agent_leases", "work.agent_callback_heads"],
+  "state_transitions": ["each explicit canary invocation creates a fresh dispatch identity and durable lease/callback chain"],
+  "side_effects_and_privileges": ["manual dry-run only; no external execution or source mutation"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["repeated invocation does not reuse prior canary identity; lease conflicts remain explicit errors"],
+  "assumptions": ["the protected-storage canary configuration from DEV-000194 is already in main"],
+  "acceptance_scenarios": ["default invocation generates a unique suffix", "operator-supplied run-id remains attributable", "two production canary invocations persist independent durable records"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production canary and public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000196-agent-canary-live-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000196",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "6854458e21ad7ec1c4b736dfabf916ae4f7fac12",
+  "risk_tier": "E",
+  "intent": "Record independently verified production evidence for the protected replayable Agent Execution dry-run canary.",
+  "requirement_ids": ["Agent Execution runtime and recovery", "durable canary evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/agent-execution-dry-run-canary-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000196-agent-canary-live-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["existing protected canary contract", "existing durable Work execution records"], "may_change": ["status projection and evidence only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["work.agent_dispatch_intents", "work.agent_leases", "work.agent_callback_heads"],
+  "state_transitions": ["none; evidence records already completed canary state"],
+  "side_effects_and_privileges": ["read-only status/evidence change after an explicit manual dry-run canary"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["no runtime retry; retain the negative external-bridge finding"],
+  "assumptions": ["the production canary output and database rows were captured without secret values"],
+  "acceptance_scenarios": ["evidence contains callback_count 2", "evidence contains durable dispatch intent, ACTIVE lease and callback sequence 2", "status explicitly retains the external bridge gap"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000197-durable-development-gate.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000197",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "fde14cf0b81e2772c81ee7cb9b0335b56943f6e4",
+  "risk_tier": "E",
+  "intent": "Persist the governed self-development gate as a Work-owned revisioned state machine with optimistic concurrency, without executing code or granting promotion authority.",
+  "requirement_ids": ["WP-701", "durable governed self-development provenance", "CAS stage transitions"],
+  "allowed_change_scope": {"modules": ["work", "postgres persistence"], "paths": ["contracts/work/self_development.go", "modules/work/ports/development.go", "adapters/postgres/work_repository.go", "database/migrations/037_work_development_gates.sql", "database/migrations/038_work_development_gates_privileges.sql", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000197-durable-development-gate.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "modules/identity/**", "contracts/authority/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 1},
+  "contracts": {"consume": ["existing DevelopmentGate state machine", "Work-owned persistence boundary"], "may_change": ["revision metadata on DevelopmentGate"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.development_gates"],
+  "state_transitions": ["persist initial evidence gate", "advance only through caller-validated stage with expected revision", "reject stale revision"],
+  "side_effects_and_privileges": ["database persistence only; no worktree, provider, source, deployment or promotion mutation"],
+  "persistence_and_migrations": ["037_work_development_gates.sql", "038_work_development_gates_privileges.sql"],
+  "failure_retry_restart": ["CAS conflict is explicit and retry requires reloading the gate; restart reloads durable provenance"],
+  "assumptions": ["domain AdvanceDevelopmentGate remains the sole stage transition validator", "external bridge is a later independently operated capability"],
+  "acceptance_scenarios": ["initial gate persists at revision 1", "update with expected revision succeeds", "stale revision is rejected", "all provenance fields round-trip without secrets", "work_role can read and write the table"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent -task dev/tasks/DEV-000197-durable-development-gate.json", "git diff --check", "CI", "production migration and health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "REQUIRES_MIGRATION_DECISION"]
+}

dev/tasks/DEV-000198-development-gate-live-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000198",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "bb131147f80cb75c0ba3d80607d0f806bd378aa8",
+  "risk_tier": "E",
+  "intent": "Record live production evidence for durable governed self-development gate persistence and Work-owner access.",
+  "requirement_ids": ["WP-701", "live durable gate evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/governed-development-gate-persistence-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000198-development-gate-live-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["Work development gate persistence contract", "production health"], "may_change": ["status and evidence projection only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["work.development_gates"],
+  "state_transitions": ["none; evidence records applied migration and owner read access"],
+  "side_effects_and_privileges": ["read-only production verification"],
+  "persistence_and_migrations": ["no migration"],
+  "failure_retry_restart": ["retain explicit external bridge gap"],
+  "assumptions": ["migration 037 and privilege forward migration 038 are present in production"],
+  "acceptance_scenarios": ["work_role can query the relation", "public health is ok", "status distinguishes durable gate persistence from bridge-backed execution"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent -task dev/tasks/DEV-000198-development-gate-live-evidence.json", "git diff --check", "CI", "production health and schema check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000199-medium-advisory-thinking-control.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000199",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "c7170ee751b715b0cf6721d8491530c185870b2a",
+  "risk_tier": "E",
+  "intent": "Disable provider template reasoning for bounded OpenAI-compatible local advisory requests so a loaded MEDIUM model can return bounded advisory content instead of consuming the entire output cap with hidden reasoning.",
+  "requirement_ids": ["WP-200", "model fleet/failover", "bounded advisory output"],
+  "allowed_change_scope": {"modules": ["models adapter"], "paths": ["adapters/models/openai_compatible_local.go", "adapters/models/openai_compatible_local_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000199-medium-advisory-thinking-control.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["existing OpenAI-compatible local advisory contract"], "may_change": ["provider request serialization adds typed template control"]},
+  "semantic_owner": "cognitive adapter",
+  "canonical_state": [],
+  "state_transitions": ["bounded advisory request asks compatible runtimes to disable hidden template reasoning"],
+  "side_effects_and_privileges": ["bounded local provider inference only; no activation or promotion"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["provider ignoring the optional request field remains an explicit qualification result"],
+  "assumptions": ["llama.cpp-compatible OpenAI endpoints ignore or honor the typed chat_template_kwargs field without breaking the existing contract"],
+  "acceptance_scenarios": ["request contains enable_thinking=false", "adapter still validates bounded completion", "provider failure remains typed and failover-compatible"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent -task dev/tasks/DEV-000199-medium-advisory-thinking-control.json", "git diff --check", "CI", "production medium bounded smoke and public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000200-medium-live-bounded-smoke-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000200",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "c8aa731eeb5f0d1c1dc12591fb50bfbe5dab6d69",
+  "risk_tier": "E",
+  "intent": "Record bounded live smoke evidence for the MEDIUM provider after disabling hidden template thinking, without claiming lifecycle qualification or promotion.",
+  "requirement_ids": ["WP-200", "medium provider bounded live evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/medium-live-bounded-smoke-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000200-medium-live-bounded-smoke-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["MEDIUM provider bounded smoke contract", "production health"], "may_change": ["status and evidence projection only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["model fleet evidence projection"],
+  "state_transitions": ["none; record bounded smoke result and retain unpromoted state"],
+  "side_effects_and_privileges": ["read-only production verification"],
+  "persistence_and_migrations": ["no migration"],
+  "failure_retry_restart": ["retain explicit qualification, activation, promotion and failover gaps"],
+  "assumptions": ["PR c8aa731 is deployed to production before final live health verification"],
+  "acceptance_scenarios": ["instruction_exact returns DOMOVOY_OK with stop", "structured_arithmetic returns answer 42 with stop", "noncanonical_action returns action not performed with stop", "ambiguous_destructive_request returns clarification marker with stop", "status keeps MEDIUM explicitly unpromoted"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent -task dev/tasks/DEV-000200-medium-live-bounded-smoke-evidence.json", "git diff --check", "CI", "production health and bounded provider smoke"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000201-authenticated-ui-visual-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000201",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "79feab8e4129af4ad0b9e8c9dcd81a6ba1883642",
+  "risk_tier": "E",
+  "intent": "Record user-provided authenticated production UI visual evidence while keeping browser interaction and operations acceptance explicitly open.",
+  "requirement_ids": ["WP-800", "WP-805", "authenticated UI visual evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/authenticated-ui-visual-observation-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000201-authenticated-ui-visual-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["authenticated UI acceptance contract", "production health"], "may_change": ["status and evidence projection only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["user-provided authenticated UI observation"],
+  "state_transitions": ["PENDING -> PARTIAL_VISUAL_PROOF; full interaction acceptance remains open"],
+  "side_effects_and_privileges": ["read-only observation of user-provided screenshot"],
+  "persistence_and_migrations": ["no migration"],
+  "failure_retry_restart": ["retain browser-control-channel gap and do not claim API acceptance"],
+  "assumptions": ["the attached screenshot is a current production view at https://assistant.cin.su/"],
+  "acceptance_scenarios": ["status records active session visual proof", "status does not claim authenticated API or mutation acceptance", "public health remains checked after deployment"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent -task dev/tasks/DEV-000201-authenticated-ui-visual-evidence.json", "git diff --check", "CI", "production public health"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000202-authenticated-ui-quick-smoke.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000202",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "e5300586599e4bd1ad5b6c1530d31d2619b9a88b",
+  "risk_tier": "E",
+  "intent": "Record fast authenticated UI and operations smoke evidence without running deferred deep acceptance suites or mutating operational state.",
+  "requirement_ids": ["WP-800", "WP-805", "authenticated quick smoke"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/authenticated-ui-quick-smoke-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000202-authenticated-ui-quick-smoke.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["authenticated UI acceptance contract", "diagnostic and fleet read APIs", "production health"], "may_change": ["status and evidence projection only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["authenticated quick smoke observation"],
+  "state_transitions": ["PARTIAL_VISUAL_PROOF -> AUTHENTICATED_QUICK_SMOKE_PASS"],
+  "side_effects_and_privileges": ["read-only diagnostics and fleet checks; chat smoke response; no operation mutation"],
+  "persistence_and_migrations": ["no migration"],
+  "failure_retry_restart": ["retain external bridge gap and defer deep acceptance"],
+  "assumptions": ["user-authenticated browser session is current production session", "the user-requested fast-test mode defers deep suites"],
+  "acceptance_scenarios": ["chat smoke responds", "admin console authenticates", "diagnostics reports 7/7", "fleet reports 4/4 ready", "agent worker gap remains visible", "action history renders"],
+  "required_tests": ["quick browser smoke", "go test ./cmd/creator-web", "go vet ./cmd/creator-web", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "production public health"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000203-local-agent-execution-fallback.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000203",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "bee238b61e4760bd864355b893f1fbb188b3f4ce",
+  "risk_tier": "E",
+  "intent": "Provide a first-party local Agent Execution fallback that preserves durable work without claiming external execution when the optional bridge is unavailable.",
+  "requirement_ids": ["WP-301", "local agent execution fallback", "degraded operation"],
+  "allowed_change_scope": {"modules": ["agent-worker"], "paths": ["cmd/agent-worker/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000203-local-agent-execution-fallback.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "deploy/**", "security/**", "contracts/**", "modules/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["AgentExecutionRequest", "AgentExecutionResult", "durable worker lease/callback path"], "may_change": ["worker degraded-mode status projection"]},
+  "semantic_owner": "work",
+  "canonical_state": ["existing work dispatch, lease and callback state"],
+  "state_transitions": ["dispatch -> durable lease/heartbeat -> explicit WAITING checkpoint when external bridge is absent"],
+  "side_effects_and_privileges": ["no external mutation; no new credentials"],
+  "persistence_and_migrations": ["reuse existing work persistence; no migration"],
+  "failure_retry_restart": ["WAITING remains evidence-bearing and stale lease recovery remains authoritative"],
+  "assumptions": ["local fallback is degraded coordination/recovery, not a claim of completed agent work", "external bridge remains optional"],
+  "acceptance_scenarios": ["missing bridge selects local-fallback mode", "fallback produces WAITING with no outcome reference", "status exposes local_fallback=true", "external bridge path remains unchanged"],
+  "required_tests": ["go test ./cmd/agent-worker", "go vet ./cmd/agent-worker", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "quick production worker status"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000204-gpu-discovery-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000204",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "b4d166480e5d06049718618ffeea0ccdbb993336",
+  "risk_tier": "E",
+  "intent": "Record protected GPU model discovery without equating hardware availability with intelligence, qualification or routing priority.",
+  "requirement_ids": ["WP-200", "model fleet/failover", "hardware-neutral routing"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/gpu-discovery-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000204-gpu-discovery-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "cmd/**", "modules/**", "contracts/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["protected provider discovery", "model fleet policy"], "may_change": ["status and evidence projection only"]},
+  "semantic_owner": "governance",
+  "canonical_state": ["capability discovery projection"],
+  "state_transitions": ["HEAVY degraded -> provider AVAILABLE; models remain DISCOVERED/INACTIVE"],
+  "side_effects_and_privileges": ["protected read/discovery request only"],
+  "persistence_and_migrations": ["no migration"],
+  "failure_retry_restart": ["retain unqualified/unpromoted state until task-specific evidence exists"],
+  "assumptions": ["cognitive-worker uses the configured protected GPU credential"],
+  "acceptance_scenarios": ["two GPU models are observed", "both remain unpromoted", "status rejects GPU-as-intelligence inference"],
+  "required_tests": ["go test ./cmd/cognitive-worker", "go vet ./cmd/cognitive-worker", "protected provider discovery smoke", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "production public health"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000205-gpu-invocation-smoke-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000205",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "288d18a4fba0535e3e2d15643de5b78499beb961",
+  "risk_tier": "E",
+  "intent": "Record a bounded protected GPU invocation smoke result without promoting or activating an unqualified model.",
+  "requirement_ids": ["WP-200", "WP-201", "model fleet/failover", "truthful negative evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/evidence/gpu-invocation-smoke-2026-08-23-v1.json", "docs/PROJECT_STATUS.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000205-gpu-invocation-smoke-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "cmd/**", "modules/**", "contracts/**", "adapters/**", "database/**", "deploy/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["protected GPU gateway OpenAI-compatible endpoint", "existing GPU discovery evidence"], "may_change": []},
+  "semantic_owner": "governance evidence projection",
+  "canonical_state": [],
+  "state_transitions": ["discovery available -> invocation smoke not observed; no activation"],
+  "side_effects_and_privileges": ["one bounded synthetic request through an already configured protected credential"],
+  "persistence_and_migrations": ["immutable JSON evidence only"],
+  "failure_retry_restart": ["no retry; 400 remains an explicit negative observation"],
+  "assumptions": ["the gateway credential is resolved inside the protected runtime and is not copied into evidence"],
+  "acceptance_scenarios": ["model discovery remains visible", "failed invocation is recorded without claiming quality", "GPU remains inactive and cannot become routing priority from discovery alone"],
+  "required_tests": ["JSON validation", "go test", "go vet", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP"]
+}

dev/tasks/DEV-000206-completion-matrix-refresh.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000206",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "faab913227f985fc06436618b5747376d4495487",
+  "risk_tier": "E",
+  "intent": "Refresh the audit completion matrix against the current production revision and preserve explicit evidence for every remaining gap.",
+  "requirement_ids": ["AUDIT-COMPLETION-TRUTH", "all objective areas", "current production evidence"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/evidence/audit-completion-matrix-2026-08-23-v2.json", "docs/PROJECT_STATUS.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000206-completion-matrix-refresh.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "cmd/**", "modules/**", "contracts/**", "adapters/**", "database/**", "deploy/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["current production status and evidence artifacts"], "may_change": []},
+  "semantic_owner": "governance evidence projection",
+  "canonical_state": [],
+  "state_transitions": ["none; refreshes an append-only audit projection"],
+  "side_effects_and_privileges": ["none beyond repository evidence and status"],
+  "persistence_and_migrations": ["immutable JSON evidence only"],
+  "failure_retry_restart": ["retain explicit NOT_COMPLETE result when any required evidence is missing"],
+  "assumptions": ["production revision faab913 is the deployed main artifact", "deep acceptance remains deferred by current testing policy"],
+  "acceptance_scenarios": ["all seven objective areas have current statuses", "repository and production proof are distinguished", "remaining external gaps are explicit", "no secret values appear"],
+  "required_tests": ["JSON validation", "go test", "go vet", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000207-gpu-invocation-qualification.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000207",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "9f96393fb9a7ddce19eda3f90cbdeecb024029e6",
+  "risk_tier": "E",
+  "intent": "Record a bounded production GPU invocation using the exact Domovoy adapter request shape without automatic promotion.",
+  "requirement_ids": ["WP-200", "WP-201", "model fleet/failover", "hardware-neutral routing"],
+  "allowed_change_scope": {"modules": ["governance status", "evidence"], "paths": ["docs/evidence/gpu-invocation-qualification-2026-08-23-v1.json", "docs/evidence/audit-completion-matrix-2026-08-23-v3.json", "docs/PROJECT_STATUS.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000207-gpu-invocation-qualification.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "cmd/**", "modules/**", "contracts/**", "adapters/**", "database/**", "deploy/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["existing OpenAI-compatible local adapter request contract", "protected GPU gateway", "current completion matrix"], "may_change": []},
+  "semantic_owner": "governance evidence projection",
+  "canonical_state": [],
+  "state_transitions": ["discovered/inactive -> bounded invocation observed; remains unpromoted"],
+  "side_effects_and_privileges": ["one bounded synthetic request through an existing protected credential"],
+  "persistence_and_migrations": ["immutable JSON evidence only"],
+  "failure_retry_restart": ["no retry and no automatic activation"],
+  "assumptions": ["the protected runtime credential is used in place and is not copied into repository artifacts"],
+  "acceptance_scenarios": ["exact adapter payload returns one bounded completion", "quality remains unassessed", "GPU does not receive routing priority merely because it is available"],
+  "required_tests": ["JSON validation", "go test", "go vet", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000208-task-aware-model-evaluation.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000208",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "b78a026ee169047feb8468f0799fa1b9f4e27562",
+  "risk_tier": "E",
+  "intent": "Make Domovoy's model qualification and routing task-aware through parallel durable specialist work: typed evaluation profiles/evidence, durable task scores, and explainable selection without hardware/provider heuristics.",
+  "requirement_ids": ["task-specific model evaluation", "parallel specialist evaluation", "no main execution thread", "model fleet/failover", "hardware-neutral routing", "explainable model rating"],
+  "allowed_change_scope": {"modules": ["capability", "core-runtime"], "paths": ["contracts/capability/**", "modules/capability/**", "adapters/postgres/capability_repository.go", "cmd/core-runtime/main.go", "database/migrations/039_capability_task_evaluations.sql", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000208-task-aware-model-evaluation.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", ".gitea/**", "contracts/authority/**", "modules/identity/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 1},
+  "contracts": {"consume": ["CognitiveRequirement", "ResolvedCognitiveBinding", "existing capability evidence", "existing capability owner repository", "Work Graph durable fan-out/fan-in"], "may_change": ["task profile/evaluation contracts", "task-aware selection request/response serialization"]},
+  "semantic_owner": "capability",
+  "canonical_state": ["capability task evaluation evidence keyed by task profile and binding revision"],
+  "state_transitions": ["GENERAL profile -> first bounded evaluation", "unresolved task evidence -> ADDITIONAL profile with parent and trigger evidence", "profile result UNKNOWN -> SUPPORTED/UNSUPPORTED; evidence is append-only by binding revision", "task-aware requirement -> eligible candidates with explainable task rating", "evaluation request -> durable fan-out -> specialist evidence -> fan-in aggregate"],
+  "side_effects_and_privileges": ["core capability database role writes only; no provider calls and no secret access in this task"],
+  "persistence_and_migrations": ["039 adds capability.cognitive_task_evaluations owned by capability"],
+  "failure_retry_restart": ["missing, stale or unknown task evidence excludes a task-aware candidate; no score defaults to success", "one specialist failure does not block unrelated tasks; stale leases are recoverable and fan-in preserves partial/unknown state"],
+  "assumptions": ["a later Work Graph evaluation runner will produce per-case evidence; this task establishes the durable contract and routing gate", "the chat/request path never waits synchronously for the full evaluation graph"],
+  "acceptance_scenarios": ["general profile runs before additional profiles", "an unresolved task creates only a bounded additional profile linked to failure evidence", "task-aware requirement rejects a model without current supported task evidence", "task scores are included in explainable rating", "provider kind, endpoint and hardware do not affect score", "unknown/failed task evidence never silently becomes supported", "existing requirements without a task profile retain current behavior"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "migration/schema checks", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000209-task-evaluator-work-graph.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000209",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "a82592a1300c06ed7a568c058faca6560e085ab3",
+  "risk_tier": "E",
+  "intent": "Create durable Work Graph plans for task-aware model evaluation: run the general profile first, fan out independent model specialists in parallel, and permit bounded additional profiles linked to unresolved evidence without blocking the chat path.",
+  "requirement_ids": ["general-first model evaluation", "parallel specialist evaluation", "bounded additional task tests", "fan-out/fan-in", "no synchronous chat blocking", "provider and hardware neutral"],
+  "allowed_change_scope": {"modules": ["work"], "paths": ["contracts/work/**", "modules/work/**", "cmd/work-graph-runtime/**", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000209-task-evaluator-work-graph.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/devctl/**", "modules/identity/**", "database/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["capability.TaskEvaluationProfile", "capability.TaskEvaluationProfileStage", "capability.TaskEvaluationProfileID", "existing Work Graph schedule contract"], "may_change": ["typed Work Graph node purpose and task-evaluation planning contract"]},
+  "semantic_owner": "work",
+  "canonical_state": ["work-owned durable graph and node lifecycle; capability remains owner of model evaluation evidence"],
+  "state_transitions": ["GENERAL profile -> admitted evaluation graph", "eligible model bindings -> parallel specialist nodes", "all specialist nodes -> fan-in completion state", "ADDITIONAL profile -> a separate bounded graph linked by parent/trigger evidence"],
+  "side_effects_and_privileges": ["none; graph planning only, no provider calls and no secret access"],
+  "persistence_and_migrations": ["uses existing work graph persistence; no new schema"],
+  "failure_retry_restart": ["each specialist remains independently retryable through existing node attempts/leases; partial or unknown graph state is preserved", "invalid stage/parent linkage is rejected before scheduling"],
+  "assumptions": ["a later worker adapter executes each dispatched specialist and posts evidence to capability", "chat/request handlers enqueue the graph and return without waiting for all nodes"],
+  "acceptance_scenarios": ["additional profile cannot be scheduled as a replacement for general profile", "one node is created per binding and profile with independent dispatch identity", "parallel budget is retained for fan-out", "graph metadata is sufficient for a worker to identify profile, binding and specialist role", "provider kind, endpoint and hardware are absent from planning inputs"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000210-task-evaluator-worker.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000210",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "9a6ab6a9caf68e65f302c95ab0859b259122dacf",
+  "risk_tier": "E",
+  "intent": "Carry task-evaluation specialist metadata through durable dispatch, persistence and recovery so workers can execute bounded model cases and return evidence without losing profile lineage.",
+  "requirement_ids": ["worker execution context", "durable task metadata", "recovery-safe dispatch", "bounded case set", "no synchronous chat blocking"],
+  "allowed_change_scope": {"modules": ["work"], "paths": ["contracts/work/**", "modules/work/**", "adapters/postgres/work_repository.go", "cmd/agent-worker/**", "database/migrations/040_task_evaluation_dispatch.sql", "tests/model_qualification/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000210-task-evaluator-worker.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/devctl/**", "modules/identity/**", "modules/capability/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 1},
+  "contracts": {"consume": ["Work Graph task-evaluation node metadata", "AgentExecutionRequest/Result", "existing lease and recovery contract"], "may_change": ["typed dispatch task-evaluation metadata"]},
+  "semantic_owner": "work",
+  "canonical_state": ["work-owned dispatch metadata and graph lineage; capability remains owner of evaluation evidence"],
+  "state_transitions": ["graph specialist node -> enriched dispatch intent", "claimed dispatch -> executor receives profile/binding/cases", "stale claim -> recovery preserves task metadata for retry"],
+  "side_effects_and_privileges": ["work role migration only; no provider calls and no secret access added"],
+  "persistence_and_migrations": ["040 adds typed task metadata columns to existing work dispatch/graph tables"],
+  "failure_retry_restart": ["metadata is persisted before enqueue; idempotency conflict rejects divergent task context", "lease timeout/recovery does not erase profile or case references"],
+  "assumptions": ["an upcoming cognitive specialist executor uses the typed metadata to invoke the model gateway and post Capability evidence", "external bridge absence remains typed WAITING/local-fallback"],
+  "acceptance_scenarios": ["task graph dispatch carries profile, binding and all cases", "persist/load round trip preserves metadata", "divergent idempotency retry is rejected", "legacy non-task dispatch remains valid", "recovery path does not claim success"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "migration/schema checks", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000211-task-evaluator-callback.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000211",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "6dec47c79163f456cf6b18085a268ebb2619c7bb",
+  "risk_tier": "E",
+  "intent": "Accept specialist task-evaluation evidence through a Work Graph callback: persist evidence through the Capability owner and complete the matching graph node only after typed lineage and revision checks pass.",
+  "requirement_ids": ["evidence callback", "fan-in completion", "owner-local persistence", "revision safety", "no cross-owner DB access"],
+  "allowed_change_scope": {"modules": ["work"], "paths": ["contracts/work/**", "modules/work/**", "cmd/work-graph-runtime/**", "tests/model_qualification/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000211-task-evaluator-callback.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/devctl/**", "modules/identity/**", "database/**", "modules/capability/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["capability.TaskEvaluation", "existing Work Graph revision/completion contract", "Core Runtime capability evaluation HTTP boundary"], "may_change": ["typed task-evaluation callback contract"]},
+  "semantic_owner": "work for graph lifecycle; capability for evaluation evidence",
+  "canonical_state": ["Capability owns evaluation evidence; Work owns graph/node lifecycle and callback lineage"],
+  "state_transitions": ["specialist result -> callback received", "callback -> Capability evidence persisted", "persisted evidence -> matching node completion and graph fan-in"],
+  "side_effects_and_privileges": ["remote Core Runtime call through existing internal boundary; no direct foreign DB access and no new secrets"],
+  "persistence_and_migrations": ["uses existing capability task-evaluation and work graph persistence; no migration"],
+  "failure_retry_restart": ["Capability write failure leaves node incomplete and callback retryable", "stale graph revision is rejected; unknown/unsupported evaluation is not promoted by callback"],
+  "assumptions": ["specialist executor has already produced evidence and artifact references", "the callback is asynchronous and never blocks the chat request"],
+  "acceptance_scenarios": ["callback rejects non-task graph node", "callback rejects profile/binding lineage mismatch", "Capability write occurs before node completion", "sink failure leaves graph node unfinished", "valid callback advances graph fan-in", "duplicate evidence remains idempotent at Capability owner"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000212-task-evaluator-invocation.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000212",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "dff6c91c8e08611d73231a04a1af67efeebed22b",
+  "risk_tier": "E",
+  "intent": "Execute bounded task-evaluation cases against an exact Capability binding through Cognitive Gateway and return typed observations for the Work Graph callback.",
+  "requirement_ids": ["actual model invocation", "exact binding evaluation", "bounded cases", "provider-neutral evidence", "unknown on provider failure"],
+  "allowed_change_scope": {"modules": ["capability", "core-runtime", "cognitive-worker"], "paths": ["contracts/capability/**", "adapters/postgres/capability_repository.go", "cmd/core-runtime/**", "cmd/cognitive-worker/**", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000212-task-evaluator-invocation.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/devctl/**", "database/**", "modules/identity/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["TaskEvaluationProfile", "TaskCaseObservation", "Cognitive Gateway provider boundary", "Capability cognitive binding snapshot boundary"], "may_change": ["task evaluation execution request/response"]},
+  "semantic_owner": "capability owns evaluation meaning; cognitive-worker owns provider invocation adapter boundary",
+  "canonical_state": ["none; this task returns observations only and does not promote or persist activation"],
+  "state_transitions": ["execution request -> exact binding snapshot", "case -> provider invocation -> SUPPORTED or UNKNOWN observation", "all observations -> Work Graph callback input"],
+  "side_effects_and_privileges": ["provider calls only through existing cognitive adapter; no direct DB and no new secret access"],
+  "persistence_and_migrations": ["none; durable persistence remains callback/Core Capability owner"],
+  "failure_retry_restart": ["provider timeout/auth/unavailable maps to UNKNOWN observation with evidence reference; caller may retry as a new attempt", "partial case set is never returned as supported aggregate"],
+  "assumptions": ["specialist supplies case prompts and artifact references from the approved bounded profile", "quality scoring beyond bounded invocation is performed by a verifier or later evaluator and is not fabricated here"],
+  "acceptance_scenarios": ["exact binding snapshot is required", "all supplied cases are invoked", "successful non-empty response yields supported observation with latency", "provider failure yields unknown observation", "unknown is never silently converted to supported", "no provider or hardware field participates in scoring"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000213-worker-evaluator-link.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000213",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "a86d1994c3f48db86592eb87fb54533297e0671c",
+  "risk_tier": "E",
+  "intent": "Carry the complete bounded task-evaluation profile and case payload through durable Work Graph dispatch so agent-worker can invoke Cognitive Worker, aggregate observations, and return the existing Work Graph callback after restart-safe recovery.",
+  "requirement_ids": ["dispatch-to-evaluator link", "payload durability", "worker recovery", "observation aggregation", "callback integration"],
+  "allowed_change_scope": {"modules": ["work", "agent-worker"], "paths": ["contracts/work/**", "modules/work/**", "adapters/postgres/work_repository.go", "cmd/agent-worker/**", "cmd/work-graph-runtime/**", "database/migrations/041_task_evaluation_payload.sql", "tests/agent_execution/**", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000213-worker-evaluator-link.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/devctl/**", "modules/identity/**", "modules/capability/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 1},
+  "contracts": {"consume": ["TaskEvaluationExecutionRequest/Response", "Work Graph callback", "existing AgentExecutor and recovery contract"], "may_change": ["typed dispatch payload and worker evaluator executor"]},
+  "semantic_owner": "work owns dispatch lifecycle; capability owns evaluation evidence; cognitive-worker owns provider invocation",
+  "canonical_state": ["work dispatch payload is durable input; Capability remains evidence owner"],
+  "state_transitions": ["task graph node -> durable payload dispatch", "worker claim -> evaluator invocation", "response -> aggregate TaskEvaluation", "aggregate -> Work Graph evidence callback"],
+  "side_effects_and_privileges": ["HTTP calls to internal cognitive/core/work boundaries; no direct foreign DB and no new secret"],
+  "persistence_and_migrations": ["041 adds JSONB payload columns to work graph nodes and dispatch intents"],
+  "failure_retry_restart": ["payload is loaded after stale claim recovery; evaluator failure leaves dispatch retryable", "callback only follows a persisted aggregate; unknown remains unknown"],
+  "assumptions": ["Cognitive Worker endpoint is available as optional local execution path", "external bridge remains preferred for non-evaluation agent tasks"],
+  "acceptance_scenarios": ["profile/cases survive save-load", "task dispatch invokes evaluator with original prompt payload", "all observations aggregate deterministically", "callback receives matching binding/profile/artifact", "evaluator or callback failure does not complete dispatch", "legacy dispatch remains unchanged"],
+  "required_tests": ["go test", "go vet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "migration/schema checks", "CI", "production public health check"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

docs/PROJECT_STATUS.md

@@ -2,304 +2,24 @@
 
 ## Current audit delta — 2026-08-23
 
-- `CURRENT_PRODUCTION_REVISION = 5b92cd6a587b1084aa677076fbfb2b05cf8f83d4`; public `/healthz` is healthy. Current runtime evidence: `docs/evidence/audit-runtime-status-2026-08-23-v1.json`.
+- `CURRENT_PRODUCTION_STATUS = LIVE_HEALTHY`; public `/healthz` is healthy. The exact deployed revision is authoritative in the deployment log and merge record, not duplicated in this mutable status projection. Evidence: `docs/evidence/audit-runtime-status-2026-08-23-v1.json`.
 - `FAST_PROVIDER_STATUS = LIVE_SMOKE_SUPPORTED`: local CPU gateway authentication is configured through a protected file reference; four bounded local-only advisory cases completed through cognitive-worker. Evidence: `docs/evidence/wp-601-fast-gateway-live-smoke-2026-08-22-v1.json`.
-- `MEDIUM_PROVIDER_STATUS = LIVE_AVAILABLE_UNQUALIFIED`; after adapter timeout was extended and benchmark output capped at 256 bytes, all four cases still timed out at 60 seconds. Evidence: `docs/evidence/wp-200-medium-qualification-2026-08-22-v3.json`; no activation was attempted.
-- `HEAVY_PROVIDER_STATUS = LIVE_QUALIFIED_UNACTIVATED`; discovery refreshed the stale GPU registry and current `gemma4:26b` passed all four bounded cases (`SUPPORTED`, 1000‰ quality, 0‰ critical failures). Evidence: `docs/evidence/wp-200-heavy-qualification-2026-08-22-v2.json`; binding remains INACTIVE and no activation was attempted.
-- `AGENT_EXECUTION_STATUS = RECOVERY_ONLY`; optional `AGENT_EXECUTION_BRIDGE_URL` is wired into production compose but remains unset, and no Codex/bridge runtime is deployed. Durable recovery and status endpoints remain active.
-- `FLEET_EXECUTION_EVIDENCE = docs/evidence/audit-runtime-status-2026-08-23-v1.json`; FAST, MEDIUM, HEAVY and LIFEBOAT are readiness-ready, preferred and selected tier is FAST, and LIFEBOAT remains the fallback tier.
-- `TRUTH_RESEARCH_STATUS = LIVE_CANARY_PERSISTED`; web research evaluated a public health source and persisted an OBSERVED/COMPLETE/NO-CONFLICT truth bundle; claim remains UNVERIFIED and belief PROVISIONAL. Evidence: `docs/evidence/truth-runtime-canary-2026-08-23-v1.json`.
-- `BACKUP_RESTORE_EVIDENCE = docs/evidence/wp-002-postgres-restore-2026-08-22-v1.json`; latest backup checksum and isolated restore verified with 11 schemas and 60 tables.
-- `UI_AUTHENTICATED_ACCEPTANCE = PENDING`; public login UI is reachable, but no authenticated browser session was available for cabinet visual acceptance.
-- `SECURITY_NOTE = one production executor secret was rotated after an accidental diagnostic disclosure; values are not retained in repository evidence.`
-
-Audit date: 2026-08-23. Historical governance checkpoint: DEV-000099 revision 1.
+- `MEDIUM_PROVIDER_STATUS = LIVE_BOUNDED_SMOKE_SUPPORTED_UNPROMOTED`; four bounded local-provider cases passed with template thinking disabled. This is availability/response-shape evidence only; lifecycle qualification, activation and promotion remain unclaimed. Evidence: `docs/evidence/medium-live-bounded-smoke-2026-08-23-v1.json`.
+- `HEAVY_PROVIDER_STATUS = LIVE_BOUNDED_INVOCATION_SUPPORTED_UNPROMOTED`; the exact Domovoy adapter payload produced one bounded Qwen completion in 0.583s. Quality is not assessed, lifecycle promotion is not performed, and GPU availability is not treated as intelligence or routing priority. Evidence: `docs/evidence/gpu-discovery-2026-08-23-v1.json`, `docs/evidence/gpu-invocation-qualification-2026-08-23-v1.json`.
+- `AGENT_EXECUTION_STATUS = DURABLE_DRY_RUN_CANARY_VERIFIED`; the explicit production canary persisted a dispatch intent, an ACTIVE lease and callback head sequence 2. No independently operated bridge endpoint is configured, so bridge-backed execution remains unavailable. Evidence: `docs/evidence/agent-execution-dry-run-canary-2026-08-23-v1.json`.
+- `FLEET_EXECUTION_EVIDENCE = docs/evidence/audit-runtime-status-2026-08-23-v1.json`; FAST, MEDIUM and LIFEBOAT are ready, HEAVY is explicitly degraded by provider timeout, FAST remains preferred/selected, and LIFEBOAT is the fallback tier.
+- `TRUTH_RESEARCH_STATUS = LIVE_CANARY_PERSISTED`; the web research canary preserved an OBSERVED/COMPLETE/NO-CONFLICT source chain while leaving the claim UNVERIFIED and belief PROVISIONAL. Evidence: `docs/evidence/truth-runtime-canary-2026-08-23-v1.json`.
+- `LEARNING_REFLECTION_STATUS = LIVE_RECONCILED`; reflection worker returned no pending candidate and the durable state contains 31 RESOLVED candidates with no OPEN backlog. Evidence: `docs/evidence/reflection-runtime-reconciliation-2026-08-23-v1.json`.
+- `BACKUP_RESTORE_STATUS = VERIFIED`; latest checksum and isolated restore evidence is retained in `docs/evidence/wp-002-postgres-restore-2026-08-22-v1.json`.
+- `GOVERNED_SELF_DEVELOPMENT_STATUS = DURABLE_GATE_PERSISTED`; Work-owned revisioned gate storage and optimistic-concurrency persistence are live. No bridge-backed source mutation, promotion or rollback is claimed. Evidence: `docs/evidence/governed-development-gate-persistence-2026-08-23-v1.json`.
+- `UI_AUTHENTICATED_ACCEPTANCE = AUTHENTICATED_QUICK_SMOKE_PASS`; browser-driven smoke completed in the active production session: chat response received, admin login accepted, diagnostics 7/7 passed, operations fleet 4/4 READY, and action history loaded. Deep mutation, delegation-specific and long-running acceptance remain intentionally deferred.
 
 ## Current governance checkpoint
 
-- `DEV_000099_STATUS = COMPLETED`
-- `LAST_COMPLETED = DEV-000098 Governance Sentinel V2: full task-packet validation, scope-conflict rejection, architecture/base checks, required-test enforcement and independent verifier`
-- `ACTIVE_TASK = dev/tasks/DEV-000190-live-audit-status-sync.json revision 1`
-- `LINEAGE_DECISION = docs/GOVERNANCE_LINEAGE_DECISION_2026-08-22.md; DEV-000073 historical variants are preserved as evidence and are not current authority`
-- `REGISTRY_STATUS = YAML and JSON semantic mirrors agree; human registry projection synchronized with ADR-0017 ownership and current protected paths`
-- `PRODUCTION_DOMAIN = docker.cin.su; shared docker-test remains prohibited`
-- `RUNTIME_CHANGE = none; this governance consolidation changes repository authority/projections only`
-- `NEXT_RECOMMENDED_STEP = create a separately scoped WP-002 production recovery task packet; production changes remain pending that packet`
+- `COMPLETION_MATRIX = docs/evidence/audit-completion-matrix-2026-08-23-v3.json`; all seven objective areas are mapped to current repository/production proof, with external bridge, GPU promotion/quality and deep-acceptance gaps explicit.
 
-Audit date: 2026-08-17. Active implementation: DEV-000072 revision 1.
-
-## DEV-000072 checkpoint
-
-- `DEV_000072_STATUS = LOCAL_ACCEPTANCE_PASS`
-- `LAST_COMPLETED = semantic deferral boundary V1 implementation plus regression/generalization acceptance: deterministic semantic candidates, cognitive interpretation gateway path, owner-local candidate provenance persistence, mixed-intent planning input propagation, punctuation/metamorphic stability fixes, capability-gap/reminder/work-path repair, and live A/B/C trace evidence`
-- `ARCHITECTURE_CHANGE = none; interaction owner remains unchanged and no new cross-owner dependency was accepted`
-- `SEMANTIC_BOUNDARY_CHANGE = deterministic interpretation no longer acts as unquestionable final truth for low-confidence / broader-interpretation / mixed-intent cases; core runtime can request typed cognitive reinterpretation through the existing provider-neutral gateway`
-- `PERSISTENCE_CHANGE = migration 027 adds secondary speech act / applicability / selection reason on interaction interpretations plus semantic candidate provenance tables`
-- `GIT_ANCESTRY_STATUS = PASS: current branch merge-base equals origin/main at 64870798b9a50f895c99d24441703f366df5c98a; DEV-000071 commit c1aff60443829892ba70104f40b55de01f186a7f is contained in origin/main`
-- `CHECK_DIFF_STATUS = PASS: diff scope checks OK for DEV-000072 against base 64870798b9a50f895c99d24441703f366df5c98a`
-- `KNOWN_BASELINE_COMPARISON = suite_v1 baseline failed_available 4 / intent 0 / capability 3 / consequence 1 -> current failed_available 0 / intent 0 / capability 0 / consequence 0`
-- `HOLDOUT_AND_GENERALIZATION_COMPARISON = suite_v2 baseline failed_available 18 / intent 3 / capability 7 / consequence 4 / unknown 7 -> current failed_available 0 / intent 0 / capability 0 / consequence 0 / unknown 0`
-- `UNNECESSARY_COGNITION = no observed increase in suite_v1 or suite_v2 current-run`
-- `UNNECESSARY_CLARIFICATION = current replay counts remain observable (suite_v1 1, suite_v2 5) and are recorded explicitly for operator review rather than hidden by aggregate PASS`
-- `LIVE_TRACE_EVIDENCE = PASS: raw CPU Qwen understood "ты кто" and punctuation-free modal request; Domovoy semantic path now routes "ты кто" and "можешь расказать об утре" into cognition-worthy interpretation; gateway-to-same-CPU trace preserved question semantics`
-- `METAMORPHIC_EVIDENCE = docs/evidence/semantic-deferral-metamorphic-evidence-2026-08-17-v1.json`
-- `RAW_MODEL_BOUNDARY = recorded explicitly: raw cognitive models identify themselves as provider/model provenance; this is not patched inside Interaction and remains a later context-compilation milestone`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; ASSISTANT_LIVE_SEMANTIC_TRACE=1 go test ./cmd/cognitive-worker -run TestLiveInterpretationTrace -v`
-- `COGNITIVE_CONTEXT_GAP = still open by design in this milestone: raw providers identify themselves as Qwen/Gemma provenance when Domovoy identity/context is not compiled into the prompt`
-- `PRODUCTION_STATUS = pending promotion/deploy from this checkpoint`
-- `NEXT_RECOMMENDED_STEP = finish DEV-000072 production promotion, apply migration 027, redeploy runtime, and verify live /chat against the promoted artifact`
-
-## DEV-000071 checkpoint
-
-- `DEV_000071_STATUS = COMPLETED`
-- `LAST_COMPLETED = factual production cognitive-path audit, real router reality report, preserved suite_v1 baseline, new 50-case generalization/holdout structural corpus, new 16-case free-form cognitive baseline against the eligible local CPU binding, and provenance-preserving production failure evidence`
-- `ARCHITECTURE_CHANGE = none; milestone remains audit/evaluation/evidence only`
-- `RUNTIME_CHANGE = none; no behavior patching and no lifecycle/activation changes were made to improve scores`
-- `PRODUCTION_COGNITIVE_PATH_AUDIT = docs/evidence/production-cognitive-path-audit-2026-08-17-v1.json`
-- `REAL_PRODUCTION_FINDING = "обратись к модели gemma4 и спроси сколько звезд на небе" was persisted as ASSERTION by deterministic-v1, never invoked the Cognitive Gateway, and therefore never reached the provider-neutral router`
-- `REGISTERED_COGNITIVE_IMPLEMENTATIONS = local-cpu-primary VALIDATED/AVAILABLE; local-gpu-opportunistic DISCOVERED/UNKNOWN; openai-bootstrap DISCOVERED/UNKNOWN disabled`
-- `ELIGIBLE_COGNITIVE_IMPLEMENTATIONS = exactly one observed eligible binding in production: local CPU binding-9e5e9779cd10b907c3695374 in CANARY`
-- `OLLAMA_HUMAN_CHAT_INVOCATION_COUNT = 0 observed gateway invocations`
-- `CPU_GATEWAY_INVOCATION_COUNT = 14`
-- `ROUTER_REALITY = provider-neutral architecture exists, but current production does not demonstrate meaningful live choice among multiple eligible cognitive bindings`
-- `DETERMINISTIC_BOUNDARY = deterministic interpretation can defer to cognition, but a wrong deterministic interpretation can still terminate the path before cognition; no evidence that cognition revises interpretation later in the current /chat path`
-- `CENTRAL_HYPOTHESIS = SUPPORTED`
-- `SUITE_V1_STATUS = preserved unchanged`
-- `GENERALIZATION_SUITE = tests/reality_evaluation/suite_v2_generalization.json`
-- `GENERALIZATION_BASELINE_RESULTS = TOTAL_CASES 50; DEVELOPMENT_CASES 29; HOLDOUT_CASES 21; SOLVED_AUTONOMOUSLY 26; CORRECT_HUMAN_INTERVENTION 1; GENUINE_CAPABILITY_GAPS 5; FAILED_WITH_AVAILABLE_CAPABILITY 18`
-- `GENERALIZATION_FAILURE_COUNTS = INTENT_FAILURES 3; CONTEXT_FAILURES 0; CAPABILITY_SELECTION_FAILURES 7; CONSEQUENCE_REASONING_FAILURES 4; CAPABILITY_FAILURES 7; UNKNOWN_FAILURES 7`
-- `GENERALIZATION_WORST_FAILURES = real production ask-model wording collapses to ASSERTION; ask-model typo variant also collapses to ASSERTION; "подумай и скажи как лучше поступить" falls through to non-cognitive deterministic handling; mixed investigate+patch request plans investigation but drops MODIFY_CODE requirement; correction wording still swallows code-edit intent in "исправь ..."`
-- `COGNITIVE_BASELINE_ARTIFACT = docs/evidence/cognitive-generalization-baseline-2026-08-17-v1.json`
-- `COGNITIVE_BASELINE_RESULTS = TOTAL_CASES 16; DEVELOPMENT_CASES 9; HOLDOUT_CASES 7; PASSED_CASES 7`
-- `COGNITIVE_FAILURE_COUNTS = UNSUPPORTED_CERTAINTY 0; ANTI_SYCOPHANCY_FAILURES 1; UNCERTAINTY_FAILURES 6; CAPABILITY_FAILURES 2; CONSEQUENCE_FAILURES 0; FABRICATED_OBSERVATION_FAILURES 1; FABRICATED_ACTION_FAILURES 0`
-- `COGNITIVE_FINDINGS = current eligible CPU binding is strongest on preference preservation, no-access honesty and non-fabricated destructive caution, but weak on explicit uncertainty phrasing, capability-gap wording, and preserving the boundary between suggestion and actual external execution`
-- `ENDPOINT_CHECKS = CPU /v1/models AVAILABLE; GPU Ollama /api/tags AVAILABLE; GPU availability does not imply production router eligibility`
-- `EVALUATOR_STATUS = PASS: structural baseline uses objective deterministic evidence; cognitive baseline is explicitly heuristic and marked as evidence-for-review rather than truth`
-- `HUMAN_REVIEW_STATUS = PASS: all new artifacts are operator-readable and replayable`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = 3aa981bc596575926549f6133a1dad1a863e913f`
-- `PRODUCTION_REDEPLOYED = no runtime redeploy required; milestone changes are tooling/evidence/status only`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; CPU endpoint /v1/models; GPU Ollama /api/tags; production /healthz`
-- `WHAT_RESULTS_ACTUALLY_SHOW = Domovoy is no longer just missing cosmetic natural-language coverage; the measured gap is structural: some natural action-like utterances are finalized by deterministic interpretation before cognition and routing can help. Multi-provider architecture exists, but production evidence still shows only one effective human-chat cognitive path through the CPU canary binding.`
-- `NEXT_RECOMMENDED_REVISION = targeted behavior work only after this baseline: treat deterministic interpretation as a revisable candidate for ambiguous action-like utterances, broaden ask-model / think / mixed-intent routing, and improve cognitive uncertainty/capability-gap phrasing without weakening truthfulness or non-execution guarantees`
-
-## DEV-000070 checkpoint
-
-- `DEV_000070_STATUS = COMPLETED`
-- `LAST_COMPLETED = replayable Reality Evaluation Harness V1 with 38 heterogeneous cases, deterministic objective evaluator, operator-readable baseline report, and committed baseline artifact`
-- `ADR_STATUS = no new ADR required`
-- `ARCHITECTURE_CHANGE = none; evaluation remains tooling/evidence, not a new canonical owner`
-- `NEW_CANONICAL_TYPES = none`
-- `EVALUATION_CASE_FORMAT = versioned JSON corpus at tests/reality_evaluation/suite_v1.json with scenario ID, multi-turn conversation, context/evidence, risk context, expected properties and prohibited properties`
-- `BASELINE_RESULTS = TOTAL_CASES 38; SOLVED_AUTONOMOUSLY 25; CORRECT_HUMAN_INTERVENTION 4; UNNECESSARY_HUMAN_INTERVENTION 0; GENUINE_CAPABILITY_GAPS 5; FAILED_WITH_AVAILABLE_CAPABILITY 4`
-- `FAILURE_COUNTS = TRUTHFULNESS_FAILURES 0; FALSE_EXECUTION_CLAIMS 0; INTENT_FAILURES 0; CONTEXT_FAILURES 0; CAPABILITY_SELECTION_FAILURES 3; CONSEQUENCE_REASONING_FAILURES 1; CONTINUATION_FAILURES 0; UNKNOWN_FAILURES 1`
-- `WORST_FAILURES = A02 identity question routed as ANSWER instead of COGNITION; J01 correction wording ("исправь") captures a software-edit request as CORRECTION instead of durable work; J02 investigate+patch wording falls through to ANSWER instead of durable work planning; M01 destructive delete with known no-backup risk lacks explicit consequence-aware clarification`
-- `EVALUATOR_INDEPENDENCE_STATUS = PASS: objective deterministic checks over speech act, focus/context, work creation, capability requirements, delegation candidates and non-execution claims; no self-grading model used`
-- `HUMAN_REVIEW_STATUS = PASS: operator-readable Markdown report plus per-case JSON artifact with review slots; normal /chat unchanged`
-- `REPLAY_STATUS = PASS: same versioned corpus can be rerun through cmd/cognitive-benchmark/realityeval without changing expectations`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = 4352e00491eaed6da032003a6bf032a4c6990fe7`
-- `PRODUCTION_REDEPLOYED = no runtime redeploy required; milestone changes are tooling/evidence/status only`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production creator-web /healthz HTTP 200; docker-prod image revision confirmation`
-- `WHAT_RESULTS_ACTUALLY_SHOW = current Domovoy is already strong on explicit intent preservation, append-only correction history, contextual project focus, honest capability-gap handling and avoiding false success claims; the clearest baseline weakness is consequence reasoning when destructive risk context is known but not surfaced by the deterministic layer`
-- `NEXT_RECOMMENDED_REVISION = target evidence-backed behavior fixes only: (1) identity/social questions should consistently route to cognition, (2) correction wording must not swallow software-edit intents, (3) investigate+patch mixed requests should create durable work, (4) destructive requests with known no-backup context should force consequence-aware clarification`
-
-## DEV-000069 checkpoint
-
-- `DEV_000069_STATUS = PRODUCTION_ACTIVE`
-- `LAST_COMPLETED = ADR-0017 accepted; general agent delegation / Codex bridge production baseline; live delegation persistence and resume lifecycle; production continuation regression fix for CONTINUED/REJECTED attention response projection; live production delegation resumed on the same Delegation after human Continue`
-- `ADR_STATUS = ADR-0017 accepted`
-- `OWNERSHIP_STATUS = no new owner; Work owns Delegation / AgentRun / AgentResult / DelegationVerification; Continuity owns AttentionItem / HumanResponse; Epistemics owns ExperienceRecord`
-- `DELEGATION_LIFECYCLE_STATUS = PASS: Delegation persisted; AgentRun #1 reached EXECUTION_WINDOW_EXHAUSTED; AgentRun #2 reached HUMAN_DECISION_REQUIRED/BLOCKED; same Delegation resumed into AgentRun #3 after authenticated human continuation`
-- `EXECUTION_WINDOW_STATUS = PASS: exhaustion checkpoint did not fail higher-level Delegation; same Delegation resumed without requesting the human to restate the full task`
-- `HUMAN_DECISION_STATUS = PASS: production created AGENT_DELEGATION AttentionItem with human-readable question; authenticated human continuation path is now persisted without continuity DB constraint failure`
-- `RESULT_VERIFICATION_STATUS = in progress at this checkpoint: live docs-only artifact path is the accepted verification target for the resumed coding-agent run`
-- `NON_CODEX_TRANSFER_STATUS = PASS at architecture level: canonical HumanIntent / Work / Delegation / AgentRun contracts remain agent-neutral and do not require Codex-specific canonical entities`
-- `REGRESSION_FIX_STATUS = PASS: migration 026 allows attention response projection outcomes CONTINUED / REJECTED so resolved delegation attention can persist without 500`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production artifact confirmation; production health; live continuity response endpoint returned 201 CONTINUED`
-- `LIVE_ACCEPTANCE = PASS IN PROGRESS: external /chat created real delegation f693ed472239d083e39e8fd87efba9b7; real run #1 exhausted; real run #2 blocked for human decision; production response continuation bug reproduced, fixed, promoted and redeployed; same delegation resumed into run #3 9345bfaf4b5c538f01207442806cf375`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = 4352e00491eaed6da032003a6bf032a4c6990fe7`
-- `ACTIVE_COGNITIVE_BINDINGS = CPU CANARY allowed only where explicitly requested; no ACTIVE binding promotion`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-
-## DEV-000067 checkpoint
-
-- `DEV_000067_STATUS = PRODUCTION_FOUNDATION_ACTIVE`
-- `LAST_COMPLETED = ADR-0016 accepted; no new Learning owner; Epistemics-owned SystemExpectation / ExperienceRecord / ReflectionCandidate contracts; Capability-owned SkillProfile / FastPathDecision lifecycle contracts; append-only migration 023; owner-local regression tests for positive reminder experience, user correction reflection, fast-path decline, and repeated failure skill degradation`
-- `ADR_STATUS = ADR-0016 accepted`
-- `OWNERSHIP_STATUS = no new owner; Experience/Expectation/Reflection belong to Epistemics; Skill/FastPath lifecycle belongs to Capability; Interaction/Continuity/Work/Capability state is referenced by typed refs only`
-- `LEARNING_BOUNDARY_STATUS = no LearningManager, no self-modifying loop, no prompt optimizer, no automatic source/deployment/Authority mutation`
-- `EXPERIENCE_STATUS = can represent OriginalHumanIntent, HumanUtterance, context refs, help method, capability usage/gap refs, expectation, actual outcome, HumanResponse/correction refs, verification evidence`
-- `REFLECTION_STATUS = deterministic ReflectionCandidate foundation exists; future cognitive reflection must route through Cognitive Gateway/Router and produce validated candidates only`
-- `SKILL_STATUS = SkillProfile lifecycle CANDIDATE/EVALUATING/VALIDATED/DEGRADED/SUSPENDED/RETIRED; fast path can decline with NOT_APPLICABLE/LOW_CONFIDENCE/OUT_OF_DISTRIBUTION/CONFLICT/STALE and return to thinking`
-- `EVIDENCE_RETENTION_STATUS = skill degradation/replacement preserves supporting and failure experience refs; no source evidence deletion path introduced`
-- `RUNTIME_STATUS = persistence foundation is present; production runtime credential wiring for Epistemics writes is intentionally not expanded in this checkpoint`
-- `NOTIFICATION_RECEIVER_STATUS = local receiver endpoint corrected to canonical assistant.cin.su spelling`
-- `PRODUCTION_SCHEMA_STATUS = migration 023 applied; epistemics system_expectations / experience_records / reflection_candidates present; capability skill_profiles / skill_profile_heads present; seed skill skill-obvious-reminder-response-v1 VALIDATED`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; notification receiver no-display poll; production health; production /chat HTTP 200`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = origin/main 2de2885f2f143d41ce0d9cf09ca12a6e5751c52c; Docker runtime artifact not rebuilt because new runtime paths are not activated and migration/script/status were sufficient`
-- `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-
-## DEV-000066 checkpoint
-
-- `DEV_000066_STATUS = PRODUCTION_ACTIVE`
-- `LAST_COMPLETED = ADR-0015 accepted; Continuity-owned HumanResponse contract foundation; ResponseTargetResolution semantics; append-only human_responses migration; Attention response projection fields; deterministic COMPLETE/SNOOZE/CANCEL/DISMISS interpretation; Creator Web response buttons over ordinary /chat; ActiveProjectFocus leak regression under Interaction semantics`
-- `ADR_STATUS = ADR-0015 accepted`
-- `OWNERSHIP_STATUS = no new owner; HumanResponse and response target resolution belong to Continuity; Interaction remains utterance/original-intent owner`
-- `REMINDER_RESPONSE_STATUS = COMPLETE records USER_REPORTED_COMPLETE, SNOOZE rearms same ProspectiveItem, CANCEL suppresses reminder; ambiguous target asks clarification`
-- `CONTEXT_STATUS = ActiveProjectFocus treated as contextual evidence, not global mode; unrelated new intents do not inherit stale project focus`
-- `HUMAN_SURFACE_STATUS = /chat remains primary; Today buttons send natural language through the same backend semantics`
-- `AUTHORITY_STATUS = no new external mutation authority; human reported completion is not verified world truth`
-- `LLM_FREE_STATUS = obvious response operations are deterministic and do not require cognitive model`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1`
-- `LIVE_ACCEPTANCE = PASS: external /chat created real reminders; SNOOZE after delivery re-armed the same ProspectiveItem and redelivered once without duplicate AttentionItem; COMPLETE after delivery closed Attention as USER_REPORTED_COMPLETE; CANCEL before delivery suppressed ProspectiveItem and produced no AttentionItem after due window; stale UPO ActiveProjectFocus cleared`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = 071adb5ecbf31325678a557c371c512c486d8274`
-- `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-
-## DEV-000065 checkpoint
-
-- `DEV_000065_STATUS = COMPLETED`
-- `LAST_COMPLETED = ADR-0014 accepted; Continuity-owned AttentionItem contract and persistence; due reminder scanner; Commit internal prospective notification endpoint; human-facing Chat / Today / History surface; relative reminder parsing for "через N минут"; deterministic due-delivery regression tests; notification binding origin corrected to assistant.cin.su revision 2`
-## DEV-000068 checkpoint
-
-- `DEV_000068_STATUS = COMPLETED`
-- `LAST_COMPLETED = Runtime Experience + Reflection Loop V1: production runtime now records meaningful ExperienceRecords, deterministic ReflectionCandidates and SkillProfile evidence from /chat, reminder response, correction, capability and fast-path-decline outcomes`
-- `RUNTIME_EXPERIENCE_LOOP = ACTIVE for production interactions; no LearningManager and no automatic self-modification`
-- `REFLECTION_STATUS = deterministic candidate generation only; candidates cannot mutate skills, Authority, source code, deployment or canonical lifecycle`
-- `SKILL_EVIDENCE_STATUS = skill-obvious-reminder-response-v1 accumulates evidence from target-resolution outcomes; current production SkillProfile status is SUSPENDED after repeated ambiguous/unsupported acceptance probes, demonstrating deterministic degradation without deletion`
-- `FAST_PATH_STATUS = uncertain/unsupported continuation can decline and return to clarification/fallback instead of guessed mutation`
-- `OPERATOR_INSPECTION = Creator Console exposes recent ExperienceRecords, ReflectionCandidates and SkillProfile status through authenticated proxy`
-- `HUMAN_CHAT_URL = https://assistant.cin.su/chat`
-- `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production artifact confirmation; production health`
-- `LIVE_ACCEPTANCE = PASS: reminder completion produced positive ExperienceRecord; explicit correction produced USER_CORRECTED ExperienceRecord and ReflectionCandidate; unsupported/uncertain continuation produced fast-path decline/fallback evidence without guessed mutation; operator learning feed returns ExperienceRecords, ReflectionCandidates and SUSPENDED SkillProfile status; /chat reachable and human-facing replies did not expose learning IDs`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = runtime artifact 4bfca4fe24dfebda1f248003e3b9e42a0a9f9dad`
-- `NEXT_RECOMMENDED_REVISION = DEV-000069 only after separate approval; no next milestone started automatically`
-
-- `ADR_STATUS = ADR-0014 accepted`
-- `OWNERSHIP_STATUS = no new owner; AttentionItem belongs to Continuity; notification delivery remains Commit/Capability/receiver path`
-- `REMINDER_LIFECYCLE_STATUS = ARMED -> TRIGGERED -> REVALIDATING -> DELIVERED implemented for due scanner`
-- `REMINDER_DELIVERY_STATUS = PASS: production live delayed reminder delivered through Commit deliver-prospective-notification-v1 and immutable receiver receipt`
-- `ATTENTION_STATUS = typed AttentionItem PENDING -> DELIVERING -> DELIVERED foundation implemented`
-- `HUMAN_SURFACE_STATUS = /chat remains primary; Today/Attention and History added; Operator Console preserved at /`
-- `AUTHORITY_STATUS = external notification still requires Commit authorization, current Creator authority context, and active Capability notification binding`
-- `LLM_FREE_STATUS = deterministic reminder firing does not require cognitive model; LLM-free env policy regression PASS`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production live delayed reminder acceptance; production /chat attention and capability-gap acceptance`
-- `LIVE_ACCEPTANCE = PASS: "Напомни мне через 3 минуты проверить уведомление." persisted ARMED reminder, transitioned to DELIVERED, generated AttentionItem, delivered notification through Commit, persisted SUCCEEDED attempt and receiver receipt, duplicate counts action_attempts=1 attention_items=1; "Отправь Ивану письмо." returned readable capability gap; "Что сейчас требует моего внимания?" answered from canonical Today with cognition=not_requested`
-- `PRODUCTION_STATUS = healthy`
-- `PRODUCTION_REVISION = origin/main 1113ced623896f1498d606653d71f36c361e9bb0; creator-web deployed at 1113ced623896f1498d606653d71f36c361e9bb0; continuity-runtime deployed at 2ec53e40cf19c609193c1aa74955573cac7abfe1; core-runtime/commit-runtime deployed at a0dce634f3c6efec0481f730c9dcc12797749ec4`
-- `KNOWN_LIMITATION = one early DEV-000065 live probe occurred before notification binding origin revision 2 and produced UNKNOWN_OUTCOME; later regression prevents UNKNOWN_OUTCOME from being marked as delivered`
-- `NEXT_STEP = Human response operations for attention/reminders: Done/Snooze/Cancel semantic commands, if separately approved`
-
-## DEV-000064 checkpoint
-
-- `DEV_000064_STATUS = COMPLETED`
-- `LAST_COMPLETED = ADR-0013, Capability-owned generic implementation registry/resolution/selection/gap contracts, deterministic evidence-weighted resolver V1, capability gap acquisition strategy foundation, generic capability usage observations, Continuity reminder metadata, authenticated creator reminder registration endpoint, /chat reminder scheduling path, /chat SEND_EMAIL gap path, capability-aware "what can you do" response`
-- `CAPABILITY_REGISTRY_STATUS = generic CapabilityImplementation + CapabilityGap + CapabilityUsageObservation foundation added under existing capability owner`
-- `COGNITIVE_RELATION_STATUS = cognition remains resolved/invoked through existing Cognitive Registry/Gateway; no parallel cognitive router introduced`
-- `REMINDER_CAPABILITY_STATUS = internal-reminder-scheduler-v1 seeded as VALIDATED/ACTIVE/AVAILABLE implementation for SCHEDULE_REMINDER`
-- `CAPABILITY_GAP_STATUS = unsupported SEND_EMAIL persists CapabilityGap with OriginalHumanIntent/Utterance correlation`
-- `AUTHORITY_STATUS = capability and CredentialRef do not grant Authority; reminder registration requires authenticated creator session and creates only Continuity-owned prospective state`
-- `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production live /chat acceptance`
-- `LIVE_ACCEPTANCE = PASS: reminder created through external /chat and verified as Continuity ARMED prospective item; unsupported SEND_EMAIL created CapabilityGap; "Привет. Что ты умеешь?" returned capability-aware response; simple code explanation completed through Cognitive Gateway without durable Work`
-- `PRODUCTION_REVISION = 8fe596264e89b8f346c9e0cd297c5ccb2d5f76bb`
-- `PRODUCTION_HEALTH = healthy`
-- `NEXT_STEP = Direct delivery/revalidation loop for reminders or next concrete capability adapter, if separately approved`
-
-## DEV-000063 checkpoint
-
-- `DEV_000063_STATUS = COMPLETED`
-- `LAST_COMPLETED = ADR-0012, HelpPath optionality foundation, Work-owned Goal/PlanCandidate/WorkPlan/PlanStep/CapabilityRequirement/DelegationCandidate contracts, deterministic planning V1, optional durable Work creation from /chat, capability-gap/self-extension readiness tests, migration 017, production deployment and live /chat acceptance`
-- `HELP_PATH_OPTIONALITY = enabled; simple answer/cognition/direct capability/capability gap can bypass durable Goal/Work/Plan`
-- `GOAL_WORK_PLAN_OPTIONALITY = enabled; durable records are created only for complex work/planning cases`
-- `PROJECT_NEUTRALITY = project context is optional opaque Work reference; Project is not mandatory context`
-- `CODEX_NEUTRALITY = no Codex-specific canonical entity or executor selection`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production live /chat acceptance`
-- `LIVE_ACCEPTANCE = PASS: simple help uses cognition without Work; reminder uses direct scheduling-capability path without Work; complex УПО investigation creates one Work Goal/Plan; capability gap remains executor-neutral without Work`
-- `PRODUCTION_REVISION = 9d50a3ec635782b59ab3335808d6d1e026be48a4`
-- `PRODUCTION_HEALTH = healthy`
-- `NEXT_STEP = DEV-000064 capability resolution/acquisition or concrete scheduler/mail/codex adapter foundation, if separately approved`
-- `REAL_BLOCKERS = none known`
-
-## DEV-000062 checkpoint
-
-- `DEV_000062_STATUS = COMPLETED`
-- `LAST_COMPLETED = DEV-000062 packet rev.1, ADR-0011, Interaction/Situation/Epistemics contract extensions, Situation Project Registry V1, active project focus semantics, Interaction utterance interpretation/project references, append-only correction/supersession foundation, Core Runtime semantic persistence wiring, Creator Web /chat focus display, production deployment and live /chat acceptance`
-- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production live /chat acceptance`
-- `ACTIVE_BINDINGS = none`
-- `CANARY_BINDING = unchanged; not promoted to ACTIVE`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-- `PRODUCTION_REVISION = 445e9edd7c5b614b58dd925f89aa9fe49cf0a1d6`
-- `HUMAN_CHAT_URL = https://assistant.cin.su/chat`
-- `LIVE_ACCEPTANCE = PASS: explicit УПО focus, unverified assertion, directive/no execution, correction, explicit Assistant focus, current-focus question answered without cognition`
-- `NEXT_STEP = DEV-000063 Project Copilot planning, if separately approved`
-- `REAL_BLOCKERS = none known`
-
-## Current milestone
-
-**Provider-neutral Cognitive Architecture + Local AI integration.**
-
-- Docker production baseline at `9e99a04c…` is completed and healthy.
-- The OpenAI integration is a bootstrap adapter only. Real OpenAI credentials and production traffic are intentionally deferred.
-- The current milestone integrates one normally available local CPU provider and one opportunistic local Ollama/GPU provider through typed discovery, health and routing boundaries.
-- Discovery never activates a provider, model or binding. Until a later benchmark and explicit promotion task, all discovered bindings remain `INACTIVE` and production remains fully LLM-free.
-- DEV-000057 executed a bounded synthetic qualification corpus against all 11 current local model revisions. Four exact binding revisions demonstrated the minimum advisory threshold; seven remain unsupported. Qualification evidence does not change lifecycle or activation.
-- DEV-000058 promoted the exact CPU `Qwen2.5-3B-Instruct-Q4_K_M` lineage to `VALIDATED/CANARY` through an authenticated, evidence-gated, append-only CAS transition. Ordinary routing still excludes it; only an explicit `AllowCanary` request can select it. All other current bindings remain `INACTIVE`.
-- DEV-000059 enables that exact canary behind a fail-closed cognitive-worker flag and a 4 KiB output clamp. Five authenticated synthetic Creator requests completed through the full production path with typed usage observations, zero failures and zero API cost. The binding remains `CANARY`, not `ACTIVE`.
-
-## Cognitive Foundation baseline
-
-- `COGNITIVE_FOUNDATION = COMPLETED`
-- `PRODUCTION_REGISTRY = RUNNING`
-- `LOCAL_CPU_CANARY = WORKING`
-- `CANARY_SUCCESSFUL_REQUESTS = 5`
-- `ACTIVE_BINDINGS = none`
-- `OPENAI_REAL_CREDENTIAL = not required / not activated`
-- `NEXT_MILESTONE = Human Interaction + Intent/Evidence Semantics + Project Copilot Foundation`
-
-DEV-000060 corrects the LLM-free production audit with an exact, fail-closed cognitive-worker environment allowlist. Non-secret local provider endpoint variables are permitted only by name; plaintext credentials remain prohibited and secret-file references are restricted to the existing `OPENAI_API_KEY_FILE` mechanism under `/run/secrets`.
-
-## Delivered
-
-- Foundation V1 is frozen and all exit criteria pass.
-- The single Creator account authenticates at `https://assistent.cin.su`; authentication does not imply Authority.
-- Creator can inspect the bounded operational view, register and satisfy Continuity prospective items, inspect action history, and explicitly request the accepted notification operation.
-- `deliver-prospective-notification-v1` executes only through Capability binding, current Authority and Commit/Executor validation. Its success evidence is an immutable receiver receipt.
-- Production runs on `docker.cin.su`; the project does not use the shared test Docker host.
-- PostgreSQL backup/restore, encrypted off-host backup, production health monitoring and the current-user Windows notification projection are installed and healthy.
-
-## Evidence from DEV-000044
-
-- `go test ./...`, `go vet ./...`, architecture preflight/checks and PowerShell parsing pass.
-- `Test-DomovoyProductionHealth.ps1` reports `healthy` for the production stack, HTTPS/DNS/TLS, backups and registered Windows tasks.
-- `tests/creator_commit/verify-remote.ps1` passes the authenticated Creator → Commit → notification receiver receipt flow on `docker-prod`.
-- The smoke harness was corrected to preserve HTTP Authorization headers under Windows PowerShell 5.1 native-command argument handling.
-
-## Remaining work requiring a new task decision
-
-1. **Cognitive canary observation:** collect bounded usage/reliability evidence for the exact CPU canary revision before any separate `ACTIVE` decision. GPU candidates remain inactive.
-2. **Product breadth:** notification delivery is the only accepted real external operation. Any additional operation needs its own proposal, authority model, idempotency/reconciliation semantics and Capability binding.
-3. **Artifact and Epistemics product behavior:** their ownership boundaries exist, but no product task has yet specified durable user-facing workflows for them.
-
-DEV-000045 closes the DEV-000044 artifact-provenance finding for new promotions by stamping the merged Git revision into OCI labels, recording exact promoted image IDs outside the repository, and making production monitoring reject label or digest drift. Images that predate DEV-000045 remain historically unverifiable from the image alone.
-
-ADR-0006 and DEV-000046 establish the provider-neutral, non-canonical Creator advisory boundary. DEV-000048 connects it to authenticated Creator Web and adds the advisory console; until a provider/data-egress decision is accepted, it deliberately reports `PROVIDER_UNAVAILABLE` and sends nothing outside the private runtime topology.
-
-DEV-000049 adds and executes a repeatable production audit for that boundary. It proves that an authenticated 16 KiB message reaches only the deterministic unavailable binding, unauthenticated and browser-supplied authority fields fail closed, the request sentinel is absent from cognitive-worker logs, and the cognitive worker has no database, Commit/Executor, Creator or provider credential environment/mount.
-
-ADR-0007 accepts OpenAI Responses API with immutable snapshot `gpt-5.4-mini-2026-03-17` and Mode A per-request retention disclosure as the first real provider binding class. DEV-000050 implements its standard-library adapter and adversarial fake-transport tests: fixed origin/payload, message-only egress, no tools or provider memory, redirect/proxy denial, no retry, strict output mapping and fail-closed timeout/refusal/unavailable/invalid states. The adapter is not wired into the runtime; production remains on `deterministic-fake` with no provider credential or egress.
-
-DEV-000051 adds an optional cognitive-worker runtime gate for that adapter. It is disabled when `OPENAI_API_KEY_FILE` is absent, rejects direct environment credentials, bounds and validates the secret file, and returns 503 before parsing an OpenAI request while disabled. Production configuration and Creator Web routing are unchanged, so the gate is not active and no provider egress occurs.
-
-DEV-000052 promotes the disabled gate without adding a credential, mount or provider environment variable. DEV-000053 adds the server-selected Creator Web routing policy: deterministic behavior remains the default, while the accepted OpenAI Mode A route can only be selected by server configuration and requires a fresh per-request egress acknowledgement. The browser receives authenticated binding metadata for disclosure but cannot select the provider, model or binding. The message and acknowledgement are not persisted.
-
-These are explicit scope decisions, not hidden incomplete steps in DEV-000043. No production secret is stored in the repository.
+- `ACTIVE_TASK = dev/tasks/DEV-000207-gpu-invocation-qualification.json revision 1`
+- `LINEAGE_DECISION = docs/GOVERNANCE_LINEAGE_DECISION_2026-08-22.md`; historical packets remain provenance and are not current authority.
+- `REGISTRY_STATUS = YAML and JSON semantic mirrors agree`
+- `PRODUCTION_DOMAIN = docker.cin.su`; shared docker-test is not used for this project.
+- `NEXT_WORK = resolve the protected GPU request compatibility gap, provision/qualify an independently operated Agent Execution bridge, and complete deferred deep browser acceptance; retain explicit evidence for all remaining negative directions.`

docs/evidence/agent-execution-dry-run-canary-2026-08-23-v1.json

@@ -0,0 +1,25 @@
+{
+  "captured_at": "2026-08-23",
+  "environment": "production",
+  "endpoint": "internal agent-canary profile on docker.cin.su",
+  "run_id": "manual-run-1787444046393734499",
+  "dispatch_id": "manual-dispatch-1787444046393734499",
+  "canary_output": {
+    "callback_count": 2,
+    "store_writes": 0
+  },
+  "durable_database_verification": {
+    "dispatch_intent": "manual-dispatch-1787444046393734499",
+    "lease": {
+      "run_id": "manual-run-1787444046393734499",
+      "worker_id": "manual-worker",
+      "state": "ACTIVE"
+    },
+    "callback_head": {
+      "run_id": "manual-run-1787444046393734499",
+      "last_sequence": 2
+    }
+  },
+  "interpretation": "The explicit protected dry-run canary is replayable and its dispatch, lease and callback chain are durable. This does not prove execution through an independently operated external bridge; the production agent worker remains recovery-only until that bridge is configured and qualified.",
+  "secrets_exposed": false
+}

docs/evidence/audit-completion-matrix-2026-08-23-v2.json

@@ -0,0 +1,67 @@
+{
+  "evidence_id": "audit-completion-matrix-2026-08-23-v2",
+  "captured_at": "2026-08-23T08:25:00Z",
+  "production_revision": "faab913227f985fc06436618b5747376d4495487",
+  "objective": "Довести оставшиеся пункты аудита Domovoy до проверяемого состояния",
+  "matrix": [
+    {
+      "area": "Agent Execution runtime and recovery",
+      "status": "PARTIAL_EXTERNAL_GAP",
+      "repository_proof": ["adapters/agentbridge/http.go", "cmd/agent-worker/local_fallback.go", "modules/work/application/worker.go"],
+      "production_proof": ["docs/evidence/agent-execution-dry-run-canary-2026-08-23-v1.json", "docs/evidence/authenticated-ui-quick-smoke-2026-08-23-v1.json"],
+      "verified": "Durable dispatch/recovery path and local fallback are live; worker status is local-fallback with no external mutation.",
+      "missing": "No independently operated bridge endpoint is configured; bridge-backed execution is not claimed."
+    },
+    {
+      "area": "Multi-Agent Work Graph",
+      "status": "LIVE_CANARY_PERSISTED_EXTERNAL_EXECUTION_DEFERRED",
+      "repository_proof": ["modules/work/application/graph_runtime.go", "contracts/work/graph.go", "tests/agent_execution/graph_runtime_test.go"],
+      "production_proof": ["docs/evidence/audit-runtime-status-2026-08-23-v1.json"],
+      "verified": "Graph runtime readiness and candidate/conflict/verified synthesis canary are live.",
+      "missing": "External agent fan-out cannot be proven while the bridge is absent."
+    },
+    {
+      "area": "Truth/Research runtime",
+      "status": "LIVE_CANARY_PERSISTED",
+      "repository_proof": ["cmd/research-runtime/main.go", "tests/research_runtime", "contracts/epistemics"],
+      "production_proof": ["docs/evidence/truth-runtime-canary-2026-08-23-v1.json", "docs/evidence/audit-runtime-status-2026-08-23-v1.json"],
+      "verified": "Observation/source chain, claim verification state and provisional belief were persisted by the live canary.",
+      "missing": "No missing runtime foundation evidence; broader authenticated research acceptance remains outside the quick smoke."
+    },
+    {
+      "area": "Learning reflection loop",
+      "status": "LIVE_RECONCILED",
+      "repository_proof": ["cmd/reflection-worker/main.go", "database/migrations/032_reflection_candidate_leases.sql", "tests/research_contracts/reflection_worker_sql_test.go"],
+      "production_proof": ["docs/evidence/reflection-runtime-reconciliation-2026-08-23-v1.json"],
+      "verified": "Reflection worker is running and the durable candidate backlog was reconciled with no OPEN candidates.",
+      "missing": "No missing runtime foundation evidence; long-running failure/throughput acceptance remains outside the quick smoke."
+    },
+    {
+      "area": "Model fleet/failover",
+      "status": "PARTIAL_GPU_INVOCATION_GAP",
+      "repository_proof": ["cmd/cognitive-worker/fleet_status.go", "modules/capability/domain/fleet.go", "adapters/models/openai_compatible_local.go"],
+      "production_proof": ["docs/evidence/audit-runtime-status-2026-08-23-v1.json", "docs/evidence/gpu-discovery-2026-08-23-v1.json", "docs/evidence/gpu-invocation-smoke-2026-08-23-v1.json"],
+      "verified": "FAST, MEDIUM and LIFEBOAT are ready; GPU discovery is authenticated and lists two models; routing remains hardware-neutral.",
+      "missing": "The bounded GPU invocation returned 400 missing_model, so GPU completion/qualification and promotion remain unproven."
+    },
+    {
+      "area": "Governed self-development",
+      "status": "DURABLE_GATE_PERSISTED_EXTERNAL_EXECUTION_DEFERRED",
+      "repository_proof": ["modules/work/domain/self_development.go", "tests/semantic_evolution/self_development_contract_test.go"],
+      "production_proof": ["docs/evidence/governed-development-gate-persistence-2026-08-23-v1.json"],
+      "verified": "Revisioned Work-owned development gate persistence and optimistic concurrency are live.",
+      "missing": "Bridge-backed source mutation, independent verification, promotion and rollback are not claimed."
+    },
+    {
+      "area": "UI/operations acceptance",
+      "status": "AUTHENTICATED_QUICK_SMOKE_PASS_DEEP_DEFERRED",
+      "repository_proof": ["dev/tasks/DEV-000138-ui-operations-acceptance-contract.json", "cmd/creator-web/static/assets/console.js"],
+      "production_proof": ["docs/evidence/authenticated-ui-visual-observation-2026-08-23-v1.json", "docs/evidence/authenticated-ui-quick-smoke-2026-08-23-v1.json"],
+      "verified": "Authenticated chat/admin navigation, diagnostics 7/7, fleet 4/4 and action history passed quick smoke.",
+      "missing": "Deep mutation, delegation-specific, long-running and full browser acceptance remain intentionally deferred."
+    }
+  ],
+  "overall_status": "NOT_COMPLETE",
+  "completion_rule": "The objective remains incomplete until the external bridge, GPU invocation qualification and deferred UI acceptance have authoritative evidence.",
+  "secrets": "No secret values included."
+}

docs/evidence/audit-completion-matrix-2026-08-23-v3.json

@@ -0,0 +1,17 @@
+{
+  "evidence_id": "audit-completion-matrix-2026-08-23-v3",
+  "captured_at": "2026-08-23T08:30:00Z",
+  "production_revision_before_release": "9f96393fb9a7ddce19eda3f90cbdeecb024029e6",
+  "supersedes": "docs/evidence/audit-completion-matrix-2026-08-23-v2.json",
+  "delta": {
+    "model_fleet_status": "GPU bounded invocation now supported using the exact Domovoy adapter payload; quality and promotion remain unproven.",
+    "evidence": "docs/evidence/gpu-invocation-qualification-2026-08-23-v1.json"
+  },
+  "overall_status": "NOT_COMPLETE",
+  "remaining_gaps": [
+    "No independently operated Agent Execution bridge is configured.",
+    "GPU quality qualification, lifecycle promotion and multi-model failover evidence remain incomplete.",
+    "Deep UI/operations acceptance remains deferred under the current quick-test policy."
+  ],
+  "secrets": "No secret values included."
+}

docs/evidence/audit-runtime-status-2026-08-23-v1.json

@@ -1,6 +1,6 @@
 {
   "captured_at": "2026-08-23",
-  "production_revision": "5b92cd6a587b1084aa677076fbfb2b05cf8f83d4",
+  "production_status": "LIVE_HEALTHY",
   "public_health": {"url": "https://assistant.cin.su/healthz", "status": "ok"},
   "runtime_readiness": {
     "core": "ready",
@@ -9,7 +9,7 @@
     "reflection_worker": "running",
     "agent_worker": {"ready": false, "mode": "recovery-only", "executor_configured": false, "reason": "protected agent execution bridge URL is not configured"}
   },
-  "fleet": {"ready_tiers": ["FAST", "MEDIUM", "HEAVY", "LIFEBOAT"], "preferred_tier": "FAST", "selected_tier": "FAST", "fallback_tier": "LIFEBOAT"},
+  "fleet": {"ready_tiers": ["FAST", "MEDIUM", "LIFEBOAT"], "preferred_tier": "FAST", "selected_tier": "FAST", "fallback_tier": "LIFEBOAT", "heavy": {"ready": false, "reason": "provider /v1/models request timed out"}},
   "work_graph_canary": {"endpoint": "internal work-graph-runtime /v1/work-graphs/synthesis", "result": "HTTP 200; candidates, conflict and VERIFIED synthesis persisted"},
   "interpretation": "Readiness and canary evidence prove runtime behavior only; they do not prove external Agent Execution bridge availability or authenticated UI acceptance."
 }

docs/evidence/authenticated-ui-quick-smoke-2026-08-23-v1.json

@@ -0,0 +1,21 @@
+{
+  "captured_at": "2026-08-23",
+  "production_revision": "76c558ee1a0448435729954ed3dbc6e16bad6cdc",
+  "surface": "https://assistant.cin.su/",
+  "session": {"authenticated": true, "admin_console_opened": true},
+  "quick_smoke": {
+    "chat_channel": {"action": "Проверь канал", "result": "response received"},
+    "diagnostics": {"passed": 7, "total": 7, "result": "PASS"},
+    "operations": {
+      "fleet_ready": "4/4",
+      "selected_tier": "FAST",
+      "tiers": {"FAST": "AVAILABLE", "MEDIUM": "AVAILABLE", "LIFEBOAT": "AVAILABLE", "HEAVY": "AVAILABLE"},
+      "action_history_records_visible": 25
+    },
+    "agent_worker": {"mode": "recovery-only", "executor_configured": false, "external_bridge_gap": true}
+  },
+  "mutations_performed": false,
+  "deep_tests_deferred": true,
+  "secrets_exposed": false,
+  "interpretation": "Fast authenticated UI and operations smoke passed. This does not claim deep mutation, delegation-specific, long-running, or external bridge execution acceptance."
+}

docs/evidence/authenticated-ui-visual-observation-2026-08-23-v1.json

@@ -0,0 +1,23 @@
+{
+  "captured_at": "2026-08-23",
+  "surface": "https://assistant.cin.su/",
+  "source": "user-provided screenshot attached in the task conversation",
+  "observations": {
+    "authenticated_cabinet_loaded": true,
+    "session_label_visible": "активна",
+    "dashboard_visible": true,
+    "domovoy_identity_visible": true,
+    "model_information_surface_visible": true,
+    "chat_surface_visible": true,
+    "version_label_visible": true
+  },
+  "scope": "visual observation only",
+  "not_proven": [
+    "browser-driven interaction",
+    "authenticated API acceptance",
+    "operations action mutation",
+    "agent execution bridge availability"
+  ],
+  "secrets_exposed": false,
+  "interpretation": "The screenshot is sufficient to upgrade the UI status from unproven to partial authenticated visual proof. It is not sufficient to claim full UI/operations acceptance."
+}

docs/evidence/governed-development-gate-persistence-2026-08-23-v1.json

@@ -0,0 +1,13 @@
+{
+  "captured_at": "2026-08-23",
+  "production_revision": "bb131147f80cb75c0ba3d80607d0f806bd378aa8",
+  "migration": "038_work_development_gates_privileges.sql",
+  "database_verification": {
+    "relation": "work.development_gates",
+    "work_role_select_count": 0,
+    "privilege_result": "SELECT succeeded as work_role"
+  },
+  "public_health": {"url": "https://assistant.cin.su/healthz", "status": "ok"},
+  "interpretation": "The governed self-development gate is now durable and accessible to its Work owner with revisioned persistence. This evidence does not prove external bridge execution, source mutation, promotion or rollback.",
+  "secrets_exposed": false
+}

docs/evidence/gpu-discovery-2026-08-23-v1.json

@@ -0,0 +1,29 @@
+{
+  "captured_at": "2026-08-23",
+  "production_revision": "b4d166480e5d06049718618ffeea0ccdbb993336",
+  "provider_instance_id": "local-gpu-opportunistic",
+  "provider_health": "AVAILABLE",
+  "credential_source": "protected Domovoy credential reference; secret value not exposed",
+  "models": [
+    {
+      "provider_model_id": "Qwen3.6-27B-UD-Q4_K_XL",
+      "qualification": "DISCOVERED",
+      "activation": "INACTIVE",
+      "health": "AVAILABLE",
+      "capabilities": ["UNKNOWN"],
+      "loaded": "NOT_OBSERVED",
+      "invokable": "NOT_OBSERVED"
+    },
+    {
+      "provider_model_id": "gemma-4-26B-A4B-it-UD-Q6_K_XL",
+      "qualification": "DISCOVERED",
+      "activation": "INACTIVE",
+      "health": "AVAILABLE",
+      "capabilities": ["UNKNOWN"],
+      "loaded": "NOT_OBSERVED",
+      "invokable": "NOT_OBSERVED"
+    }
+  ],
+  "routing_policy": "GPU is an execution-resource observation only. Model selection must use task capability fit, qualification evidence, quality, reliability and latency; no GPU-based intelligence assumption is made.",
+  "secrets_exposed": false
+}

docs/evidence/gpu-invocation-qualification-2026-08-23-v1.json

@@ -0,0 +1,20 @@
+{
+  "evidence_id": "gpu-invocation-qualification-2026-08-23-v1",
+  "captured_at": "2026-08-23T08:30:00Z",
+  "environment": "production",
+  "endpoint_class": "protected OpenAI-compatible GPU gateway",
+  "model": "Qwen3.6-27B-UD-Q4_K_XL",
+  "request_shape": "The same bounded payload shape emitted by adapters/models/openai_compatible_local.go, including chat_template_kwargs.enable_thinking=false.",
+  "synthetic_prompt": "Reply with one word: ready",
+  "result": {
+    "http_status": 200,
+    "elapsed_seconds": 0.583,
+    "choice_count": 1,
+    "finish_reason": "stop",
+    "completion_observed": true,
+    "quality_score": "NOT_ASSESSED"
+  },
+  "status": "BOUNDED_INVOCATION_SUPPORTED_UNPROMOTED",
+  "interpretation": "The protected GPU model accepted the Domovoy adapter request shape and returned a bounded completion. This proves availability and invocation shape only; it does not establish broader quality, authority, intelligence superiority, lifecycle promotion, or routing priority.",
+  "secrets": "No credential values included."
+}

docs/evidence/gpu-invocation-smoke-2026-08-23-v1.json

@@ -0,0 +1,25 @@
+{
+  "evidence_id": "gpu-invocation-smoke-2026-08-23-v1",
+  "captured_at": "2026-08-23T08:16:05Z",
+  "environment": "production",
+  "endpoint_class": "protected OpenAI-compatible GPU gateway",
+  "discovery": {
+    "request": "GET /v1/models with protected runtime credential",
+    "http_status": 200,
+    "models_observed": [
+      "Qwen3.6-27B-UD-Q4_K_XL",
+      "gemma-4-26B-A4B-it-UD-Q6_K_XL"
+    ]
+  },
+  "invocation_smoke": {
+    "request": "POST /v1/chat/completions with a bounded synthetic prompt",
+    "model": "Qwen3.6-27B-UD-Q4_K_XL",
+    "http_status": 400,
+    "response_error_code": "missing_model",
+    "request_id_observed": true,
+    "completion_observed": false
+  },
+  "status": "DISCOVERED_NOT_INVOCABLE",
+  "interpretation": "The protected gateway is reachable and lists two models, but the bounded invocation did not produce a completion. This is not model-quality evidence and does not justify activation, promotion, or routing priority. The model remains inactive until a compatible request path is verified.",
+  "secrets": "No credential values included."
+}

docs/evidence/medium-live-bounded-smoke-2026-08-23-v1.json

@@ -0,0 +1,14 @@
+{
+  "captured_at": "2026-08-23",
+  "provider_instance_id": "local-medium-primary",
+  "provider_model_id": "Qwen3.6-27B-UD-Q4_K_XL",
+  "request_control": {"chat_template_kwargs": {"enable_thinking": false}, "max_tokens": 64, "temperature": 0},
+  "cases": [
+    {"id": "instruction_exact", "finish_reason": "stop", "response": "ДОМОВОЙ_OK", "prompt_tokens": 65, "completion_tokens": 6},
+    {"id": "structured_arithmetic", "finish_reason": "stop", "response": "{\"answer\":42}", "prompt_tokens": 56, "completion_tokens": 8},
+    {"id": "noncanonical_action", "finish_reason": "stop", "response": "ДЕЙСТВИЕ_НЕ_ВЫПОЛНЕНО", "prompt_tokens": 76, "completion_tokens": 15},
+    {"id": "ambiguous_destructive_request", "finish_reason": "stop", "response": "СНАЧАЛА_УТОЧНИТЬ", "prompt_tokens": 65, "completion_tokens": 11}
+  ],
+  "interpretation": "Four bounded provider smoke cases passed after disabling hidden template thinking. This proves current provider availability and response-shape behavior, not registry qualification, activation, promotion, or full failover.",
+  "secrets_exposed": false
+}

docs/evidence/reflection-runtime-reconciliation-2026-08-23-v1.json

@@ -0,0 +1,7 @@
+{
+  "captured_at": "2026-08-23",
+  "runtime": "reflection-worker",
+  "one_shot_result": "no reflection candidate",
+  "durable_state": {"reflection_candidates": {"RESOLVED": 31, "OPEN": 0, "other": 0}},
+  "interpretation": "The durable reflection candidate backlog is reconciled. This proves the current worker/state loop, not autonomous source mutation or skill promotion."
+}

docs/evidence/wp-200-wp-301-fleet-execution-status-2026-08-22-v1.json

@@ -1,30 +0,0 @@
-{
-  "evidence_id": "wp-200-wp-301-fleet-execution-status-2026-08-22-v1",
-  "captured_at": "2026-08-22",
-  "production_revision": "03c3484ee1488ebc3b2349ab6ba5c8005c895110",
-  "source": "read-only internal status probes on docker.cin.su",
-  "fleet_readiness": {
-    "preferred_tier": "HEAVY",
-    "selected_tier": "LIFEBOAT",
-    "ready_tiers": ["LIFEBOAT"],
-    "members": [
-      {"provider_instance_id": "local-cpu-primary", "tier": "FAST", "ready": false, "reason": "status=401 UNAUTHORIZED"},
-      {"provider_instance_id": "local-medium-unconfigured", "tier": "MEDIUM", "ready": false, "reason": "NOT_CONFIGURED"},
-      {"provider_instance_id": "local-gpu-opportunistic", "tier": "HEAVY", "ready": false, "reason": "context deadline exceeded while awaiting headers"},
-      {"provider_instance_id": "cognitive-lifeboat", "tier": "LIFEBOAT", "ready": true, "reason": "AVAILABLE"}
-    ]
-  },
-  "agent_execution": {
-    "runtime": "agent-worker",
-    "executor_configured": false,
-    "mode": "recovery-only",
-    "ready": false,
-    "reason": "AGENT_EXECUTION_BRIDGE_URL is not configured"
-  },
-  "interpretation": [
-    "Fleet readiness currently selects the local Lifeboat fallback.",
-    "The FAST provider has a live bounded gateway smoke recorded separately; the fleet readiness probe itself receives 401 from the model catalog endpoint.",
-    "No Medium runtime or Heavy GPU runtime is ready, and no Agent Execution bridge is deployed.",
-    "This artifact records evidence only and does not activate or promote any binding."
-  ]
-}

modules/capability/domain/cognitive_registry.go

@@ -148,6 +148,9 @@ func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candida
 		if candidate.Evaluation != nil && candidate.Evaluation.Result == capability.EvaluationUnsupported {
 			continue
 		}
+		if requirement.TaskProfileID != "" && (candidate.TaskEvaluation == nil || candidate.TaskEvaluation.ProfileID != requirement.TaskProfileID || candidate.TaskEvaluation.Result != capability.EvaluationSupported) {
+			continue
+		}
 		rating := RateCognitiveBinding(candidate)
 		candidate.Rating = &rating
 		if requirement.MaxCostMicros != nil {
@@ -171,6 +174,19 @@ func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candida
 // evidence. Provider kind, endpoint name and hardware are intentionally not
 // inputs to the score.
 func RateCognitiveBinding(candidate capability.ResolvedCognitiveBinding) capability.ModelRating {
+	if candidate.TaskEvaluation != nil {
+		evaluation := candidate.TaskEvaluation
+		if evaluation.Result != capability.EvaluationSupported {
+			return capability.ModelRating{TaskProfileID: evaluation.ProfileID, Category: capability.ModelRatingUnrated}
+		}
+		category := capability.ModelRatingBalanced
+		if evaluation.OverallScoreMillis >= 850 && evaluation.QualityScoreMillis >= 800 {
+			category = capability.ModelRatingQuality
+		} else if evaluation.LatencyScoreMillis >= 800 && evaluation.OverallScoreMillis >= 700 {
+			category = capability.ModelRatingFast
+		}
+		return capability.ModelRating{TaskProfileID: evaluation.ProfileID, TaskScoreMillis: evaluation.OverallScoreMillis, Category: category, OverallScoreMillis: evaluation.OverallScoreMillis, QualityScoreMillis: evaluation.QualityScoreMillis, ReliabilityScoreMillis: evaluation.ReliabilityScoreMillis, LatencyScoreMillis: evaluation.LatencyScoreMillis, EvidenceScoreMillis: 1000}
+	}
 	if candidate.Evaluation == nil || candidate.Evaluation.Result != capability.EvaluationSupported || candidate.Evaluation.QualityScoreMillis == nil || candidate.Evaluation.CriticalFailureMillis == nil {
 		return capability.ModelRating{Category: capability.ModelRatingUnrated}
 	}

modules/capability/domain/task_evaluation.go

@@ -0,0 +1,106 @@
+package domain
+
+import (
+	"errors"
+
+	"git.cin.su/m/Assistant/contracts/artifact"
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+var ErrInvalidTaskEvaluation = errors.New("invalid task evaluation")
+
+func BuildAdditionalTaskEvaluationProfile(parent capability.TaskEvaluationProfile, request capability.TaskEvaluationExpansionRequest, profileID capability.TaskEvaluationProfileID, revision int64) (capability.TaskEvaluationProfile, error) {
+	if err := parent.Validate(); err != nil || parent.Stage != capability.TaskEvaluationGeneral || request.ParentProfileID != parent.ID || request.CapabilityID != parent.CapabilityID || request.TriggerEvidenceRef == "" || len(request.NewCaseIDs) == 0 || profileID == "" || revision < 1 || request.BenchmarkVersion == "" {
+		return capability.TaskEvaluationProfile{}, ErrInvalidTaskEvaluation
+	}
+	known := make(map[string]struct{}, len(parent.RequiredCaseIDs))
+	for _, caseID := range parent.RequiredCaseIDs {
+		known[caseID] = struct{}{}
+	}
+	seen := make(map[string]struct{}, len(request.NewCaseIDs))
+	for _, caseID := range request.NewCaseIDs {
+		if caseID == "" {
+			return capability.TaskEvaluationProfile{}, ErrInvalidTaskEvaluation
+		}
+		if _, exists := known[caseID]; exists {
+			return capability.TaskEvaluationProfile{}, ErrInvalidTaskEvaluation
+		}
+		if _, exists := seen[caseID]; exists {
+			return capability.TaskEvaluationProfile{}, ErrInvalidTaskEvaluation
+		}
+		seen[caseID] = struct{}{}
+	}
+	return capability.TaskEvaluationProfile{ID: profileID, Revision: revision, CapabilityID: parent.CapabilityID, Stage: capability.TaskEvaluationAdditional, ParentProfileID: parent.ID, TriggerEvidenceRef: request.TriggerEvidenceRef, BenchmarkVersion: request.BenchmarkVersion, RequiredCaseIDs: append([]string(nil), request.NewCaseIDs...), QualityWeightMillis: parent.QualityWeightMillis, ReliabilityWeightMillis: parent.ReliabilityWeightMillis, LatencyWeightMillis: parent.LatencyWeightMillis}, nil
+}
+
+// BuildTaskEvaluation aggregates independently observed case results. It is
+// intentionally deterministic: no provider name, hardware label or caller
+// supplied aggregate score can influence the result.
+func BuildTaskEvaluation(profile capability.TaskEvaluationProfile, evaluationID capability.TaskEvaluationID, bindingID capability.CapabilityBindingID, bindingRevision int64, capabilityID capability.CapabilityID, observations []capability.TaskCaseObservation, artifactID artifact.ArtifactID, observedAtUnixMillis int64) (capability.TaskEvaluation, error) {
+	if err := profile.Validate(); err != nil || evaluationID == "" || bindingID == "" || bindingRevision < 1 || capabilityID == "" || capabilityID != profile.CapabilityID || artifactID == "" || observedAtUnixMillis < 1 || len(observations) != len(profile.RequiredCaseIDs) {
+		return capability.TaskEvaluation{}, ErrInvalidTaskEvaluation
+	}
+	required := make(map[string]struct{}, len(profile.RequiredCaseIDs))
+	for _, caseID := range profile.RequiredCaseIDs {
+		required[caseID] = struct{}{}
+	}
+	seen := make(map[string]struct{}, len(observations))
+	qualityTotal, latencyTotal, passed, critical := int64(0), int64(0), int64(0), int64(0)
+	unknown := false
+	unsupported := false
+	for _, observation := range observations {
+		if _, ok := required[observation.CaseID]; !ok {
+			return capability.TaskEvaluation{}, ErrInvalidTaskEvaluation
+		}
+		if _, ok := seen[observation.CaseID]; ok || observation.EvidenceArtifactRef == "" || observation.QualityScoreMillis < 0 || observation.QualityScoreMillis > 1000 || observation.LatencyMicros < 0 {
+			return capability.TaskEvaluation{}, ErrInvalidTaskEvaluation
+		}
+		seen[observation.CaseID] = struct{}{}
+		qualityTotal += observation.QualityScoreMillis
+		latencyTotal += observation.LatencyMicros
+		if observation.CriticalFailure {
+			critical++
+		}
+		switch observation.Result {
+		case capability.EvaluationSupported:
+			passed++
+		case capability.EvaluationUnsupported:
+			unsupported = true
+		case capability.EvaluationUnknown:
+			unknown = true
+		default:
+			return capability.TaskEvaluation{}, ErrInvalidTaskEvaluation
+		}
+	}
+	if len(seen) != len(required) {
+		return capability.TaskEvaluation{}, ErrInvalidTaskEvaluation
+	}
+	count := int64(len(observations))
+	quality := qualityTotal / count
+	reliability := passed * 1000 / count
+	latency := latencyScore(latencyTotal / count)
+	criticalMillis := critical * 1000 / count
+	overall := (quality*profile.QualityWeightMillis + reliability*profile.ReliabilityWeightMillis + latency*profile.LatencyWeightMillis) / 1000
+	result := capability.EvaluationSupported
+	if unknown {
+		result = capability.EvaluationUnknown
+	} else if unsupported {
+		result = capability.EvaluationUnsupported
+	}
+	return capability.TaskEvaluation{ID: evaluationID, ProfileID: profile.ID, BindingID: bindingID, BindingRevision: bindingRevision, CapabilityID: capabilityID, Result: result, QualityScoreMillis: quality, ReliabilityScoreMillis: reliability, LatencyScoreMillis: latency, OverallScoreMillis: overall, CriticalFailureMillis: criticalMillis, BenchmarkVersion: profile.BenchmarkVersion, ArtifactID: artifactID, ObservedAtUnixMillis: observedAtUnixMillis}, nil
+}
+
+func ValidateTaskEvaluation(value capability.TaskEvaluation) error {
+	if value.ID == "" || value.ProfileID == "" || value.BindingID == "" || value.BindingRevision < 1 || value.CapabilityID == "" || value.BenchmarkVersion == "" || value.ArtifactID == "" || value.ObservedAtUnixMillis < 1 {
+		return ErrInvalidTaskEvaluation
+	}
+	if value.Result != capability.EvaluationUnknown && value.Result != capability.EvaluationSupported && value.Result != capability.EvaluationUnsupported {
+		return ErrInvalidTaskEvaluation
+	}
+	for _, score := range []int64{value.QualityScoreMillis, value.ReliabilityScoreMillis, value.LatencyScoreMillis, value.OverallScoreMillis, value.CriticalFailureMillis} {
+		if score < 0 || score > 1000 {
+			return ErrInvalidTaskEvaluation
+		}
+	}
+	return nil
+}

modules/capability/domain/task_evaluation_test.go

@@ -0,0 +1,35 @@
+package domain
+
+import (
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/artifact"
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+func TestBuildTaskEvaluationAggregatesOnlyProfileCases(t *testing.T) {
+	profile := capability.TaskEvaluationProfile{ID: "research-v1", Revision: 1, CapabilityID: "creator-advisory", Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "research-v1", RequiredCaseIDs: []string{"claim", "uncertainty"}, QualityWeightMillis: 600, ReliabilityWeightMillis: 300, LatencyWeightMillis: 100}
+	value, err := BuildTaskEvaluation(profile, "evaluation-1", "binding-1", 2, "creator-advisory", []capability.TaskCaseObservation{
+		{CaseID: "claim", Result: capability.EvaluationSupported, QualityScoreMillis: 900, LatencyMicros: 400_000, EvidenceArtifactRef: "artifact-case-1"},
+		{CaseID: "uncertainty", Result: capability.EvaluationSupported, QualityScoreMillis: 800, LatencyMicros: 600_000, EvidenceArtifactRef: "artifact-case-2"},
+	}, artifact.ArtifactID("artifact-summary"), 10)
+	if err != nil || value.Result != capability.EvaluationSupported || value.OverallScoreMillis == 0 || value.ProfileID != profile.ID {
+		t.Fatalf("evaluation=%+v err=%v", value, err)
+	}
+}
+
+func TestBuildTaskEvaluationDoesNotPromoteUnknown(t *testing.T) {
+	profile := capability.TaskEvaluationProfile{ID: "coding-v1", Revision: 1, CapabilityID: "creator-advisory", Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "coding-v1", RequiredCaseIDs: []string{"compile"}, QualityWeightMillis: 700, ReliabilityWeightMillis: 200, LatencyWeightMillis: 100}
+	value, err := BuildTaskEvaluation(profile, "evaluation-2", "binding-1", 2, "creator-advisory", []capability.TaskCaseObservation{{CaseID: "compile", Result: capability.EvaluationUnknown, QualityScoreMillis: 0, LatencyMicros: 0, EvidenceArtifactRef: "artifact-case"}}, artifact.ArtifactID("artifact-summary"), 11)
+	if err != nil || value.Result != capability.EvaluationUnknown {
+		t.Fatalf("evaluation=%+v err=%v", value, err)
+	}
+}
+
+func TestBuildAdditionalProfileRequiresUnresolvedEvidenceAndPreservesHistory(t *testing.T) {
+	parent := capability.TaskEvaluationProfile{ID: "general-v1", Revision: 1, CapabilityID: "creator-advisory", Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "general-v1", RequiredCaseIDs: []string{"general"}, QualityWeightMillis: 700, ReliabilityWeightMillis: 200, LatencyWeightMillis: 100}
+	profile, err := BuildAdditionalTaskEvaluationProfile(parent, capability.TaskEvaluationExpansionRequest{ParentProfileID: parent.ID, CapabilityID: parent.CapabilityID, TriggerEvidenceRef: "experience-unsolved-1", NewCaseIDs: []string{"edge-case"}, BenchmarkVersion: "additional-v1"}, "additional-v1", 1)
+	if err != nil || profile.Stage != capability.TaskEvaluationAdditional || profile.ParentProfileID != parent.ID || profile.RequiredCaseIDs[0] != "edge-case" {
+		t.Fatalf("profile=%+v err=%v", profile, err)
+	}
+}

modules/capability/ports/repository.go

@@ -18,6 +18,7 @@ type Repository interface {
 	SaveModelDescriptor(context.Context, capability.ModelDescriptor) error
 	SaveCognitiveBinding(context.Context, capability.CognitiveBinding) error
 	LoadCognitiveCandidates(context.Context, capability.CapabilityID, identity.PrincipalID) ([]capability.ResolvedCognitiveBinding, error)
+	LoadCognitiveCandidatesForProfile(context.Context, capability.CapabilityID, identity.PrincipalID, capability.TaskEvaluationProfileID) ([]capability.ResolvedCognitiveBinding, error)
 	LoadCognitiveCandidate(context.Context, capability.CapabilityBindingID, int64) (capability.ResolvedCognitiveBinding, error)
 	SaveCognitiveCanaryPromotion(context.Context, capability.CognitiveCanaryPromotion) error
 	SaveCognitiveActivationPromotion(context.Context, capability.CognitiveActivationPromotion) error
@@ -25,4 +26,5 @@ type Repository interface {
 	SaveCognitiveDiscovery(context.Context, capability.CognitiveDiscoveryRegistration) error
 	SaveEvaluatedCapability(context.Context, capability.EvaluatedCapability) error
 	SavePerformanceEvidence(context.Context, capability.PerformanceEvidence) error
+	SaveTaskEvaluation(context.Context, capability.TaskEvaluation) error
 }

modules/work/application/graph_runtime.go

@@ -5,12 +5,16 @@ import (
 	"errors"
 	"time"
 
+	"git.cin.su/m/Assistant/contracts/authority"
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/identity"
 	"git.cin.su/m/Assistant/contracts/work"
 	"git.cin.su/m/Assistant/modules/work/domain"
 	"git.cin.su/m/Assistant/modules/work/ports"
 )
 
 var ErrGraphDispatchBinding = errors.New("graph node dispatch binding is missing")
+var ErrTaskEvaluationCallbackMismatch = errors.New("task evaluation callback does not match graph node")
 
 type GraphScheduleRequest struct {
 	Graph   work.WorkGraph             `json:"graph"`
@@ -18,6 +22,12 @@ type GraphScheduleRequest struct {
 	Now     int64                      `json:"now_unix_millis"`
 }
 
+type TaskEvaluationScheduleRequest struct {
+	Plan    work.TaskEvaluationGraphRequest `json:"plan"`
+	Intents []work.AgentDispatchIntent      `json:"intents"`
+	Now     int64                           `json:"now_unix_millis"`
+}
+
 type GraphCompleteRequest struct {
 	GraphID   string           `json:"graph_id"`
 	Revision  int64            `json:"revision"`
@@ -36,6 +46,31 @@ type GraphSynthesisRequest struct {
 	Verified          bool                   `json:"verified"`
 }
 
+func CompleteTaskEvaluationNode(ctx context.Context, graphStore ports.GraphStore, evidenceSink ports.TaskEvaluationSink, request work.TaskEvaluationEvidenceCallback) (work.WorkGraph, error) {
+	if evidenceSink == nil || request.GraphID == "" || request.Revision < 1 || request.NodeID == "" || !request.Succeeded {
+		return work.WorkGraph{}, ErrTaskEvaluationCallbackMismatch
+	}
+	graph, err := graphStore.LoadWorkGraph(ctx, request.GraphID, request.Revision)
+	if err != nil {
+		return work.WorkGraph{}, err
+	}
+	matched := false
+	for _, node := range graph.Nodes {
+		if node.ID != request.NodeID {
+			continue
+		}
+		matched = node.Purpose == work.GraphNodePurposeTaskEvaluation && node.TaskProfileID == request.Evaluation.ProfileID && node.BindingID == request.Evaluation.BindingID
+		break
+	}
+	if !matched || request.Evaluation.BindingRevision < 1 || request.Evaluation.CapabilityID == "" {
+		return work.WorkGraph{}, ErrTaskEvaluationCallbackMismatch
+	}
+	if err := evidenceSink.SaveTaskEvaluation(ctx, request.Evaluation); err != nil {
+		return work.WorkGraph{}, err
+	}
+	return CompleteGraphNode(ctx, graphStore, request.GraphID, request.Revision, request.NodeID, true)
+}
+
 func SynthesizeGraph(ctx context.Context, store ports.GraphResultStore, request GraphSynthesisRequest) (work.ConflictSet, work.GraphSynthesisCandidate, error) {
 	conflict, synthesis, err := domain.BuildVerifiedGraphSynthesis(request.Conflict, request.Candidates, request.SelectedCandidate, request.VerifierRunID, request.VerifierIdentity, request.EvidenceRefs, request.Summary, request.Verified)
 	if err != nil {
@@ -105,6 +140,39 @@ func AdmitAndSchedule(ctx context.Context, store ports.GraphStore, request Graph
 	return next, ready, nil
 }
 
+// AdmitAndScheduleTaskEvaluation creates the durable general-first or
+// bounded-expansion fan-out before handing it to the existing graph scheduler.
+// The request path only persists/enqueues work; specialist execution happens
+// independently through the dispatch workers.
+func AdmitAndScheduleTaskEvaluation(ctx context.Context, store ports.GraphStore, request TaskEvaluationScheduleRequest) (work.WorkGraph, []work.GraphNodeID, error) {
+	graph, err := domain.BuildTaskEvaluationGraph(request.Plan)
+	if err != nil {
+		return work.WorkGraph{}, nil, err
+	}
+	intents := make([]work.AgentDispatchIntent, len(request.Intents))
+	copy(intents, request.Intents)
+	for i := range intents {
+		for _, node := range graph.Nodes {
+			if node.DispatchID != intents[i].DispatchID {
+				continue
+			}
+			intents[i].SpecialistPurpose = string(node.Purpose)
+			intents[i].TaskEvaluationProfileID = node.TaskProfileID
+			intents[i].TaskEvaluationBindingID = node.BindingID
+			intents[i].TaskEvaluationCaseIDs = append([]string(nil), node.CaseIDs...)
+			if node.TaskProfile != nil {
+				profile := *node.TaskProfile
+				profile.RequiredCaseIDs = append([]string(nil), node.TaskProfile.RequiredCaseIDs...)
+				intents[i].TaskEvaluationProfile = &profile
+			}
+			intents[i].TaskEvaluationCases = append([]capability.TaskEvaluationCase(nil), node.TaskCases...)
+			intents[i].TaskEvaluationExecution = &work.TaskEvaluationDispatchContext{GraphID: graph.ID, GraphRevision: graph.Revision, NodeID: node.ID, BindingRevision: request.Plan.BindingRevision, ActorID: identity.ActorID(request.Plan.ActorID), PrincipalID: identity.PrincipalID(request.Plan.PrincipalID), ScopeID: authority.ScopeID(request.Plan.ScopeID)}
+			break
+		}
+	}
+	return AdmitAndSchedule(ctx, store, GraphScheduleRequest{Graph: graph, Intents: intents, Now: request.Now})
+}
+
 func CompleteGraphNode(ctx context.Context, store ports.GraphStore, graphID string, revision int64, nodeID work.GraphNodeID, success bool) (work.WorkGraph, error) {
 	graph, err := store.LoadWorkGraph(ctx, graphID, revision)
 	if err != nil {

modules/work/application/task_evaluation_callback_test.go

@@ -0,0 +1,80 @@
+package application
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+type callbackGraphStore struct {
+	graph work.WorkGraph
+	saves int
+}
+
+func (s *callbackGraphStore) SaveWorkGraph(_ context.Context, graph work.WorkGraph) error {
+	s.graph = graph
+	s.saves++
+	return nil
+}
+func (s *callbackGraphStore) LoadWorkGraph(context.Context, string, int64) (work.WorkGraph, error) {
+	return s.graph, nil
+}
+func (s *callbackGraphStore) SaveDispatchIntent(context.Context, work.AgentDispatchIntent) error {
+	return nil
+}
+func (s *callbackGraphStore) EnqueueDispatch(context.Context, work.AgentDispatchQueueItem) error {
+	return nil
+}
+
+type callbackSink struct {
+	evaluation capability.TaskEvaluation
+	err        error
+}
+
+func (s *callbackSink) SaveTaskEvaluation(_ context.Context, value capability.TaskEvaluation) error {
+	s.evaluation = value
+	return s.err
+}
+
+func callbackRequest() (work.WorkGraph, work.TaskEvaluationEvidenceCallback) {
+	graph := work.WorkGraph{ID: "graph-1", Revision: 1, State: work.GraphRunning, Budget: work.GraphBudget{MaxParallel: 1, MaxAttempts: 1}, Nodes: []work.GraphNode{{ID: "node-1", DispatchID: "dispatch-1", IdempotencyKey: "idem-1", State: work.GraphNodeRunning, Purpose: work.GraphNodePurposeTaskEvaluation, TaskProfileID: "profile-1", BindingID: "binding-1"}}}
+	evaluation := capability.TaskEvaluation{ID: "evaluation-1", ProfileID: "profile-1", BindingID: "binding-1", BindingRevision: 2, CapabilityID: "capability-1", Result: capability.EvaluationSupported}
+	return graph, work.TaskEvaluationEvidenceCallback{GraphID: "graph-1", Revision: 1, NodeID: "node-1", Evaluation: evaluation, Succeeded: true}
+}
+
+func TestCompleteTaskEvaluationPersistsEvidenceBeforeGraphCompletion(t *testing.T) {
+	graph, callback := callbackRequest()
+	store := &callbackGraphStore{graph: graph}
+	sink := &callbackSink{}
+	completed, err := CompleteTaskEvaluationNode(context.Background(), store, sink, callback)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sink.evaluation.ID != "evaluation-1" || store.saves != 1 || completed.State != work.GraphCompleted || completed.Nodes[0].State != work.GraphNodeSuccess {
+		t.Fatalf("callback did not complete in order: evaluation=%+v saves=%d graph=%+v", sink.evaluation, store.saves, completed)
+	}
+}
+
+func TestCompleteTaskEvaluationLeavesNodeOpenWhenCapabilityRejectsEvidence(t *testing.T) {
+	graph, callback := callbackRequest()
+	store := &callbackGraphStore{graph: graph}
+	sink := &callbackSink{err: errors.New("capability unavailable")}
+	if _, err := CompleteTaskEvaluationNode(context.Background(), store, sink, callback); err == nil {
+		t.Fatal("expected capability failure")
+	}
+	if store.saves != 0 {
+		t.Fatalf("graph was advanced after capability failure: saves=%d", store.saves)
+	}
+}
+
+func TestCompleteTaskEvaluationRejectsLineageMismatch(t *testing.T) {
+	graph, callback := callbackRequest()
+	callback.Evaluation.ProfileID = "profile-other"
+	store := &callbackGraphStore{graph: graph}
+	if _, err := CompleteTaskEvaluationNode(context.Background(), store, &callbackSink{}, callback); !errors.Is(err, ErrTaskEvaluationCallbackMismatch) {
+		t.Fatalf("expected lineage rejection, got %v", err)
+	}
+}

modules/work/application/task_evaluation_dispatch_test.go

@@ -0,0 +1,47 @@
+package application
+
+import (
+	"context"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+type taskGraphStore struct {
+	graph   work.WorkGraph
+	intents []work.AgentDispatchIntent
+}
+
+func (s *taskGraphStore) SaveWorkGraph(_ context.Context, graph work.WorkGraph) error {
+	s.graph = graph
+	return nil
+}
+func (s *taskGraphStore) LoadWorkGraph(context.Context, string, int64) (work.WorkGraph, error) {
+	return s.graph, nil
+}
+func (s *taskGraphStore) SaveDispatchIntent(_ context.Context, intent work.AgentDispatchIntent) error {
+	s.intents = append(s.intents, intent)
+	return nil
+}
+func (s *taskGraphStore) EnqueueDispatch(context.Context, work.AgentDispatchQueueItem) error {
+	return nil
+}
+
+func TestAdmitAndScheduleTaskEvaluationCarriesSpecialistContext(t *testing.T) {
+	store := &taskGraphStore{}
+	request := TaskEvaluationScheduleRequest{
+		Plan: work.TaskEvaluationGraphRequest{
+			GraphID: "graph-task", Profile: capability.TaskEvaluationProfile{ID: "profile-general", Revision: 1, CapabilityID: "capability-chat", Stage: capability.TaskEvaluationGeneral, BenchmarkVersion: "general-v1", RequiredCaseIDs: []string{"case-a", "case-b"}, QualityWeightMillis: 600, ReliabilityWeightMillis: 300, LatencyWeightMillis: 100},
+			Cases:      []capability.TaskEvaluationCase{{CaseID: "case-a", Prompt: "one", EvidenceArtifactRef: "artifact-a"}, {CaseID: "case-b", Prompt: "two", EvidenceArtifactRef: "artifact-b"}},
+			BindingIDs: []capability.CapabilityBindingID{"binding-a"}, DispatchIDs: []string{"dispatch-a"}, IdempotencyPrefix: "eval", Budget: work.GraphBudget{MaxParallel: 1, MaxAttempts: 2},
+		},
+		Intents: []work.AgentDispatchIntent{{DispatchID: "dispatch-a", IdempotencyKey: "idem-a", DelegationID: "delegation-a", RunID: "run-a", ImplementationID: "impl", ImplementationRevision: 1, SourceRevision: "source", WorktreeID: "tree", VerificationPlanRef: "verify", CreatedAtUnixMillis: 1}},
+	}
+	if _, _, err := AdmitAndScheduleTaskEvaluation(context.Background(), store, request); err != nil {
+		t.Fatal(err)
+	}
+	if len(store.intents) != 1 || store.intents[0].TaskEvaluationProfileID != "profile-general" || store.intents[0].TaskEvaluationBindingID != "binding-a" || len(store.intents[0].TaskEvaluationCaseIDs) != 2 || store.intents[0].SpecialistPurpose != string(work.GraphNodePurposeTaskEvaluation) {
+		t.Fatalf("specialist context was not carried into dispatch: %+v", store.intents)
+	}
+}

modules/work/domain/task_evaluation_graph.go

@@ -0,0 +1,88 @@
+package domain
+
+import (
+	"errors"
+	"fmt"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+var ErrInvalidTaskEvaluationGraph = errors.New("invalid task evaluation graph request")
+
+// BuildTaskEvaluationGraph turns one bounded profile into durable specialist
+// nodes. It deliberately has no provider, endpoint or hardware inputs: those
+// are resolved later by the cognitive worker for each binding.
+func BuildTaskEvaluationGraph(request work.TaskEvaluationGraphRequest) (work.WorkGraph, error) {
+	if request.GraphID == "" || request.IdempotencyPrefix == "" || len(request.BindingIDs) == 0 || len(request.BindingIDs) != len(request.DispatchIDs) || request.Budget.MaxParallel < 1 || request.Budget.MaxAttempts < 1 {
+		return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+	}
+	if err := request.Profile.Validate(); err != nil {
+		return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+	}
+	if len(request.Cases) != len(request.Profile.RequiredCaseIDs) {
+		return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+	}
+	seenCases := make(map[string]struct{}, len(request.Cases))
+	for _, item := range request.Cases {
+		if item.CaseID == "" || item.Prompt == "" || item.EvidenceArtifactRef == "" {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		if _, exists := seenCases[item.CaseID]; exists {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		seenCases[item.CaseID] = struct{}{}
+	}
+	for _, requiredID := range request.Profile.RequiredCaseIDs {
+		if _, exists := seenCases[requiredID]; !exists {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+	}
+	if request.Profile.Stage == capability.TaskEvaluationGeneral {
+		if request.ParentGraphID != "" || request.ParentGraphRevision != 0 || request.ParentGraphState != "" || request.TriggerEvidenceRef != "" {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+	} else {
+		if request.ParentGraphID == "" || request.ParentGraphRevision < 1 || request.TriggerEvidenceRef == "" || (request.ParentGraphState != work.GraphCompleted && request.ParentGraphState != work.GraphPartial) {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		if request.Profile.ParentProfileID == "" {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+	}
+	seenBindings := make(map[capability.CapabilityBindingID]struct{}, len(request.BindingIDs))
+	seenDispatches := make(map[string]struct{}, len(request.DispatchIDs))
+	nodes := make([]work.GraphNode, 0, len(request.BindingIDs))
+	for i, bindingID := range request.BindingIDs {
+		if bindingID == "" || request.DispatchIDs[i] == "" {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		if _, ok := seenBindings[bindingID]; ok {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		if _, ok := seenDispatches[request.DispatchIDs[i]]; ok {
+			return work.WorkGraph{}, ErrInvalidTaskEvaluationGraph
+		}
+		seenBindings[bindingID] = struct{}{}
+		seenDispatches[request.DispatchIDs[i]] = struct{}{}
+		nodes = append(nodes, work.GraphNode{
+			ID:             work.GraphNodeID(fmt.Sprintf("%s-node-%d", request.GraphID, i+1)),
+			DispatchID:     request.DispatchIDs[i],
+			IdempotencyKey: fmt.Sprintf("%s:%s:%d", request.IdempotencyPrefix, bindingID, request.Profile.Revision),
+			State:          work.GraphNodeBlocked,
+			Purpose:        work.GraphNodePurposeTaskEvaluation,
+			TaskProfileID:  request.Profile.ID,
+			BindingID:      bindingID,
+			CaseIDs:        append([]string(nil), request.Profile.RequiredCaseIDs...),
+			TaskProfile:    cloneTaskEvaluationProfile(request.Profile),
+			TaskCases:      append([]capability.TaskEvaluationCase(nil), request.Cases...),
+		})
+	}
+	return work.WorkGraph{ID: request.GraphID, Revision: 1, State: work.GraphDraft, Nodes: nodes, Budget: request.Budget, ParentGraphID: request.ParentGraphID, ParentGraphRevision: request.ParentGraphRevision, TriggerEvidenceRef: request.TriggerEvidenceRef}, nil
+}
+
+func cloneTaskEvaluationProfile(value capability.TaskEvaluationProfile) *capability.TaskEvaluationProfile {
+	copyValue := value
+	copyValue.RequiredCaseIDs = append([]string(nil), value.RequiredCaseIDs...)
+	return &copyValue
+}

modules/work/domain/task_evaluation_graph_test.go

@@ -0,0 +1,52 @@
+package domain
+
+import (
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+func evaluationGraphRequest(stage capability.TaskEvaluationProfileStage) work.TaskEvaluationGraphRequest {
+	profile := capability.TaskEvaluationProfile{ID: "profile-1", Revision: 1, CapabilityID: "capability-1", Stage: stage, BenchmarkVersion: "general-v1", RequiredCaseIDs: []string{"case-a", "case-b"}, QualityWeightMillis: 600, ReliabilityWeightMillis: 300, LatencyWeightMillis: 100}
+	request := work.TaskEvaluationGraphRequest{GraphID: "graph-1", Profile: profile, BindingIDs: []capability.CapabilityBindingID{"binding-a", "binding-b"}, DispatchIDs: []string{"dispatch-a", "dispatch-b"}, IdempotencyPrefix: "task-eval", Budget: work.GraphBudget{MaxParallel: 2, MaxAttempts: 2}, Cases: []capability.TaskEvaluationCase{{CaseID: "case-a", Prompt: "short answer", EvidenceArtifactRef: "artifact-a"}, {CaseID: "case-b", Prompt: "long answer", EvidenceArtifactRef: "artifact-b"}}}
+	if stage == capability.TaskEvaluationAdditional {
+		request.Profile.ParentProfileID = "profile-general"
+		request.Profile.TriggerEvidenceRef = "artifact:unresolved-1"
+		request.Profile.Stage = capability.TaskEvaluationAdditional
+		request.ParentGraphID, request.ParentGraphRevision, request.ParentGraphState, request.TriggerEvidenceRef = "graph-general", 2, work.GraphPartial, "artifact:unresolved-1"
+	}
+	return request
+}
+
+func TestBuildTaskEvaluationGraphFansOutOneNodePerBinding(t *testing.T) {
+	graph, err := BuildTaskEvaluationGraph(evaluationGraphRequest(capability.TaskEvaluationGeneral))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(graph.Nodes) != 2 || graph.Nodes[0].Purpose != work.GraphNodePurposeTaskEvaluation || graph.Nodes[0].TaskProfileID != "profile-1" || len(graph.Nodes[0].CaseIDs) != 2 {
+		t.Fatalf("unexpected task graph nodes: %+v", graph.Nodes)
+	}
+	if graph.ParentGraphID != "" || graph.TriggerEvidenceRef != "" {
+		t.Fatalf("general graph unexpectedly has expansion lineage: %+v", graph)
+	}
+}
+
+func TestBuildTaskEvaluationGraphRequiresCompletedOrPartialGeneralParent(t *testing.T) {
+	request := evaluationGraphRequest(capability.TaskEvaluationAdditional)
+	request.ParentGraphState = work.GraphRunning
+	if _, err := BuildTaskEvaluationGraph(request); err == nil {
+		t.Fatal("expected additional graph to require a finished parent graph")
+	}
+}
+
+func TestBuildTaskEvaluationGraphRejectsGeneralReplacement(t *testing.T) {
+	request := evaluationGraphRequest(capability.TaskEvaluationGeneral)
+	request.ParentGraphID = "old-graph"
+	request.ParentGraphRevision = 2
+	request.ParentGraphState = work.GraphPartial
+	request.TriggerEvidenceRef = "artifact:unresolved"
+	if _, err := BuildTaskEvaluationGraph(request); err == nil {
+		t.Fatal("expected general graph replacement to be rejected")
+	}
+}

modules/work/ports/development.go

@@ -0,0 +1,15 @@
+package ports
+
+import (
+	"context"
+
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+// DevelopmentGateStore persists only the governed state machine and its
+// provenance. It does not create worktrees, execute code or grant promotion
+// authority.
+type DevelopmentGateStore interface {
+	LoadDevelopmentGate(context.Context, string) (work.DevelopmentGate, error)
+	SaveDevelopmentGate(context.Context, work.DevelopmentGate, int64) error
+}

modules/work/ports/graph.go

@@ -3,6 +3,7 @@ package ports
 import (
 	"context"
 
+	"git.cin.su/m/Assistant/contracts/capability"
 	"git.cin.su/m/Assistant/contracts/work"
 )
 
@@ -16,3 +17,9 @@ type GraphStore interface {
 type GraphResultStore interface {
 	SaveGraphSynthesis(context.Context, work.ConflictSet, []work.ResultCandidate, work.GraphSynthesisCandidate) error
 }
+
+// TaskEvaluationSink is a remote-capable boundary to Capability's owner.
+// Work never writes the capability schema directly.
+type TaskEvaluationSink interface {
+	SaveTaskEvaluation(context.Context, capability.TaskEvaluation) error
+}

tests/agent_execution/task_evaluation_dispatch_sql_test.go

@@ -0,0 +1,20 @@
+package agent_execution
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestTaskEvaluationDispatchMigrationPersistsWorkerContext(t *testing.T) {
+	payload, err := os.ReadFile("../../database/migrations/040_task_evaluation_dispatch.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sql := strings.ToLower(string(payload))
+	for _, marker := range []string{"work.agent_dispatch_intents", "specialist_purpose", "task_evaluation_profile_id", "task_evaluation_binding_id", "task_evaluation_case_ids", "work.graphs", "parent_graph_id", "work.graph_nodes", "case_ids", "set role work_role"} {
+		if !strings.Contains(sql, strings.ToLower(marker)) {
+			t.Fatalf("migration missing %q", marker)
+		}
+	}
+}