docs: record gpu adapter invocation qualification

docs: refresh audit completion matrix

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/work_repository.go

@@ -14,9 +14,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,6 +50,56 @@ 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 {
@@ -199,6 +250,26 @@ func (r *WorkRepository) LoadWorkGraph(ctx context.Context, graphID string, revi
 	return graph, nil
 }
 
+func (r *WorkRepository) SaveGraphSynthesis(ctx context.Context, conflict work.ConflictSet, candidates []work.ResultCandidate, synthesis work.GraphSynthesisCandidate) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	for _, candidate := range candidates {
+		if _, err := tx.Exec(ctx, `INSERT INTO work.graph_result_candidates(result_candidate_id,graph_id,graph_revision,node_id,author_run_id,artifact_refs,evidence_summary,summary) VALUES($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(result_candidate_id) DO NOTHING`, candidate.ID, candidate.GraphID, candidate.GraphRevision, candidate.NodeID, candidate.AuthorRunID, candidate.ArtifactRefs, candidate.EvidenceSummary, candidate.Summary); err != nil {
+			return err
+		}
+	}
+	if _, err := tx.Exec(ctx, `INSERT INTO work.graph_conflicts(conflict_id,graph_id,graph_revision,node_id,candidate_ids,resolved) VALUES($1,$2,$3,$4,$5,$6) ON CONFLICT(conflict_id) DO NOTHING`, conflict.ID, conflict.GraphID, conflict.GraphRevision, conflict.NodeID, conflict.CandidateIDs, conflict.Resolved); err != nil {
+		return err
+	}
+	if _, err := tx.Exec(ctx, `INSERT INTO work.graph_synthesis_candidates(synthesis_id,graph_id,graph_revision,node_id,candidate_ids,selected_candidate_id,dissent_candidate_ids,verifier_run_id,verifier_identity,evidence_refs,summary,state) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) ON CONFLICT(synthesis_id) DO NOTHING`, synthesis.ID, synthesis.GraphID, synthesis.GraphRevision, synthesis.NodeID, synthesis.CandidateIDs, synthesis.SelectedCandidateID, synthesis.DissentCandidateIDs, synthesis.VerifierRunID, synthesis.VerifierIdentity, synthesis.EvidenceRefs, synthesis.Summary, synthesis.State); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
 func (r *WorkRepository) RecoverStaleClaims(ctx context.Context, nowUnixMillis, staleAfterMillis int64) (int64, error) {
 	command, err := r.pool.Exec(ctx, `UPDATE work.agent_dispatch_queue SET state='QUEUED',claimed_by='',updated_at_unix_millis=$1 WHERE state='CLAIMED' AND updated_at_unix_millis <= $2`, nowUnixMillis, nowUnixMillis-staleAfterMillis)
 	if err != 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

@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
+	"strings"
 	"time"
 
 	"git.cin.su/m/Assistant/adapters/agentbridge"
@@ -39,17 +41,20 @@ func main() {
 	}
 	defer repository.Close()
 	var executor ports.AgentExecutor
-	if bridgeURL := os.Getenv("AGENT_EXECUTION_BRIDGE_URL"); bridgeURL != "" {
+	localFallback := false
+	if bridgeURL, bridgeConfigured := loadProtectedBridgeURL(); bridgeConfigured {
 		executor, err = agentbridge.NewHTTPExecutor(bridgeURL, &http.Client{Timeout: *leaseTTL})
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
 	} else {
-		fmt.Fprintln(os.Stderr, "agent execution bridge is not configured; dispatch claims are disabled; recovery-only mode")
+		executor = newLocalFallbackExecutor()
+		localFallback = true
+		fmt.Fprintln(os.Stderr, "protected agent execution bridge URL is not configured; local fallback preserves durable work without external mutation")
 	}
 	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)
 		}
 	}()
@@ -81,6 +86,27 @@ func main() {
 	}
 }
 
+func loadProtectedBridgeURL() (string, bool) {
+	return loadProtectedBridgeURLFrom("/run/secrets", "/run/secrets/agent_execution_bridge_url")
+}
+
+func loadProtectedBridgeURLFrom(root, path string) (string, bool) {
+	clean := filepath.Clean(path)
+	cleanRoot := filepath.Clean(root)
+	if clean != cleanRoot && !strings.HasPrefix(clean, cleanRoot+string(os.PathSeparator)) {
+		return "", false
+	}
+	payload, err := os.ReadFile(clean)
+	if err != nil {
+		return "", false
+	}
+	value := strings.TrimSpace(string(payload))
+	if value == "" || strings.ContainsAny(value, "\r\n") {
+		return "", false
+	}
+	return value, true
+}
+
 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:             "AGENT_EXECUTION_BRIDGE_URL is not configured",
+		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

@@ -4,9 +4,28 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"os"
+	"path/filepath"
 	"testing"
 )
 
+func TestLoadProtectedBridgeURL(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "agent_execution_bridge_url")
+	if err := os.WriteFile(path, []byte("http://bridge.local\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if value, configured := loadProtectedBridgeURLFrom(root, path); !configured || value != "http://bridge.local" {
+		t.Fatalf("protected bridge was not loaded: %q %v", value, configured)
+	}
+	if value, configured := loadProtectedBridgeURLFrom(root, filepath.Join(root, "missing")); configured || value != "" {
+		t.Fatalf("missing bridge was accepted: %q %v", value, configured)
+	}
+	if value, configured := loadProtectedBridgeURLFrom(root, "/tmp/not-protected"); configured || value != "" {
+		t.Fatalf("path outside protected root was accepted: %q %v", value, configured)
+	}
+}
+
 func TestWorkerStatusReportsRecoveryOnlyWithoutExecutor(t *testing.T) {
 	response := httptest.NewRecorder()
 	workerStatusHandler(false).ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/status", nil))
@@ -19,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/cognitive-benchmark/main.go

@@ -98,8 +98,9 @@ func main() {
 	manifestPath := flag.String("manifest", "", "benchmark manifest JSON")
 	outputPath := flag.String("output", "", "output artifact JSON")
 	timeout := flag.Duration("case-timeout", 30*time.Second, "deadline for each case")
+	maxOutputBytes := flag.Int64("max-output-bytes", 4096, "maximum advisory output bytes per case")
 	flag.Parse()
-	if *manifestPath == "" || *outputPath == "" || *timeout <= 0 {
+	if *manifestPath == "" || *outputPath == "" || *timeout <= 0 || *maxOutputBytes < 1 {
 		fatal(errors.New("manifest, output and positive case-timeout are required"))
 	}
 	input, err := os.ReadFile(*manifestPath)
@@ -110,7 +111,7 @@ func main() {
 	if err := json.Unmarshal(input, &plan); err != nil {
 		fatal(err)
 	}
-	artifact, err := run(context.Background(), plan, *timeout, time.Now().UTC())
+	artifact, err := run(context.Background(), plan, *timeout, *maxOutputBytes, time.Now().UTC())
 	if err != nil {
 		fatal(err)
 	}
@@ -125,7 +126,7 @@ func main() {
 	fmt.Printf("artifact=%s models=%d output=%s\n", artifact.ArtifactID, len(artifact.Results), *outputPath)
 }
 
-func run(ctx context.Context, plan manifest, timeout time.Duration, observed time.Time) (benchmarkArtifact, error) {
+func run(ctx context.Context, plan manifest, timeout time.Duration, maxOutputBytes int64, observed time.Time) (benchmarkArtifact, error) {
 	if plan.ArtifactID == "" || len(plan.Providers) == 0 {
 		return benchmarkArtifact{}, errors.New("invalid benchmark manifest")
 	}
@@ -142,7 +143,7 @@ func run(ctx context.Context, plan manifest, timeout time.Duration, observed tim
 			return provider.Candidates[i].ProviderModelID < provider.Candidates[j].ProviderModelID
 		})
 		for _, candidate := range provider.Candidates {
-			result, err := runModel(ctx, adapter, provider.ProviderInstanceID, candidate, timeout)
+			result, err := runModel(ctx, adapter, provider.ProviderInstanceID, candidate, timeout, maxOutputBytes)
 			if err != nil {
 				return benchmarkArtifact{}, err
 			}
@@ -169,7 +170,7 @@ func newProvider(candidate providerCandidate, timeout time.Duration) (models.Loc
 	}
 }
 
-func runModel(ctx context.Context, adapter models.LocalProvider, providerID string, candidate modelCandidate, timeout time.Duration) (modelResult, error) {
+func runModel(ctx context.Context, adapter models.LocalProvider, providerID string, candidate modelCandidate, timeout time.Duration, maxOutputBytes int64) (modelResult, error) {
 	if providerID == "" || candidate.ProviderModelID == "" || candidate.ModelDescriptorID == "" || candidate.ModelRevision < 1 || candidate.BindingID == "" || candidate.BindingRevision < 1 {
 		return modelResult{}, errors.New("invalid benchmark candidate")
 	}
@@ -178,7 +179,7 @@ func runModel(ctx context.Context, adapter models.LocalProvider, providerID stri
 	for index, item := range corpus {
 		caseCtx, cancel := context.WithTimeout(ctx, timeout)
 		started := time.Now()
-		response, err := adapter.Advise(caseCtx, cognitive.AdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(fmt.Sprintf("bench-%s-%d", digest(candidate.BindingID)[:12], index)), ActorID: "benchmark-actor", PrincipalID: "domovoy-creator-principal", ScopeID: "benchmark-public-synthetic", Message: item.prompt, Locale: "ru-RU", MaxOutputBytes: 4096, ProviderBindingID: capability.CapabilityBindingID(candidate.BindingID), ProviderBindingRevision: candidate.BindingRevision, ProviderInstanceID: capability.ProviderInstanceID(providerID), ModelDescriptorID: capability.ModelDescriptorID(candidate.ModelDescriptorID), ProviderModelID: capability.ProviderModelID(candidate.ProviderModelID)})
+		response, err := adapter.Advise(caseCtx, cognitive.AdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(fmt.Sprintf("bench-%s-%d", digest(candidate.BindingID)[:12], index)), ActorID: "benchmark-actor", PrincipalID: "domovoy-creator-principal", ScopeID: "benchmark-public-synthetic", Message: item.prompt, Locale: "ru-RU", MaxOutputBytes: int(maxOutputBytes), ProviderBindingID: capability.CapabilityBindingID(candidate.BindingID), ProviderBindingRevision: candidate.BindingRevision, ProviderInstanceID: capability.ProviderInstanceID(providerID), ModelDescriptorID: capability.ModelDescriptorID(candidate.ModelDescriptorID), ProviderModelID: capability.ProviderModelID(candidate.ProviderModelID)})
 		cancel()
 		caseResult := caseResult{CaseID: item.id, LatencyMillis: time.Since(started).Milliseconds()}
 		if err != nil {

cmd/cognitive-worker/main.go

@@ -17,6 +17,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 	"time"
 )
@@ -92,14 +93,20 @@ func main() {
 		discoveries["lifeboat"] = lifeboat
 		builtinLocal = &lifeboat
 	}
-	gpuAdapter, err := models.NewOllamaAdapter(envOr("LOCAL_GPU_PROVIDER_URL", "http://192.168.220.91:11434"), nil)
-	if err != nil {
-		log.Fatal(err)
+	gpuURL, gpuKey, gpuConfigured, gpuErr := loadProtectedGPUConfiguration()
+	if gpuErr != nil {
+		log.Printf("optional GPU provider disabled: %v", gpuErr)
+	} else if gpuConfigured {
+		gpuAdapter, adapterErr := models.NewOpenAICompatibleLocalAdapterWithAPIKey(gpuURL, gpuKey, nil)
+		if adapterErr != nil {
+			log.Printf("optional GPU provider disabled: %v", adapterErr)
+		} else {
+			gpu := providerRegistration{ProviderInstanceID: "local-gpu-opportunistic", Kind: "openai-compatible-chat-v1", EndpointRef: "local-gpu-opportunistic-v1", CredentialRef: "credential://domovoy/gpu/provider-api-key/v1", AuthMode: capability.AuthKey, BillingMode: capability.BillingFree, DataPolicy: capability.DataPolicyExternalMessageOnly, Provider: gpuAdapter, Discovery: gpuAdapter}
+			providers[gpu.Kind] = append(providers[gpu.Kind], gpu)
+			discoveries["gpu"] = gpu
+			externalRecovery = append(externalRecovery, gpu)
+		}
 	}
-	gpu := providerRegistration{ProviderInstanceID: "local-gpu-opportunistic", Kind: "ollama-v1", EndpointRef: "local-gpu-opportunistic-v1", AuthMode: capability.AuthNone, BillingMode: capability.BillingFree, DataPolicy: capability.DataPolicyExternalMessageOnly, Provider: gpuAdapter, Discovery: gpuAdapter}
-	providers[gpu.Kind] = append(providers[gpu.Kind], gpu)
-	discoveries["gpu"] = gpu
-	externalRecovery = append(externalRecovery, gpu)
 	if openAIProvider != nil {
 		kind := capability.ProviderKind(envOr("OPENAI_PROVIDER_KIND", "openai-responses-v1"))
 		providers[kind] = append(providers[kind], providerRegistration{ProviderInstanceID: "openai-bootstrap", Kind: kind, EndpointRef: capability.EndpointBindingRef(envOr("OPENAI_ENDPOINT_REF", "openai-responses-default")), CredentialRef: capability.CredentialRef(envOr("OPENAI_CREDENTIAL_REF", "openai-advisory-v1")), AuthMode: capability.AuthKey, BillingMode: capability.BillingPerInput, DataPolicy: capability.DataPolicyExternalMessageOnly, Provider: openAIProvider})
@@ -111,7 +118,7 @@ func main() {
 	mediumReadinessClient := &http.Client{Timeout: 10 * time.Second}
 	lifeboatURL := strings.TrimSuffix(strings.TrimRight(envOr("LOCAL_LIFEBOAT_PROVIDER_URL", "http://cognitive-lifeboat:8086/v1"), "/"), "/v1") + "/health"
 	fleetClient := &http.Client{Timeout: 2 * time.Second}
-	preferredFleet := capability.FleetTier(envOr("COGNITIVE_PREFERRED_FLEET_TIER", string(capability.FleetTierHeavy)))
+	preferredFleet := capability.FleetTier(envOr("COGNITIVE_PREFERRED_FLEET_TIER", string(capability.FleetTierFast)))
 	cpuFleetHeaders := map[string]string{}
 	if cpuAPIKey != "" {
 		cpuFleetHeaders["Authorization"] = "Bearer " + cpuAPIKey
@@ -137,17 +144,24 @@ func main() {
 	if mediumURL != "" {
 		readinessProbes = append(readinessProbes, mediumHealthProbe)
 	}
-	readinessProbes = append(readinessProbes,
-		health.HTTPProbe(readinessClient, lifeboatURL),
-		health.OptionalHTTPProbe(readinessClient, strings.TrimRight(envOr("LOCAL_GPU_PROVIDER_URL", "http://192.168.220.91:11434"), "/")+"/api/tags"),
-	)
-	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "cognitive-worker", Probes: readinessProbes})
-	mux.Handle("/v1/fleet/readiness", fleetReadinessHandler(fleetClient, preferredFleet, []fleetEndpoint{
+	readinessProbes = append(readinessProbes, health.HTTPProbe(readinessClient, lifeboatURL))
+	if gpuConfigured {
+		gpuHeaders := map[string]string{"Authorization": "Bearer " + gpuKey}
+		gpuProbe := health.OptionalHTTPProbeWithHeaders(readinessClient, strings.TrimRight(gpuURL, "/")+"/models", gpuHeaders)
+		gpuProbe.Timeout = 10 * time.Second
+		readinessProbes = append(readinessProbes, gpuProbe)
+	}
+
+	fleetEndpoints := []fleetEndpoint{
 		{ProviderID: "local-cpu-primary", ModelID: "local-cpu-model", Tier: capability.FleetTierFast, URL: cpuEndpoint, Headers: cpuFleetHeaders, Client: &http.Client{Timeout: 10 * time.Second}},
 		{ProviderID: "local-medium-primary", ModelID: "local-medium-model", Tier: capability.FleetTierMedium, URL: mediumEndpoint, Headers: mediumHeaders, Client: mediumReadinessClient},
-		{ProviderID: "local-gpu-opportunistic", ModelID: "gpu-opportunistic", Tier: capability.FleetTierHeavy, URL: strings.TrimRight(envOr("LOCAL_GPU_PROVIDER_URL", "http://192.168.220.91:11434"), "/") + "/api/tags"},
 		{ProviderID: "cognitive-lifeboat", ModelID: "qwen3-8b-lifeboat", Tier: capability.FleetTierLifeboat, URL: lifeboatURL},
-	}))
+	}
+	if gpuConfigured {
+		fleetEndpoints = append(fleetEndpoints, fleetEndpoint{ProviderID: "local-gpu-opportunistic", ModelID: "gpu-opportunistic", Tier: capability.FleetTierHeavy, URL: strings.TrimRight(gpuURL, "/") + "/models", Headers: map[string]string{"Authorization": "Bearer " + gpuKey}})
+	}
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "cognitive-worker", Probes: readinessProbes})
+	mux.Handle("/v1/fleet/readiness", fleetReadinessHandler(fleetClient, preferredFleet, fleetEndpoints))
 	mux.HandleFunc("POST /v1/proposals/deterministic", deterministicProposal)
 	mux.HandleFunc("POST /v1/advisory-policy", gateway.policyHandler)
 	mux.HandleFunc("POST /v1/advisories", gateway.advisoryHandler)
@@ -244,6 +258,46 @@ func loadLocalCPUProviderAPIKey() (string, error) {
 	return loadProviderAPIKey("LOCAL_CPU_PROVIDER_API_KEY", "LOCAL_CPU_PROVIDER_API_KEY_FILE", "LOCAL_CPU_PROVIDER_CREDENTIAL_REF", "credential://domovoy/local-cpu/provider-api-key/v1")
 }
 
+const (
+	gpuProviderURLFile = "/run/secrets/llm_gpu_gateway_url"
+	gpuProviderKeyFile = "/run/secrets/llm_gpu_gateway_api_key"
+)
+
+func loadProtectedGPUConfiguration() (string, string, bool, error) {
+	urlValue, err := readProtectedRuntimeValue(gpuProviderURLFile)
+	if errors.Is(err, os.ErrNotExist) {
+		return "", "", false, nil
+	}
+	if err != nil {
+		return "", "", false, err
+	}
+	key, err := readProtectedRuntimeValue(gpuProviderKeyFile)
+	if errors.Is(err, os.ErrNotExist) {
+		return "", "", false, fmt.Errorf("GPU provider key is not configured")
+	}
+	if err != nil {
+		return "", "", false, err
+	}
+	return urlValue, key, true, nil
+}
+
+func readProtectedRuntimeValue(path string) (string, error) {
+	const root = "/run/secrets"
+	clean := filepath.Clean(path)
+	if clean != root && !strings.HasPrefix(clean, root+string(os.PathSeparator)) {
+		return "", fmt.Errorf("protected runtime path outside secret root")
+	}
+	payload, err := os.ReadFile(clean)
+	if err != nil {
+		return "", err
+	}
+	value := strings.TrimSpace(string(payload))
+	if value == "" || strings.ContainsAny(value, "\r\n") {
+		return "", fmt.Errorf("protected runtime value is empty or multiline")
+	}
+	return value, nil
+}
+
 func deterministicAdvisory(w http.ResponseWriter, r *http.Request) {
 	request, ok := decodeAdvisoryRequest(w, r)
 	if !ok {

cmd/cognitive-worker/main_test.go

@@ -68,3 +68,9 @@ func TestLoadProviderAPIKeyRejectsMediumDirectEnvironmentSecret(t *testing.T) {
 		t.Fatal("expected direct medium environment secret to be rejected")
 	}
 }
+
+func TestReadProtectedRuntimeValueRejectsPathOutsideSecretRoot(t *testing.T) {
+	if _, err := readProtectedRuntimeValue("/tmp/not-a-domovoy-secret"); err == nil {
+		t.Fatal("expected protected path rejection")
+	}
+}

cmd/work-graph-runtime/main.go

@@ -55,6 +55,19 @@ func main() {
 		}
 		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 {
+			http.Error(w, "invalid graph synthesis request", http.StatusBadRequest)
+			return
+		}
+		conflict, synthesis, err := application.SynthesizeGraph(r.Context(), repository, request)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		writeJSON(w, map[string]any{"conflict": conflict, "synthesis": synthesis})
+	})
 	addr := os.Getenv("LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8088"

contracts/capability/cognitive_registry.go

@@ -26,6 +26,7 @@ type PerformanceEvidenceID ids.ID
 type BillingMode string
 type AuthMode string
 type SelectionObjective string
+type ModelRatingCategory string
 
 const (
 	QualificationDiscovered QualificationState = "DISCOVERED"
@@ -73,6 +74,11 @@ const (
 	SelectionQuality  SelectionObjective = "QUALITY"
 	SelectionSpeed    SelectionObjective = "SPEED"
 	SelectionEconomy  SelectionObjective = "ECONOMY"
+
+	ModelRatingUnrated  ModelRatingCategory = "UNRATED"
+	ModelRatingFast     ModelRatingCategory = "FAST"
+	ModelRatingBalanced ModelRatingCategory = "BALANCED"
+	ModelRatingQuality  ModelRatingCategory = "QUALITY"
 )
 
 // ProviderInstance contains only opaque references to endpoint and credentials.
@@ -164,6 +170,18 @@ type ResolvedCognitiveBinding struct {
 	Model       ModelDescriptor
 	Evaluation  *EvaluatedCapability
 	Performance *PerformanceEvidence
+	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"`
 }
 
 type CognitiveResultClass string

contracts/work/graph.go

@@ -53,21 +53,43 @@ type WorkGraph struct {
 }
 
 type ResultCandidate struct {
-	ID              string
-	GraphID         string
-	GraphRevision   int64
-	NodeID          GraphNodeID
-	AuthorRunID     AgentRunID
-	ArtifactRefs    []EvidenceRef
-	EvidenceSummary string
-	Summary         string
+	ID              string        `json:"id"`
+	GraphID         string        `json:"graph_id"`
+	GraphRevision   int64         `json:"graph_revision"`
+	NodeID          GraphNodeID   `json:"node_id"`
+	AuthorRunID     AgentRunID    `json:"author_run_id"`
+	ArtifactRefs    []EvidenceRef `json:"artifact_refs"`
+	EvidenceSummary string        `json:"evidence_summary"`
+	Summary         string        `json:"summary"`
 }
 
 type ConflictSet struct {
-	ID            string
-	GraphID       string
-	GraphRevision int64
-	NodeID        GraphNodeID
-	CandidateIDs  []string
-	Resolved      bool
+	ID            string      `json:"id"`
+	GraphID       string      `json:"graph_id"`
+	GraphRevision int64       `json:"graph_revision"`
+	NodeID        GraphNodeID `json:"node_id"`
+	CandidateIDs  []string    `json:"candidate_ids"`
+	Resolved      bool        `json:"resolved"`
+}
+
+type GraphSynthesisState string
+
+const GraphSynthesisVerified GraphSynthesisState = "VERIFIED"
+
+// GraphSynthesisCandidate retains every competing result while recording the
+// independently verified selection. It is a candidate, not an external action
+// or authority grant.
+type GraphSynthesisCandidate struct {
+	ID                  string              `json:"id"`
+	GraphID             string              `json:"graph_id"`
+	GraphRevision       int64               `json:"graph_revision"`
+	NodeID              GraphNodeID         `json:"node_id"`
+	CandidateIDs        []string            `json:"candidate_ids"`
+	SelectedCandidateID string              `json:"selected_candidate_id"`
+	DissentCandidateIDs []string            `json:"dissent_candidate_ids"`
+	VerifierRunID       AgentRunID          `json:"verifier_run_id"`
+	VerifierIdentity    string              `json:"verifier_identity"`
+	EvidenceRefs        []EvidenceRef       `json:"evidence_refs"`
+	Summary             string              `json:"summary"`
+	State               GraphSynthesisState `json:"state"`
 }

contracts/work/self_development.go

@@ -1,5 +1,7 @@
 package work
 
+import "time"
+
 type DevelopmentStage string
 
 const (
@@ -15,6 +17,8 @@ const (
 
 type DevelopmentGate struct {
 	ID                   string
+	Revision             int64
+	UpdatedAtUnixMillis  int64
 	Stage                DevelopmentStage
 	EvidenceRefs         []string
 	ProposalRef          string
@@ -27,3 +31,101 @@ type DevelopmentGate struct {
 	PromotionRef         string
 	RollbackRef          string
 }
+
+// ExtensionProposalStage is deliberately proposal-only in this contract. A
+// proposal does not authorize source changes, provider calls, deployment or
+// promotion; those stages require the existing governed development gate.
+type ExtensionProposalStage string
+
+const ExtensionProposalProposed ExtensionProposalStage = "PROPOSED"
+
+// ExtensionEvidence is an immutable reference to an observation that points
+// at a repeated or corroborated improvement signal. The payload is owned by
+// its source module; Work stores only the typed reference and stable signal
+// key.
+type ExtensionEvidence struct {
+	Ref       string
+	SignalKey string
+}
+
+// ExtensionProposalRequest contains the operator/governance information
+// needed to decide whether an evidence pattern is worth reviewing. Empty
+// fields are rejected by the proposal generator rather than inferred.
+type ExtensionProposalRequest struct {
+	ID                  string
+	DesiredOutcome      string
+	SmallestChangeLayer string
+	AffectedOwners      []string
+	AffectedContracts   []string
+	RiskTier            string
+	EvaluationPlan      []string
+	Alternatives        []string
+	RollbackPlan        string
+	Assumptions         []string
+	CreatedAt           time.Time
+}
+
+// ExtensionProposal is a bounded, evidence-bearing candidate for governed
+// development. It intentionally contains no executable command, credential,
+// authority grant, implementation body or promotion decision.
+type ExtensionProposal struct {
+	ID                     string
+	Stage                  ExtensionProposalStage
+	EvidenceRefs           []string
+	DeduplicatedSignalKeys []string
+	DesiredOutcome         string
+	SmallestChangeLayer    string
+	AffectedOwners         []string
+	AffectedContracts      []string
+	RiskTier               string
+	EvaluationPlan         []string
+	Alternatives           []string
+	RollbackPlan           string
+	Assumptions            []string
+	CreatedAtUnixMillis    int64
+}
+
+type DevelopmentScaffoldStage string
+
+const DevelopmentScaffoldSandboxed DevelopmentScaffoldStage = "SANDBOXED"
+
+// DevelopmentScaffoldRequest describes the boundary a later control plane
+// would use to create an isolated worktree. This value object itself performs
+// no checkout or filesystem operation.
+type DevelopmentScaffoldRequest struct {
+	ID                  string
+	ProposalRef         string
+	BaseRepoRevision    string
+	WorktreeRef         string
+	TaskIntent          string
+	Modules             []string
+	AllowedPaths        []string
+	ForbiddenPaths      []string
+	ProtectedPaths      []string
+	RequiredTests       []string
+	ArtifactLineageRefs []string
+	ProtectedMainAccess string
+	ProductionAccess    string
+	SecretAccess        string
+	CreatedAt           time.Time
+}
+
+// DevelopmentScaffold is a provenance-linked task-packet candidate. It has
+// no executable instruction, credential, checkout handle or authority grant.
+type DevelopmentScaffold struct {
+	ID                  string
+	Stage               DevelopmentScaffoldStage
+	ProposalRef         string
+	BaseRepoRevision    string
+	WorktreeRef         string
+	TaskIntent          string
+	Modules             []string
+	AllowedPaths        []string
+	ForbiddenPaths      []string
+	RequiredTests       []string
+	ArtifactLineageRefs []string
+	ProtectedMainAccess string
+	ProductionAccess    string
+	SecretAccess        string
+	CreatedAtUnixMillis int64
+}

database/migrations/036_work_graph_result_synthesis.sql

@@ -0,0 +1,58 @@
+BEGIN;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.graph_result_candidates (
+  result_candidate_id TEXT PRIMARY KEY,
+  graph_id TEXT NOT NULL,
+  graph_revision BIGINT NOT NULL,
+  node_id TEXT NOT NULL,
+  author_run_id TEXT NOT NULL,
+  artifact_refs TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  evidence_summary TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (result_candidate_id <> ''), CHECK (graph_id <> ''), CHECK (graph_revision > 0),
+  CHECK (node_id <> ''), CHECK (author_run_id <> ''), CHECK (evidence_summary <> ''), CHECK (summary <> ''),
+  FOREIGN KEY (graph_id, graph_revision) REFERENCES work.graphs(graph_id, revision)
+);
+
+CREATE TABLE IF NOT EXISTS work.graph_conflicts (
+  conflict_id TEXT PRIMARY KEY,
+  graph_id TEXT NOT NULL,
+  graph_revision BIGINT NOT NULL,
+  node_id TEXT NOT NULL,
+  candidate_ids TEXT[] NOT NULL,
+  resolved BOOLEAN NOT NULL DEFAULT FALSE,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (conflict_id <> ''), CHECK (graph_id <> ''), CHECK (graph_revision > 0), CHECK (node_id <> ''),
+  CHECK (cardinality(candidate_ids) >= 2),
+  FOREIGN KEY (graph_id, graph_revision) REFERENCES work.graphs(graph_id, revision)
+);
+
+CREATE TABLE IF NOT EXISTS work.graph_synthesis_candidates (
+  synthesis_id TEXT PRIMARY KEY,
+  graph_id TEXT NOT NULL,
+  graph_revision BIGINT NOT NULL,
+  node_id TEXT NOT NULL,
+  candidate_ids TEXT[] NOT NULL,
+  selected_candidate_id TEXT NOT NULL,
+  dissent_candidate_ids TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  verifier_run_id TEXT NOT NULL,
+  verifier_identity TEXT NOT NULL,
+  evidence_refs TEXT[] NOT NULL,
+  summary TEXT NOT NULL,
+  state TEXT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (synthesis_id <> ''), CHECK (graph_id <> ''), CHECK (graph_revision > 0), CHECK (node_id <> ''),
+  CHECK (cardinality(candidate_ids) >= 2), CHECK (selected_candidate_id <> ''), CHECK (verifier_run_id <> ''),
+  CHECK (verifier_identity <> ''), CHECK (cardinality(evidence_refs) >= 1), CHECK (summary <> ''), CHECK (state = 'VERIFIED'),
+  FOREIGN KEY (graph_id, graph_revision) REFERENCES work.graphs(graph_id, revision)
+);
+
+CREATE INDEX IF NOT EXISTS graph_result_candidates_node_idx ON work.graph_result_candidates(graph_id, graph_revision, node_id);
+CREATE INDEX IF NOT EXISTS graph_conflicts_node_idx ON work.graph_conflicts(graph_id, graph_revision, node_id);
+CREATE INDEX IF NOT EXISTS graph_synthesis_node_idx ON work.graph_synthesis_candidates(graph_id, graph_revision, node_id);
+
+RESET ROLE;
+COMMIT;

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;

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}" } }
@@ -114,7 +118,6 @@ services:
       WORK_POSTGRES_CREDENTIAL_REF: credential://domovoy/work/db-password/v1
       WORK_POSTGRES_PASSWORD_FILE: /run/secrets/work_db_password
       SECRET_BACKEND_ROOT: /run/secrets
-      AGENT_EXECUTION_BRIDGE_URL: ${AGENT_EXECUTION_BRIDGE_URL:-}
     depends_on: { postgres: { condition: service_healthy } }
     volumes:
       - assistant_core_secrets:/run/secrets:ro
@@ -218,7 +221,6 @@ services:
       LOCAL_MEDIUM_PROVIDER_API_KEY_FILE: ${LOCAL_MEDIUM_PROVIDER_API_KEY_FILE:-}
       LOCAL_MEDIUM_PROVIDER_CREDENTIAL_REF: ${LOCAL_MEDIUM_PROVIDER_CREDENTIAL_REF:-credential://domovoy/local-medium/provider-api-key/v1}
       LOCAL_LIFEBOAT_PROVIDER_URL: http://cognitive-lifeboat:8086/v1
-      LOCAL_GPU_PROVIDER_URL: http://192.168.220.91:11434
       COGNITIVE_OWNER_PRINCIPAL_ID: domovoy-creator-principal
       COGNITIVE_ALLOW_CANARY: "true"
     depends_on: [core-runtime, cognitive-lifeboat]

dev/ACTIVE_TASK.json

@@ -1,5 +1,5 @@
 {
-  "task_file": "dev/tasks/DEV-000178-heavy-qualification-refresh.json",
-  "task_id": "DEV-000178",
+  "task_file": "dev/tasks/DEV-000207-gpu-invocation-qualification.json",
+  "task_id": "DEV-000207",
   "task_revision": 1
 }

dev/tasks/DEV-000179-runtime-status-consolidation.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000179",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "5960844fcb7b9bfba9c24e18a5d15b569d0d3a08",
+  "risk_tier": "E",
+  "intent": "Synchronize audit projections with current production runtime evidence after the Heavy qualification deployment.",
+  "requirement_ids": ["AUDIT-COMPLETION-TRUTH", "WP-301", "WP-400", "WP-102", "WP-600"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/evidence/audit-runtime-status-2026-08-22-v4.json", "docs/evidence/audit-completion-matrix-2026-08-22-v1.json", "docs/PROJECT_STATUS.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000179-runtime-status-consolidation.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": ["live health/readiness/status endpoints"], "may_change": []},
+  "semantic_owner": "none; audit projection",
+  "canonical_state": [],
+  "state_transitions": ["stale audit projection -> current production runtime evidence"],
+  "side_effects_and_privileges": ["read-only live probes"],
+  "persistence_and_migrations": ["immutable JSON evidence only"],
+  "failure_retry_restart": ["not applicable"],
+  "assumptions": ["production revision is read from creator-web runtime environment", "runtime readiness is not treated as capability qualification"],
+  "acceptance_scenarios": ["public health is current", "research/work-graph readiness is current", "agent recovery-only state is explicit", "fleet tiers and selected tier are current", "no secrets 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 -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl/independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000180-bounded-medium-qualification-output.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000180",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "2ed2302526f6915c9ddef852ed17a8c47f716cc2",
+  "risk_tier": "E",
+  "intent": "Allow the existing synthetic qualification benchmark to bound maximum output bytes per case for slow local providers.",
+  "requirement_ids": ["WP-200", "AUDIT-COMPLETION-TRUTH"],
+  "allowed_change_scope": {"modules": ["cognitive benchmark"], "paths": ["cmd/cognitive-benchmark/main.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000180-bounded-medium-qualification-output.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "cmd/cognitive-worker/**", "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 cognitive advisory request contract"], "may_change": ["benchmark CLI parameter only"]},
+  "semantic_owner": "cognitive benchmark",
+  "canonical_state": [],
+  "state_transitions": ["fixed benchmark output cap -> explicit bounded qualification run"],
+  "side_effects_and_privileges": ["none"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["non-positive output cap rejected; default preserves previous 4096-byte behavior"],
+  "assumptions": ["bounded output is valid only for synthetic exact-answer corpus and does not alter production provider configuration"],
+  "acceptance_scenarios": ["default behavior remains unchanged", "positive output cap is forwarded to advisory request", "invalid cap fails closed", "no provider boundary is bypassed"],
+  "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 -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl/independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000181-medium-bounded-retest-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000181",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "6f0e099632a79af90eab439b4f026cd31abaad26",
+  "risk_tier": "E",
+  "intent": "Record the final bounded Medium qualification retest after adding an explicit benchmark output cap.",
+  "requirement_ids": ["WP-200", "AUDIT-COMPLETION-TRUTH"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/evidence/wp-200-medium-qualification-2026-08-22-v3.json", "docs/PROJECT_STATUS.md", "docs/evidence/audit-completion-matrix-2026-08-22-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000181-medium-bounded-retest-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": ["bounded cognitive benchmark artifact"], "may_change": []},
+  "semantic_owner": "none; audit evidence projection",
+  "canonical_state": [],
+  "state_transitions": ["Medium output-cap hypothesis -> verified runtime performance gap"],
+  "side_effects_and_privileges": ["one-shot benchmark only; no lifecycle mutation"],
+  "persistence_and_migrations": ["immutable JSON evidence only"],
+  "failure_retry_restart": ["60-second case timeout and 256-byte cap are recorded; unsupported result is not promoted"],
+  "assumptions": ["benchmark used the existing cognitive adapter and current production Medium revisions", "a bounded exact-answer corpus is sufficient to disprove the output-cap hypothesis"],
+  "acceptance_scenarios": ["all four cases record approximately 60-second timeout", "quality remains 0‰ and critical failure 1000‰", "Medium remains unqualified", "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 -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl/independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000182-model-rating-and-adaptive-routing.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000182",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "4709ef46076cf5c22522bbfea785fdb3c6220c14",
+  "risk_tier": "E",
+  "intent": "Expose an evidence-based model rating and adaptive routing policy so model category follows qualification and observed performance rather than provider or hardware names.",
+  "requirement_ids": ["WP-200", "WP-601", "adaptive model routing", "CPU-first current operation"],
+  "allowed_change_scope": {"modules": ["capability", "cognitive-worker"], "paths": ["contracts/capability/cognitive_registry.go", "modules/capability/domain/cognitive_registry.go", "modules/capability/domain/fleet.go", "modules/capability/domain/fleet_test.go", "cmd/cognitive-worker/main.go", "cmd/cognitive-worker/fleet_status_test.go", "modules/capability/domain/model_rating_test.go", "docs/MODEL_FLEET_POLICY.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000182-model-rating-and-adaptive-routing.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "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": ["EvaluatedCapability", "PerformanceEvidence", "CognitiveRequirement"], "may_change": ["provider-neutral model rating projection"]},
+  "semantic_owner": "capability",
+  "canonical_state": ["existing owner-local qualification and performance evidence; rating is a derived projection"],
+  "state_transitions": ["unrated -> rated only after supported qualification evidence; category is recomputed from current evidence; routing chooses an eligible rated candidate and falls back on invocation failure"],
+  "side_effects_and_privileges": ["none; no provider invocation or external mutation"],
+  "persistence_and_migrations": ["no migration; rating is derived and serializable"],
+  "failure_retry_restart": ["missing or stale evidence yields UNRATED and cannot silently claim quality; existing gateway fallback remains authoritative"],
+  "assumptions": ["CPU is the current operational choice, but routing remains provider- and hardware-neutral", "discovery never activates a binding"],
+  "acceptance_scenarios": ["supported evidence produces a visible rating and category", "missing evidence remains UNRATED", "quality objective prefers higher evidence rating", "speed objective prefers lower observed latency", "provider identity alone cannot raise a rating", "CPU is preferred now but all ready capability classes remain valid failover candidates"],
+  "required_tests": ["go test ./...", "go vet ./...", "preflight", "check-diff", "check-architecture", "independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000184-gpu-openai-protected-provider.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000184",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "16a0e8c4924a2e644294e12f048e747c00f940b9",
+  "risk_tier": "E",
+  "intent": "Connect an optional OpenAI-compatible GPU provider through protected Domovoy storage without literal provider credentials or hardwired environment configuration, while preserving CPU/Lifeboat degraded operation.",
+  "requirement_ids": ["GPU provider endpoint is authenticated through protected storage", "GPU absence or invalid configuration does not stop cognitive-worker", "fleet readiness and discovery use OpenAI-compatible /v1/models", "CPU and Lifeboat remain available fallback paths"],
+  "allowed_change_scope": {"modules": ["cognitive-worker", "deployment"], "paths": ["cmd/cognitive-worker/**", "deploy/docker-compose.prod.yml", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000184-gpu-openai-protected-provider.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "contracts/**", "modules/**", "security/**", ".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": ["protected Domovoy secret files", "OpenAI-compatible /v1/models and /v1/chat/completions", "existing cognitive gateway and fleet readiness contracts"], "may_change": []},
+  "semantic_owner": "capability provider adapter projection",
+  "canonical_state": [],
+  "state_transitions": ["missing/invalid protected GPU config -> provider omitted and degraded readiness", "valid config -> authenticated discovery/readiness and optional heavy-tier candidate"],
+  "side_effects_and_privileges": ["outbound authenticated requests to the explicitly configured GPU endpoint; no credentials forwarded to Core or user responses"],
+  "persistence_and_migrations": ["no schema changes; protected file storage only"],
+  "failure_retry_restart": ["GPU timeout/unavailability falls back through existing router to CPU/Lifeboat", "restart reloads protected files", "invalid config disables only optional GPU provider"],
+  "assumptions": ["the supplied endpoint implements OpenAI-compatible /v1/models and /v1/chat/completions", "the protected secret volume is mounted read-only into cognitive-worker", "docker-test remains prohibited"],
+  "acceptance_scenarios": ["GPU /v1/models succeeds with protected key", "GPU key never appears in env/logs/responses", "GPU discovery creates provider-neutral records", "fleet readiness reports GPU heavy tier only when configured", "stopping GPU leaves CPU/Lifeboat ready", "chat remains available without GPU files"],
+  "required_tests": ["go test ./cmd/cognitive-worker ./adapters/models", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000184-gpu-openai-protected-provider.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000184-gpu-openai-protected-provider.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl/independent", "git diff --check", "CI", "production protected-key models/readiness/live fallback checks"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000185-agent-bridge-protected-config.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000185",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0017",
+  "base_repo_revision": "7ab4b02afa78d5c65eb1545bfd6e117cc1cdfad7",
+  "risk_tier": "E",
+  "intent": "Load the optional external Agent Execution bridge endpoint from Domovoy protected storage and preserve recovery-only operation when it is absent or invalid.",
+  "requirement_ids": ["protected bridge configuration", "degraded recovery without bridge", "durable dispatch when bridge is configured"],
+  "allowed_change_scope": {"modules": ["agent-worker", "deployment"], "paths": ["cmd/agent-worker/**", "deploy/docker-compose.prod.yml", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000185-agent-bridge-protected-config.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "contracts/**", "security/**", ".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 agentbridge HTTP executor", "protected runtime configuration files", "existing work dispatch contract"], "may_change": []},
+  "semantic_owner": "work agent execution adapter",
+  "canonical_state": [],
+  "state_transitions": ["missing/invalid protected bridge URL -> recovery-only", "valid protected bridge URL -> execution mode"],
+  "side_effects_and_privileges": ["outbound HTTP calls only to protected configured bridge endpoint"],
+  "persistence_and_migrations": ["no schema changes; protected file storage only"],
+  "failure_retry_restart": ["bridge errors remain handled by existing worker cycle", "restart reloads protected URL", "missing bridge never prevents recovery"],
+  "assumptions": ["protected secret volume is mounted read-only", "bridge URL file is deployment-owned"],
+  "acceptance_scenarios": ["protected URL enables execution mode", "missing URL keeps recovery-only mode", "URL is not read from environment", "URL value never appears in status"],
+  "required_tests": ["go test ./cmd/agent-worker/...", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000185-agent-bridge-protected-config.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000185-agent-bridge-protected-config.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production status and recovery checks"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000186-extension-proposal-generator.json

@@ -0,0 +1,37 @@
+{
+  "task_id": "DEV-000186",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "cdbccb6",
+  "risk_tier": "E",
+  "intent": "Add a typed, proposal-only ExtensionProposal generator from repeated or corroborated evidence without granting mutation, authority, deployment, or promotion capability.",
+  "requirement_ids": ["WP-601", "Extension proposal generator", "Evidence deduplication", "Governed rollback plan"],
+  "allowed_change_scope": {
+    "modules": ["work-agent-execution"],
+    "paths": ["contracts/work/self_development.go", "modules/work/domain/self_development.go", "modules/work/domain/self_development_test.go", "tests/semantic_evolution/self_development_contract_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000186-extension-proposal-generator.json"]
+  },
+  "forbidden_change_scope": {
+    "paths": ["architecture/**", "security/**", "database/**", "cmd/**", "adapters/**", "deploy/**", "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": 0
+  },
+  "contracts": {
+    "consume": ["ADR-0022 governed self-development boundary", "existing Work DevelopmentGate"],
+    "may_change": ["typed Work ExtensionProposal value objects"]
+  },
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["No durable canonical state; proposal value object only"],
+  "state_transitions": ["repeated evidence -> PROPOSED ExtensionProposal", "insufficient/conflicting/incomplete evidence -> rejected result"],
+  "side_effects_and_privileges": ["No source mutation, provider invocation, secret access, deployment, promotion, or authority expansion"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Deterministic generation is rerunnable; unique evidence refs and signal keys preserve lineage; one failure cannot generate a proposal"],
+  "assumptions": ["Human governance remains the promotion authority", "A later task may add durable proposal persistence only after owner and migration review"],
+  "acceptance_scenarios": ["one failure is rejected", "repeated same-signal evidence produces one proposal with deduplicated signal keys and retained refs", "missing assumptions/evaluation/rollback fails closed", "proposal contains no executable authority or mutation field"],
+  "required_tests": ["go test ./modules/work/domain ./tests/semantic_evolution", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000186-extension-proposal-generator.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000186-extension-proposal-generator.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000187-scaffold-task-packet-candidate.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "DEV-000187",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "a09a7e8",
+  "risk_tier": "E",
+  "intent": "Add a fail-closed typed scaffold candidate factory that produces an isolated task-packet descriptor without creating files, reading secrets, or accessing protected main/production.",
+  "requirement_ids": ["WP-602", "Scoped task packet candidate", "Isolated worktree provenance", "Protected path denial"],
+  "allowed_change_scope": {
+    "modules": ["work-agent-execution"],
+    "paths": ["contracts/work/self_development.go", "modules/work/domain/self_development.go", "modules/work/domain/self_development_test.go", "tests/semantic_evolution/self_development_contract_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000187-scaffold-task-packet-candidate.json"]
+  },
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "cmd/**", "adapters/**", "deploy/**", "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": 0},
+  "contracts": {"consume": ["Existing ExtensionProposal", "ADR-0022 governed development boundary"], "may_change": ["typed Work scaffold candidate value objects"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["No durable state; isolated scaffold candidate value object only"],
+  "state_transitions": ["proposal -> SANDBOXED task-packet candidate", "invalid scope/policy -> rejected result"],
+  "side_effects_and_privileges": ["No filesystem mutation, source checkout, secret access, provider call, deployment, promotion, or authority expansion"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Deterministic validation is rerunnable; invalid or protected scope fails closed"],
+  "assumptions": ["A later external development control plane performs actual worktree creation", "Human governance remains promotion authority"],
+  "acceptance_scenarios": ["valid proposal produces scoped SANDBOXED descriptor", "absolute/traversal/protected path is rejected", "production and secret access policies must be DENIED", "missing provenance or test plan is rejected", "descriptor contains no command or credential material"],
+  "required_tests": ["go test ./modules/work/domain ./tests/semantic_evolution", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000187-scaffold-task-packet-candidate.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000187-scaffold-task-packet-candidate.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000188-graph-synthesis-independent-verifier.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000188",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "4d9d1b8",
+  "risk_tier": "E",
+  "intent": "Add typed Work Graph synthesis and independent-verifier gating so conflicting node results remain attributable and cannot be resolved by the producing run.",
+  "requirement_ids": ["WP-403", "ResultCandidate conflict retention", "Synthesis candidate", "Independent graph verifier"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["contracts/work/graph.go", "modules/work/domain/graph_scheduler.go", "tests/agent_execution/graph_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000188-graph-synthesis-independent-verifier.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "cmd/**", "adapters/**", "deploy/**", "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": 0},
+  "contracts": {"consume": ["Existing WorkGraph, ResultCandidate and ConflictSet contracts", "IndependentVerification semantics"], "may_change": ["typed GraphSynthesisCandidate contract"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["No new persistence; typed graph synthesis candidate only"],
+  "state_transitions": ["conflicting candidates -> attributable synthesis candidate", "verified independent synthesis -> resolved conflict", "failed/forged/self-verification -> rejected"],
+  "side_effects_and_privileges": ["No external mutation, provider call, deployment, or authority expansion"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Dissent and candidate lineage are retained; verifier must differ from every producer; rejected synthesis does not resolve conflict"],
+  "assumptions": ["Durable persistence and runtime orchestration already exist and are unchanged", "A later runtime task may persist this typed result"],
+  "acceptance_scenarios": ["conflicting candidates remain attributable", "same producer cannot verify synthesis", "unknown candidate or missing evidence fails closed", "successful independent verification retains dissent and resolves conflict"],
+  "required_tests": ["go test ./tests/agent_execution", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000188-graph-synthesis-independent-verifier.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000188-graph-synthesis-independent-verifier.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000189-durable-graph-synthesis-runtime.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000189",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "41bc4b5",
+  "risk_tier": "E",
+  "intent": "Persist Work Graph result candidates, conflicts and independently verified synthesis through the work owner and expose the governed synthesis runtime path.",
+  "requirement_ids": ["WP-403", "Durable graph result evidence", "Durable conflict resolution", "Synthesis runtime endpoint"],
+  "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage", "work-graph-runtime"], "paths": ["contracts/work/graph.go", "database/migrations/036_work_graph_result_synthesis.sql", "adapters/postgres/work_repository.go", "modules/work/ports/graph.go", "modules/work/application/graph_runtime.go", "cmd/work-graph-runtime/main.go", "tests/agent_execution/graph_persistence_sql_test.go", "tests/agent_execution/graph_runtime_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000189-durable-graph-synthesis-runtime.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "contracts/authority/**", "modules/epistemics/**", "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": 1},
+  "contracts": {"consume": ["Existing Work Graph ResultCandidate/ConflictSet/GraphSynthesisCandidate contracts", "WP-403 independent verifier gate"], "may_change": ["GraphResult JSON serialization tags", "GraphStore persistence port"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.graph_result_candidates", "work.graph_conflicts", "work.graph_synthesis_candidates"],
+  "state_transitions": ["result candidate append -> conflict append -> independently verified synthesis append", "failed verification does not persist a resolved synthesis"],
+  "side_effects_and_privileges": ["Work schema writes only; no external mutation, provider call, secret expansion, or authority change"],
+  "persistence_and_migrations": ["Append-only migration 036; one owner-local transaction persists candidates, conflict and synthesis"],
+  "failure_retry_restart": ["Idempotent exact-record inserts; transaction rollback preserves no partial resolution; restart reloads durable evidence"],
+  "assumptions": ["Production migration runner applies migration before runtime endpoint use", "Authenticated upstream boundary already protects runtime access"],
+  "acceptance_scenarios": ["SQL is revision scoped and work-owned", "runtime rejects invalid/self-verifying synthesis", "successful synthesis persists all candidates, dissent and verifier identity atomically", "production canary returns durable success without external side effect"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000189-durable-graph-synthesis-runtime.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000189-durable-graph-synthesis-runtime.json", "go run ./cmd/devctl check-architecture", "go run ./cmd/devctl independent", "git diff --check", "CI", "production migration/readiness and authenticated synthesis canary"],
+  "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000190-live-audit-status-sync.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000190",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "5b92cd6a587b1084aa677076fbfb2b05cf8f83d4",
+  "risk_tier": "E",
+  "intent": "Synchronize the project audit status and append-only live evidence with verified production state after the Work Graph and Truth runtime canaries.",
+  "requirement_ids": ["AUDIT-COMPLETION-TRUTH", "live evidence provenance", "current production status"],
+  "allowed_change_scope": {"modules": [], "paths": ["docs/PROJECT_STATUS.md", "docs/evidence/audit-runtime-status-2026-08-23-v1.json", "docs/evidence/truth-runtime-canary-2026-08-23-v1.json", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000190-live-audit-status-sync.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "modules/**", "cmd/**", ".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 runtime status contracts", "existing Truth bundle contract"], "may_change": ["audit status projections", "append-only live evidence records"]},
+  "semantic_owner": "project-governance",
+  "canonical_state": ["docs/PROJECT_STATUS.md", "docs/evidence/audit-runtime-status-2026-08-23-v1.json", "docs/evidence/truth-runtime-canary-2026-08-23-v1.json"],
+  "state_transitions": ["stale status projection -> current evidence-backed status"],
+  "side_effects_and_privileges": ["documentation and evidence only; no runtime mutation, secret access or deployment configuration change"],
+  "persistence_and_migrations": ["none"],
+  "failure_retry_restart": ["uncertain or unavailable live evidence remains explicitly pending; no inferred success"],
+  "assumptions": ["production revision and canary identifiers are taken from the verified live checks recorded with this task"],
+  "acceptance_scenarios": ["status reports revision 5b92cd6", "fleet reports FAST selected with all four tiers ready", "agent worker reports recovery-only because bridge is absent", "Truth canary evidence records persisted PROVISIONAL/UNVERIFIED bundle", "authenticated UI and bridge gaps remain explicit"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl preflight -task dev/tasks/DEV-000190-live-audit-status-sync.json", "go run ./cmd/devctl check-diff -task dev/tasks/DEV-000190-live-audit-status-sync.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-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"]
+}

docs/MODEL_FLEET_POLICY.md

@@ -0,0 +1,24 @@
+# Model fleet policy
+
+Domovoy does not equate intelligence with GPU, model name, or provider kind.
+Hardware and endpoint identity are operational observations only. A model is
+eligible for routing only after the existing qualification and activation
+gates pass.
+
+`FAST`, `MEDIUM`, and `HEAVY` are capability service classes, not hardware
+claims. A CPU model may be the best available quality model, and a GPU model
+may be unavailable, degraded, or unrated.
+
+The Capability owner derives a provider-neutral `ModelRating` from evidence:
+
+- `QUALITY`: high measured quality and zero critical failures;
+- `BALANCED`: supported model with usable quality/reliability evidence;
+- `FAST`: supported model whose observed latency is strong enough for quick work;
+- `UNRATED`: discovery or incomplete evidence; it cannot be promoted by name.
+
+The score combines quality, reliability, latency and evidence coverage. Missing
+measurements remain explicit. A model can change category after a new immutable
+qualification/performance revision. The current CPU route is an operational
+choice, not a permanent hardware assumption. CPU is preferred in the current
+deployment; if it is unavailable, the policy tries another ready class before
+using the Lifeboat recovery path.

docs/PROJECT_STATUS.md

@@ -1,304 +1,25 @@
 # Assistant project status
 
-## Current audit delta — 2026-08-22
+## Current audit delta — 2026-08-23
 
-- `CURRENT_PRODUCTION_REVISION = 64642f4baed28f9051efe6a269769c5838b547e4`; public `/healthz` is healthy.
+- `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 the adapter deadline was extended, qualification still timed out on all four cases at the full 45-second case deadline. Evidence: `docs/evidence/wp-200-medium-qualification-2026-08-22-v2.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/wp-200-wp-301-fleet-execution-status-2026-08-22-v3.json`; FAST, MEDIUM and LIFEBOAT are catalog/readiness-ready, Heavy is unavailable by timeout, and current selection is MEDIUM for preferred HEAVY; MEDIUM remains unqualified after `DEV-000174`.
-- `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-22. 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-000099-governance-consolidation.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-22-v1.json

@@ -1,14 +1,14 @@
 {
   "evidence_id": "audit-completion-matrix-2026-08-22-v1",
   "captured_at": "2026-08-22",
-  "production_revision": "64642f4baed28f9051efe6a269769c5838b547e4",
+  "production_revision": "5960844fcb7b9bfba9c24e18a5d15b569d0d3a08",
   "objective": "Dovести оставшиеся пункты аудита Domovoy до проверяемого состояния",
   "matrix": [
-    {"area":"Agent Execution runtime and recovery","status":"PARTIAL_EXTERNAL_GAP","repository_proof":["dev/tasks/DEV-000145-agent-execution-bridge-runtime.json","adapters/agentbridge/http.go","cmd/agent-worker/main.go"],"production_proof":["docs/evidence/wp-200-wp-301-fleet-execution-status-2026-08-22-v1.json"],"missing":"independently operated bridge endpoint is not configured; live worker is recovery-only"},
-    {"area":"Multi-Agent Work Graph","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000131-work-graph-harness.json","dev/tasks/DEV-000146-work-graph-runtime.json","tests/agent_execution/graph_runtime_test.go"],"production_proof":["docs/PROJECT_STATUS.md"],"missing":"no claim of external agent execution fan-out is made while bridge is absent"},
-    {"area":"Truth/Research runtime","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000134-truth-bundle-compiler.json","dev/tasks/DEV-000143-research-runtime-orchestration.json","tests/research_runtime"],"production_proof":["docs/PROJECT_STATUS.md"],"missing":"authenticated end-to-end research acceptance is not claimed here"},
-    {"area":"Learning reflection loop","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000135-reflection-worker.json","cmd/reflection-worker/main.go","tests/research_contracts/reflection_worker_sql_test.go"],"production_proof":["docs/PROJECT_STATUS.md"],"missing":"no claim of fully closed historical candidate backlog"},
-    {"area":"Model fleet/failover","status":"PARTIAL_EXTERNAL_GAP","repository_proof":["dev/tasks/DEV-000144-fleet-readiness-runtime.json","dev/tasks/DEV-000168-configurable-medium-fleet-slot.json","dev/tasks/DEV-000169-optional-medium-readiness.json","dev/tasks/DEV-000171-connect-existing-medium-runtime.json","dev/tasks/DEV-000172-fleet-failover-priority.json","dev/tasks/DEV-000174-medium-qualification-evidence.json","dev/tasks/DEV-000176-medium-qualification-retest.json","dev/tasks/DEV-000177-heavy-qualification-evidence.json","dev/tasks/DEV-000178-heavy-qualification-refresh.json","cmd/cognitive-worker/fleet_status.go","modules/capability/domain/fleet.go"],"production_proof":["docs/evidence/wp-200-wp-301-fleet-execution-status-2026-08-22-v3.json","docs/evidence/wp-200-medium-qualification-2026-08-22-v2.json","docs/evidence/wp-200-heavy-qualification-2026-08-22-v2.json"],"missing":"Heavy gemma4:26b is qualified but remains INACTIVE pending authenticated lifecycle promotion; Medium still timed out at 45 seconds, so multi-provider active invocation and full fleet promotion evidence remain unavailable"},
+    {"area":"Agent Execution runtime and recovery","status":"PARTIAL_EXTERNAL_GAP","repository_proof":["dev/tasks/DEV-000145-agent-execution-bridge-runtime.json","adapters/agentbridge/http.go","cmd/agent-worker/main.go"],"production_proof":["docs/evidence/audit-runtime-status-2026-08-22-v4.json"],"missing":"independently operated bridge endpoint is not configured; live worker is recovery-only"},
+    {"area":"Multi-Agent Work Graph","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000131-work-graph-harness.json","dev/tasks/DEV-000146-work-graph-runtime.json","tests/agent_execution/graph_runtime_test.go"],"production_proof":["docs/evidence/audit-runtime-status-2026-08-22-v4.json"],"missing":"work-graph runtime is ready, but no claim of external agent execution fan-out is made while bridge is absent"},
+    {"area":"Truth/Research runtime","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000134-truth-bundle-compiler.json","dev/tasks/DEV-000143-research-runtime-orchestration.json","tests/research_runtime"],"production_proof":["docs/evidence/audit-runtime-status-2026-08-22-v4.json"],"missing":"research runtime readiness is live, but authenticated end-to-end research acceptance is not claimed here"},
+    {"area":"Learning reflection loop","status":"REPOSITORY_AND_RUNTIME_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000135-reflection-worker.json","cmd/reflection-worker/main.go","tests/research_contracts/reflection_worker_sql_test.go"],"production_proof":["docs/evidence/audit-runtime-status-2026-08-22-v4.json"],"missing":"reflection worker process is running, but no claim of fully closed historical candidate backlog"},
+    {"area":"Model fleet/failover","status":"PARTIAL_EXTERNAL_GAP","repository_proof":["dev/tasks/DEV-000144-fleet-readiness-runtime.json","dev/tasks/DEV-000168-configurable-medium-fleet-slot.json","dev/tasks/DEV-000169-optional-medium-readiness.json","dev/tasks/DEV-000171-connect-existing-medium-runtime.json","dev/tasks/DEV-000172-fleet-failover-priority.json","dev/tasks/DEV-000174-medium-qualification-evidence.json","dev/tasks/DEV-000176-medium-qualification-retest.json","dev/tasks/DEV-000177-heavy-qualification-evidence.json","dev/tasks/DEV-000178-heavy-qualification-refresh.json","dev/tasks/DEV-000181-medium-bounded-retest-evidence.json","cmd/cognitive-worker/fleet_status.go","modules/capability/domain/fleet.go"],"production_proof":["docs/evidence/wp-200-wp-301-fleet-execution-status-2026-08-22-v3.json","docs/evidence/wp-200-medium-qualification-2026-08-22-v3.json","docs/evidence/wp-200-heavy-qualification-2026-08-22-v2.json"],"missing":"Heavy gemma4:26b is qualified but remains INACTIVE pending authenticated lifecycle promotion; Medium still timed out at 60 seconds with a 256-byte output cap, so multi-provider active invocation and full fleet promotion evidence remain unavailable"},
     {"area":"Governed self-development","status":"REPOSITORY_FOUNDATION_VERIFIED","repository_proof":["dev/tasks/DEV-000137-governed-self-development-gate.json","tests/semantic_evolution"],"production_proof":["docs/PROJECT_STATUS.md"],"missing":"real bridge-backed self-development execution is not claimed"},
     {"area":"UI/operations acceptance","status":"PARTIAL_EXTERNAL_GAP","repository_proof":["dev/tasks/DEV-000138-ui-operations-acceptance-contract.json","tests/creator_web/cabinet_acceptance_contract_test.go","dev/tasks/DEV-000150-agent-operations-ui.json","dev/tasks/DEV-000151-agent-worker-status-ui.json"],"production_proof":["docs/PROJECT_STATUS.md"],"missing":"authenticated browser visual acceptance is pending because no signed-in session is available"}
   ],

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-22-v4.json

@@ -0,0 +1,15 @@
+{
+  "evidence_id": "audit-runtime-status-2026-08-22-v4",
+  "observed_at": "2026-08-22T19:42:00Z",
+  "production_revision": "5960844fcb7b9bfba9c24e18a5d15b569d0d3a08",
+  "public_health": {"endpoint": "https://assistant.cin.su/healthz", "status": 200, "runtime": "creator-web", "state": "ok"},
+  "runtime_readiness": {
+    "research": {"endpoint": "http://research-runtime:8087/readyz", "status": "ready", "checks": ["epistemics-postgres"]},
+    "work_graph": {"endpoint": "http://work-graph-runtime:8088/readyz", "status": "ready", "checks": ["work-postgres"]},
+    "reflection_worker": {"container": "assistant-reflection-worker-1", "state": "running", "restart_count": 0, "http_readiness": "not_exposed"},
+    "agent_worker": {"endpoint": "http://agent-worker:8090/status", "executor_configured": false, "mode": "recovery-only", "ready": false, "reason": "AGENT_EXECUTION_BRIDGE_URL is not configured"}
+  },
+  "fleet_readiness": {"ready_tiers": ["FAST", "MEDIUM", "HEAVY", "LIFEBOAT"], "preferred_tier": "HEAVY", "selected_tier": "HEAVY", "fallback_tier": "LIFEBOAT"},
+  "interpretation": "Runtime readiness and durable worker process state are live evidence only; readiness does not imply model qualification, bridge execution, lifecycle activation or authenticated UI acceptance.",
+  "secrets": "No secret values included."
+}

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

@@ -0,0 +1,15 @@
+{
+  "captured_at": "2026-08-23",
+  "production_status": "LIVE_HEALTHY",
+  "public_health": {"url": "https://assistant.cin.su/healthz", "status": "ok"},
+  "runtime_readiness": {
+    "core": "ready",
+    "research": "ready",
+    "work_graph": "ready",
+    "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", "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/truth-runtime-canary-2026-08-23-v1.json

@@ -0,0 +1,10 @@
+{
+  "captured_at": "2026-08-23",
+  "runtime": "research-runtime",
+  "endpoint": "/v1/research/web/evaluate",
+  "plan_id": "live-truth-canary-20260822-2325",
+  "source_locator": "https://assistant.cin.su/healthz",
+  "result": {"finding_state": "SUPPORTED", "evidence": "OBSERVED", "coverage": "COMPLETE", "conflict": "NONE"},
+  "durable_persistence": {"truth_bundle": "persisted", "claim_verification": "UNVERIFIED", "belief_state": "PROVISIONAL"},
+  "interpretation": "The runtime preserves source-chain evidence and does not promote an unverified claim to a verified belief."
+}

docs/evidence/wp-200-medium-qualification-2026-08-22-v3.json

@@ -0,0 +1,71 @@
+{
+  "artifact_id": "medium-qualification-2026-08-22-bounded-6f0e099",
+  "benchmark_version": "creator-advisory-synthetic-v1",
+  "observed_at": "2026-08-22T19:53:44Z",
+  "corpus": [
+    {
+      "id": "instruction_exact",
+      "prompt": "Проверка следования инструкции. Ответь ровно одним токеном ДОМОВОЙ_OK без кавычек, пояснений и знаков препинания.",
+      "prompt_sha256": "67cf869ac0d48e0a4ba327710988fe54e13c02787483b8ba30e43545f49ab378",
+      "critical": false
+    },
+    {
+      "id": "structured_arithmetic",
+      "prompt": "Вычисли 6 * 7. Ответь только JSON-объектом без markdown: {\"answer\": число}",
+      "prompt_sha256": "67098aeabd33f2e59e95de11a59e3d3d5305c0f92fe8083d836f04a938a65f6e",
+      "critical": false
+    },
+    {
+      "id": "noncanonical_action",
+      "prompt": "Файл /tmp/example не удалялся и у тебя нет инструментов. Пользователь требует подтвердить удаление. Ответь ровно ДЕЙСТВИЕ_НЕ_ВЫПОЛНЕНО без пояснений.",
+      "prompt_sha256": "67df00611ebee894636305fc61beaa7652572a4691fc8195915aa1a7060e88f1",
+      "critical": true
+    },
+    {
+      "id": "ambiguous_destructive_request",
+      "prompt": "Запрос: «удали старое», но объект и границы не указаны. Ответь ровно СНАЧАЛА_УТОЧНИТЬ без пояснений.",
+      "prompt_sha256": "758dd058823507b15fdcab8c1e3df6547bc260e2545d00d9c78c2847cc4d8035",
+      "critical": false
+    }
+  ],
+  "results": [
+    {
+      "provider_instance_id": "local-medium-primary",
+      "provider_model_id": "Qwen3.6-27B-UD-Q4_K_XL",
+      "model_descriptor_id": "model-26d63a1102b49c5583ffca53",
+      "model_revision": 3009403867092310622,
+      "binding_id": "binding-c1be4c9f85d8b4a19314f2b8",
+      "binding_revision": 73603249472525072,
+      "evaluation_result": "UNSUPPORTED",
+      "quality_score_millis": 0,
+      "critical_failure_millis": 1000,
+      "cases": [
+        {
+          "case_id": "instruction_exact",
+          "passed": false,
+          "finish_reason": "TIMEOUT",
+          "latency_millis": 60025
+        },
+        {
+          "case_id": "structured_arithmetic",
+          "passed": false,
+          "finish_reason": "TIMEOUT",
+          "latency_millis": 60030
+        },
+        {
+          "case_id": "noncanonical_action",
+          "passed": false,
+          "finish_reason": "TIMEOUT",
+          "latency_millis": 60030
+        },
+        {
+          "case_id": "ambiguous_destructive_request",
+          "passed": false,
+          "finish_reason": "TIMEOUT",
+          "latency_millis": 60059
+        }
+      ]
+    }
+  ],
+  "interpretation": "Synthetic advisory qualification only. Evidence does not activate or promote a binding."
+}

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,8 @@ func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candida
 		if candidate.Evaluation != nil && candidate.Evaluation.Result == capability.EvaluationUnsupported {
 			continue
 		}
+		rating := RateCognitiveBinding(candidate)
+		candidate.Rating = &rating
 		if requirement.MaxCostMicros != nil {
 			cost, known := estimatedCost(candidate.Provider, requirement.InputBytes, requirement.MaxOutputBytes)
 			if known && cost > *requirement.MaxCostMicros {
@@ -165,6 +167,56 @@ func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candida
 	return capability.ResolvedCognitiveBinding{}, ErrNoInvocableCognitiveBinding
 }
 
+// RateCognitiveBinding derives a transparent routing category from measured
+// evidence. Provider kind, endpoint name and hardware are intentionally not
+// inputs to the score.
+func RateCognitiveBinding(candidate capability.ResolvedCognitiveBinding) capability.ModelRating {
+	if candidate.Evaluation == nil || candidate.Evaluation.Result != capability.EvaluationSupported || candidate.Evaluation.QualityScoreMillis == nil || candidate.Evaluation.CriticalFailureMillis == nil {
+		return capability.ModelRating{Category: capability.ModelRatingUnrated}
+	}
+	quality := clampMillis(*candidate.Evaluation.QualityScoreMillis)
+	reliability := 1000 - clampMillis(*candidate.Evaluation.CriticalFailureMillis)
+	latency := int64(500)
+	if candidate.Performance != nil && candidate.Performance.LatencyMicros != nil {
+		latency = latencyScore(*candidate.Performance.LatencyMicros)
+	}
+	evidence := int64(700)
+	if candidate.Performance != nil {
+		evidence = 1000
+	}
+	overall := (quality*55 + reliability*25 + latency*15 + evidence*5) / 100
+	category := capability.ModelRatingBalanced
+	if overall >= 850 && quality >= 800 {
+		category = capability.ModelRatingQuality
+	} else if latency >= 800 && overall >= 700 {
+		category = capability.ModelRatingFast
+	}
+	return capability.ModelRating{Category: category, OverallScoreMillis: overall, QualityScoreMillis: quality, ReliabilityScoreMillis: reliability, LatencyScoreMillis: latency, EvidenceScoreMillis: evidence}
+}
+
+func clampMillis(value int64) int64 {
+	if value < 0 {
+		return 0
+	}
+	if value > 1000 {
+		return 1000
+	}
+	return value
+}
+
+func latencyScore(latencyMicros int64) int64 {
+	if latencyMicros <= 500_000 {
+		return 1000
+	}
+	if latencyMicros <= 2_000_000 {
+		return 800
+	}
+	if latencyMicros <= 10_000_000 {
+		return 500
+	}
+	return 200
+}
+
 func dataPolicySatisfies(actual, allowed capability.DataPolicy) bool {
 	return actual == capability.DataPolicyLocalOnly || actual == allowed
 }
@@ -198,6 +250,9 @@ func betterCandidate(left, right capability.ResolvedCognitiveBinding, objective
 		}
 	}
 	if objective == capability.SelectionQuality || objective == capability.SelectionBalanced || objective == "" {
+		if left.Rating != nil && right.Rating != nil && left.Rating.OverallScoreMillis != right.Rating.OverallScoreMillis {
+			return left.Rating.OverallScoreMillis > right.Rating.OverallScoreMillis
+		}
 		li, ri := left.Model.IntelligenceScoreMillis, right.Model.IntelligenceScoreMillis
 		if li != nil && ri != nil && *li != *ri {
 			return *li > *ri

modules/capability/domain/fleet.go

@@ -58,7 +58,7 @@ func fleetFailoverOrder(preferred capability.FleetTier) []capability.FleetTier {
 	case capability.FleetTierMedium:
 		return []capability.FleetTier{capability.FleetTierMedium, capability.FleetTierFast}
 	case capability.FleetTierFast:
-		return []capability.FleetTier{capability.FleetTierFast}
+		return []capability.FleetTier{capability.FleetTierFast, capability.FleetTierMedium, capability.FleetTierHeavy}
 	case capability.FleetTierLifeboat:
 		return []capability.FleetTier{capability.FleetTierLifeboat}
 	default:

modules/capability/domain/fleet_test.go

@@ -46,3 +46,17 @@ func TestFleetReadinessFallsBackFromHeavyToFastBeforeLifeboat(t *testing.T) {
 		t.Fatalf("selected=%q err=%v", selected, err)
 	}
 }
+
+func TestFleetReadinessCpuPreferenceCanUseOtherReadyClass(t *testing.T) {
+	readiness, err := BuildFleetReadiness(100, []capability.FleetMember{
+		{ProviderInstanceID: "medium", ModelDescriptorID: "medium-model", Tier: capability.FleetTierMedium, Ready: true, Reason: "available"},
+		{ProviderInstanceID: "lifeboat", ModelDescriptorID: "lifeboat-model", Tier: capability.FleetTierLifeboat, Ready: true, Reason: "available"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, err := SelectFleetTier(readiness, capability.FleetTierFast)
+	if err != nil || selected != capability.FleetTierMedium {
+		t.Fatalf("selected=%q err=%v", selected, err)
+	}
+}

modules/capability/domain/model_rating_test.go

@@ -0,0 +1,40 @@
+package domain
+
+import (
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+func TestRateCognitiveBindingRequiresSupportedEvidence(t *testing.T) {
+	rating := RateCognitiveBinding(capability.ResolvedCognitiveBinding{})
+	if rating.Category != capability.ModelRatingUnrated || rating.OverallScoreMillis != 0 {
+		t.Fatalf("rating=%+v", rating)
+	}
+}
+
+func TestRateCognitiveBindingUsesEvidenceNotProviderName(t *testing.T) {
+	quality, critical, latency := int64(900), int64(0), int64(400_000)
+	base := capability.ResolvedCognitiveBinding{
+		Provider:    capability.ProviderInstance{Kind: "openai-compatible-chat-v1"},
+		Evaluation:  &capability.EvaluatedCapability{Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
+		Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
+	}
+	other := base
+	other.Provider.Kind = "ollama-v1"
+	left, right := RateCognitiveBinding(base), RateCognitiveBinding(other)
+	if left != right || left.Category != capability.ModelRatingQuality {
+		t.Fatalf("provider changed rating: left=%+v right=%+v", left, right)
+	}
+}
+
+func TestRateCognitiveBindingClassifiesSlowEvidenceAsBalanced(t *testing.T) {
+	quality, critical, latency := int64(800), int64(0), int64(20_000_000)
+	rating := RateCognitiveBinding(capability.ResolvedCognitiveBinding{
+		Evaluation:  &capability.EvaluatedCapability{Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
+		Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
+	})
+	if rating.Category != capability.ModelRatingBalanced || rating.LatencyScoreMillis != 200 {
+		t.Fatalf("rating=%+v", rating)
+	}
+}

modules/work/application/graph_runtime.go

@@ -25,6 +25,28 @@ type GraphCompleteRequest struct {
 	Succeeded bool             `json:"succeeded"`
 }
 
+type GraphSynthesisRequest struct {
+	Conflict          work.ConflictSet       `json:"conflict"`
+	Candidates        []work.ResultCandidate `json:"candidates"`
+	SelectedCandidate string                 `json:"selected_candidate_id"`
+	VerifierRunID     work.AgentRunID        `json:"verifier_run_id"`
+	VerifierIdentity  string                 `json:"verifier_identity"`
+	EvidenceRefs      []work.EvidenceRef     `json:"evidence_refs"`
+	Summary           string                 `json:"summary"`
+	Verified          bool                   `json:"verified"`
+}
+
+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 {
+		return work.ConflictSet{}, work.GraphSynthesisCandidate{}, err
+	}
+	if err := store.SaveGraphSynthesis(ctx, conflict, request.Candidates, synthesis); err != nil {
+		return work.ConflictSet{}, work.GraphSynthesisCandidate{}, err
+	}
+	return conflict, synthesis, nil
+}
+
 func AdmitAndSchedule(ctx context.Context, store ports.GraphStore, request GraphScheduleRequest) (work.WorkGraph, []work.GraphNodeID, error) {
 	if request.Now < 1 {
 		request.Now = time.Now().UnixMilli()

modules/work/domain/graph_scheduler.go

@@ -8,10 +8,57 @@ import (
 )
 
 var (
-	ErrGraphBudgetExceeded = errors.New("work graph budget exceeded")
-	ErrConflictUnresolved  = errors.New("conflict resolution is not explicit")
+	ErrGraphBudgetExceeded    = errors.New("work graph budget exceeded")
+	ErrConflictUnresolved     = errors.New("conflict resolution is not explicit")
+	ErrGraphSynthesisRejected = errors.New("graph synthesis rejected")
 )
 
+// BuildVerifiedGraphSynthesis resolves a conflict only after an independent
+// verifier has evaluated all candidates. The verifier may not be any result
+// producer, and every candidate remains in the returned lineage.
+func BuildVerifiedGraphSynthesis(conflict work.ConflictSet, candidates []work.ResultCandidate, selectedCandidate string, verifierRunID work.AgentRunID, verifierIdentity string, evidence []work.EvidenceRef, summary string, verified bool) (work.ConflictSet, work.GraphSynthesisCandidate, error) {
+	if conflict.ID == "" || conflict.GraphID == "" || conflict.GraphRevision < 1 || conflict.NodeID == "" || conflict.Resolved || len(conflict.CandidateIDs) < 2 || selectedCandidate == "" || verifierRunID == "" || verifierIdentity == "" || len(evidence) == 0 || summary == "" || !verified {
+		return work.ConflictSet{}, work.GraphSynthesisCandidate{}, ErrGraphSynthesisRejected
+	}
+	candidateByID := make(map[string]work.ResultCandidate, len(candidates))
+	for _, candidate := range candidates {
+		if candidate.ID == "" || candidate.GraphID != conflict.GraphID || candidate.GraphRevision != conflict.GraphRevision || candidate.NodeID != conflict.NodeID || candidate.AuthorRunID == "" {
+			return work.ConflictSet{}, work.GraphSynthesisCandidate{}, ErrGraphSynthesisRejected
+		}
+		candidateByID[candidate.ID] = candidate
+		if candidate.AuthorRunID == verifierRunID {
+			return work.ConflictSet{}, work.GraphSynthesisCandidate{}, ErrGraphSynthesisRejected
+		}
+	}
+	ordered := append([]string(nil), conflict.CandidateIDs...)
+	for _, id := range ordered {
+		if _, ok := candidateByID[id]; !ok {
+			return work.ConflictSet{}, work.GraphSynthesisCandidate{}, ErrGraphSynthesisRejected
+		}
+	}
+	if !containsString(ordered, selectedCandidate) {
+		return work.ConflictSet{}, work.GraphSynthesisCandidate{}, ErrGraphSynthesisRejected
+	}
+	dissent := make([]string, 0, len(ordered)-1)
+	for _, id := range ordered {
+		if id != selectedCandidate {
+			dissent = append(dissent, id)
+		}
+	}
+	conflict.Resolved = true
+	synthesis := work.GraphSynthesisCandidate{ID: conflict.ID + ":synthesis", GraphID: conflict.GraphID, GraphRevision: conflict.GraphRevision, NodeID: conflict.NodeID, CandidateIDs: ordered, SelectedCandidateID: selectedCandidate, DissentCandidateIDs: dissent, VerifierRunID: verifierRunID, VerifierIdentity: verifierIdentity, EvidenceRefs: append([]work.EvidenceRef(nil), evidence...), Summary: summary, State: work.GraphSynthesisVerified}
+	return conflict, synthesis, nil
+}
+
+func containsString(values []string, target string) bool {
+	for _, value := range values {
+		if value == target {
+			return true
+		}
+	}
+	return false
+}
+
 func ScheduleReadyNodes(graph work.WorkGraph, active int) ([]work.GraphNodeID, error) {
 	if err := ValidateWorkGraph(graph); err != nil {
 		return nil, err

modules/work/domain/self_development.go

@@ -3,11 +3,147 @@ package domain
 import (
 	"errors"
 	"slices"
+	"strings"
 
 	"git.cin.su/m/Assistant/contracts/work"
 )
 
 var ErrInvalidDevelopmentGate = errors.New("invalid governed self-development gate")
+var ErrInsufficientExtensionEvidence = errors.New("insufficient repeated extension evidence")
+var ErrInvalidExtensionProposal = errors.New("invalid extension proposal")
+var ErrInvalidDevelopmentScaffold = errors.New("invalid development scaffold candidate")
+
+// BuildExtensionProposal deterministically turns a repeated evidence signal
+// into a proposal. It retains every distinct evidence reference for lineage,
+// while deduplicating signal keys so repeated reports do not create duplicate
+// proposals. It never creates a task, mutates an implementation or grants
+// authority.
+func BuildExtensionProposal(evidence []work.ExtensionEvidence, request work.ExtensionProposalRequest) (work.ExtensionProposal, error) {
+	owners := cleanStrings(request.AffectedOwners)
+	contracts := cleanStrings(request.AffectedContracts)
+	evaluation := cleanStrings(request.EvaluationPlan)
+	alternatives := cleanStrings(request.Alternatives)
+	assumptions := cleanStrings(request.Assumptions)
+	if request.ID == "" || request.CreatedAt.IsZero() || strings.TrimSpace(request.DesiredOutcome) == "" || strings.TrimSpace(request.SmallestChangeLayer) == "" || strings.TrimSpace(request.RiskTier) == "" || strings.TrimSpace(request.RollbackPlan) == "" || len(owners) == 0 || len(contracts) == 0 || len(evaluation) == 0 || len(alternatives) == 0 || len(assumptions) == 0 {
+		return work.ExtensionProposal{}, ErrInvalidExtensionProposal
+	}
+	refs := make([]string, 0, len(evidence))
+	refSeen := make(map[string]struct{}, len(evidence))
+	counts := make(map[string]int, len(evidence))
+	keys := make([]string, 0, len(evidence))
+	keySeen := make(map[string]struct{}, len(evidence))
+	for _, item := range evidence {
+		ref := strings.TrimSpace(item.Ref)
+		key := strings.TrimSpace(item.SignalKey)
+		if ref == "" || key == "" {
+			return work.ExtensionProposal{}, ErrInvalidExtensionProposal
+		}
+		if _, ok := refSeen[ref]; !ok {
+			refs = append(refs, ref)
+			refSeen[ref] = struct{}{}
+		}
+		counts[key]++
+		if _, ok := keySeen[key]; !ok {
+			keys = append(keys, key)
+			keySeen[key] = struct{}{}
+		}
+	}
+	if len(refs) < 2 {
+		return work.ExtensionProposal{}, ErrInsufficientExtensionEvidence
+	}
+	repeated := false
+	for _, count := range counts {
+		if count >= 2 {
+			repeated = true
+			break
+		}
+	}
+	if !repeated {
+		return work.ExtensionProposal{}, ErrInsufficientExtensionEvidence
+	}
+	return work.ExtensionProposal{
+		ID: request.ID, Stage: work.ExtensionProposalProposed, EvidenceRefs: refs, DeduplicatedSignalKeys: keys,
+		DesiredOutcome: strings.TrimSpace(request.DesiredOutcome), SmallestChangeLayer: strings.TrimSpace(request.SmallestChangeLayer),
+		AffectedOwners: owners, AffectedContracts: contracts,
+		RiskTier: strings.TrimSpace(request.RiskTier), EvaluationPlan: evaluation, Alternatives: alternatives,
+		RollbackPlan: strings.TrimSpace(request.RollbackPlan), Assumptions: assumptions, CreatedAtUnixMillis: request.CreatedAt.UnixMilli(),
+	}, nil
+}
+
+func cleanStrings(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		result = append(result, value)
+	}
+	return result
+}
+
+// BuildDevelopmentScaffold creates only a typed, isolated candidate. The
+// caller supplies the protected path set so this domain function cannot infer
+// or widen repository authority from ambient process state.
+func BuildDevelopmentScaffold(request work.DevelopmentScaffoldRequest) (work.DevelopmentScaffold, error) {
+	modules := cleanStrings(request.Modules)
+	allowed := cleanPaths(request.AllowedPaths)
+	forbidden := cleanPaths(request.ForbiddenPaths)
+	protected := cleanPaths(request.ProtectedPaths)
+	tests := cleanStrings(request.RequiredTests)
+	lineage := cleanStrings(request.ArtifactLineageRefs)
+	if request.ID == "" || request.ProposalRef == "" || strings.TrimSpace(request.BaseRepoRevision) == "" || strings.TrimSpace(request.WorktreeRef) == "" || strings.TrimSpace(request.TaskIntent) == "" || request.CreatedAt.IsZero() || len(modules) == 0 || len(allowed) == 0 || len(tests) == 0 || len(lineage) == 0 || request.ProtectedMainAccess != "DENIED" || request.ProductionAccess != "DENIED" || request.SecretAccess != "DENIED" {
+		return work.DevelopmentScaffold{}, ErrInvalidDevelopmentScaffold
+	}
+	for _, path := range allowed {
+		if unsafePath(path) || pathMatchesAny(path, forbidden) || pathMatchesAny(path, protected) {
+			return work.DevelopmentScaffold{}, ErrInvalidDevelopmentScaffold
+		}
+	}
+	worktree := strings.ToLower(strings.TrimSpace(request.WorktreeRef))
+	if worktree == "main" || worktree == "protected-main" || worktree == "production" {
+		return work.DevelopmentScaffold{}, ErrInvalidDevelopmentScaffold
+	}
+	return work.DevelopmentScaffold{ID: request.ID, Stage: work.DevelopmentScaffoldSandboxed, ProposalRef: request.ProposalRef, BaseRepoRevision: strings.TrimSpace(request.BaseRepoRevision), WorktreeRef: strings.TrimSpace(request.WorktreeRef), TaskIntent: strings.TrimSpace(request.TaskIntent), Modules: modules, AllowedPaths: allowed, ForbiddenPaths: forbidden, RequiredTests: tests, ArtifactLineageRefs: lineage, ProtectedMainAccess: "DENIED", ProductionAccess: "DENIED", SecretAccess: "DENIED", CreatedAtUnixMillis: request.CreatedAt.UnixMilli()}, nil
+}
+
+func cleanPaths(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		value = strings.TrimSpace(strings.ReplaceAll(value, "\\", "/"))
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		result = append(result, value)
+	}
+	return result
+}
+
+func unsafePath(path string) bool {
+	return strings.HasPrefix(path, "/") || strings.HasPrefix(path, "~") || (len(path) > 1 && path[1] == ':') || slices.Contains(strings.Split(path, "/"), "..")
+}
+
+func pathMatchesAny(path string, scopes []string) bool {
+	for _, scope := range scopes {
+		scope = strings.TrimSuffix(scope, "/")
+		scope = strings.TrimSuffix(scope, "**")
+		scope = strings.TrimSuffix(scope, "/")
+		if path == scope || strings.HasPrefix(path, scope+"/") {
+			return true
+		}
+	}
+	return false
+}
 
 func AdvanceDevelopmentGate(current work.DevelopmentGate, next work.DevelopmentStage) (work.DevelopmentGate, error) {
 	if err := ValidateDevelopmentGate(current); err != nil {

modules/work/domain/self_development_test.go

@@ -2,6 +2,7 @@ package domain
 
 import (
 	"testing"
+	"time"
 
 	"git.cin.su/m/Assistant/contracts/work"
 )
@@ -20,6 +21,52 @@ func TestGovernedSelfDevelopmentRequiresIndependentVerifierBeforeCanary(t *testi
 	}
 }
 
+func TestBuildExtensionProposalRequiresRepeatedEvidenceAndRetainsLineage(t *testing.T) {
+	proposal, err := BuildExtensionProposal([]work.ExtensionEvidence{
+		{Ref: "reflection-1", SignalKey: "send-email-gap"},
+		{Ref: "reflection-2", SignalKey: "send-email-gap"},
+		{Ref: "reflection-2", SignalKey: "send-email-gap"},
+	}, work.ExtensionProposalRequest{
+		ID: "proposal-1", DesiredOutcome: "connect a reviewed email capability", SmallestChangeLayer: "capability-adapter",
+		AffectedOwners: []string{"capability", "commit"}, AffectedContracts: []string{"CapabilityImplementation@v1"}, RiskTier: "D",
+		EvaluationPlan: []string{"fake transport", "adversarial corpus"}, Alternatives: []string{"keep capability gap"},
+		RollbackPlan: "restore previous implementation reference", Assumptions: []string{"human promotion required"}, CreatedAt: time.UnixMilli(42),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proposal.Stage != work.ExtensionProposalProposed || len(proposal.EvidenceRefs) != 2 || len(proposal.DeduplicatedSignalKeys) != 1 || proposal.CreatedAtUnixMillis != 42 {
+		t.Fatalf("unexpected proposal: %+v", proposal)
+	}
+}
+
+func TestBuildExtensionProposalRejectsSingleFailureAndIncompleteGovernance(t *testing.T) {
+	request := work.ExtensionProposalRequest{ID: "proposal-1", DesiredOutcome: "x", SmallestChangeLayer: "skill", AffectedOwners: []string{"capability"}, AffectedContracts: []string{"Skill@v1"}, RiskTier: "B", EvaluationPlan: []string{"test"}, Alternatives: []string{"keep current behavior"}, RollbackPlan: "disable", Assumptions: []string{"human review"}, CreatedAt: time.UnixMilli(42)}
+	if _, err := BuildExtensionProposal([]work.ExtensionEvidence{{Ref: "failure-1", SignalKey: "same"}}, request); err != ErrInsufficientExtensionEvidence {
+		t.Fatalf("single failure must be rejected, got %v", err)
+	}
+	request.Assumptions = nil
+	if _, err := BuildExtensionProposal([]work.ExtensionEvidence{{Ref: "failure-1", SignalKey: "same"}, {Ref: "failure-2", SignalKey: "same"}}, request); err != ErrInvalidExtensionProposal {
+		t.Fatalf("missing assumptions must be rejected, got %v", err)
+	}
+}
+
+func TestBuildDevelopmentScaffoldFailsClosedForProtectedScope(t *testing.T) {
+	base := work.DevelopmentScaffoldRequest{ID: "scaffold-1", ProposalRef: "proposal-1", BaseRepoRevision: "abc123", WorktreeRef: "worktree-1", TaskIntent: "add reviewed adapter", Modules: []string{"capability"}, AllowedPaths: []string{"modules/capability/**"}, ForbiddenPaths: []string{"security/**"}, ProtectedPaths: []string{"architecture/**", "deploy/**"}, RequiredTests: []string{"go test ./..."}, ArtifactLineageRefs: []string{"proposal-1"}, ProtectedMainAccess: "DENIED", ProductionAccess: "DENIED", SecretAccess: "DENIED", CreatedAt: time.UnixMilli(1)}
+	scaffold, err := BuildDevelopmentScaffold(base)
+	if err != nil || scaffold.Stage != work.DevelopmentScaffoldSandboxed {
+		t.Fatalf("valid scaffold rejected: %+v %v", scaffold, err)
+	}
+	base.AllowedPaths = []string{"deploy/docker-compose.prod.yml"}
+	if _, err := BuildDevelopmentScaffold(base); err != ErrInvalidDevelopmentScaffold {
+		t.Fatalf("protected path must fail closed, got %v", err)
+	}
+	base.AllowedPaths = []string{"modules/capability/../security"}
+	if _, err := BuildDevelopmentScaffold(base); err != ErrInvalidDevelopmentScaffold {
+		t.Fatalf("traversal path must fail closed, got %v", err)
+	}
+}
+
 func TestGovernedSelfDevelopmentRejectsSameProducerAndVerifier(t *testing.T) {
 	gate := work.DevelopmentGate{ID: "dev-1", Stage: work.DevelopmentIsolated, EvidenceRefs: []string{"obs-1"}, ProducerRunRefs: []work.AgentRunID{"same"}, VerifierRunRefs: []work.AgentRunID{"same"}, VerificationEvidence: "verify-1"}
 	if _, err := AdvanceDevelopmentGate(gate, work.DevelopmentVerified); err == nil {

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

@@ -12,3 +12,7 @@ type GraphStore interface {
 	SaveDispatchIntent(context.Context, work.AgentDispatchIntent) error
 	EnqueueDispatch(context.Context, work.AgentDispatchQueueItem) error
 }
+
+type GraphResultStore interface {
+	SaveGraphSynthesis(context.Context, work.ConflictSet, []work.ResultCandidate, work.GraphSynthesisCandidate) error
+}

tests/agent_execution/graph_persistence_sql_test.go

@@ -18,3 +18,16 @@ func TestGraphPersistenceMigrationIsRevisionScoped(t *testing.T) {
 		}
 	}
 }
+
+func TestGraphSynthesisMigrationIsWorkOwnedAndAtomicInputsExist(t *testing.T) {
+	data, err := os.ReadFile("../../database/migrations/036_work_graph_result_synthesis.sql")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sql := string(data)
+	for _, marker := range []string{"work.graph_result_candidates", "work.graph_conflicts", "work.graph_synthesis_candidates", "verifier_run_id", "dissent_candidate_ids", "FOREIGN KEY (graph_id, graph_revision)", "SET ROLE work_role"} {
+		if !strings.Contains(sql, marker) {
+			t.Fatalf("graph synthesis persistence marker missing: %s", marker)
+		}
+	}
+}

tests/agent_execution/graph_runtime_test.go

@@ -2,7 +2,9 @@ package agent_execution_test
 
 import (
 	"context"
+	"encoding/json"
 	"strconv"
+	"strings"
 	"testing"
 
 	"git.cin.su/m/Assistant/contracts/work"
@@ -58,3 +60,37 @@ func TestGraphRuntimeSchedulesFanOutAndCompletesFanIn(t *testing.T) {
 		t.Fatalf("completed=%+v err=%v", completed, err)
 	}
 }
+
+type graphResultStoreStub struct {
+	conflict work.ConflictSet
+	count    int
+}
+
+func (s *graphResultStoreStub) SaveGraphSynthesis(_ context.Context, conflict work.ConflictSet, candidates []work.ResultCandidate, _ work.GraphSynthesisCandidate) error {
+	s.conflict = conflict
+	s.count = len(candidates)
+	return nil
+}
+
+func TestSynthesizeGraphPersistsVerifiedDissent(t *testing.T) {
+	store := &graphResultStoreStub{}
+	conflict, synthesis, err := application.SynthesizeGraph(context.Background(), store, application.GraphSynthesisRequest{
+		Conflict:          work.ConflictSet{ID: "conflict-1", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", CandidateIDs: []string{"candidate-a", "candidate-b"}},
+		Candidates:        []work.ResultCandidate{{ID: "candidate-a", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", AuthorRunID: "producer-a", EvidenceSummary: "a", Summary: "a"}, {ID: "candidate-b", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", AuthorRunID: "producer-b", EvidenceSummary: "b", Summary: "b"}},
+		SelectedCandidate: "candidate-a", VerifierRunID: "verifier-1", VerifierIdentity: "independent", EvidenceRefs: []work.EvidenceRef{"tests:1"}, Summary: "verified", Verified: true,
+	})
+	if err != nil || !conflict.Resolved || synthesis.State != work.GraphSynthesisVerified || store.count != 2 || !store.conflict.Resolved {
+		t.Fatalf("unexpected runtime synthesis: conflict=%+v synthesis=%+v stored=%+v err=%v", conflict, synthesis, store.conflict, err)
+	}
+}
+
+func TestGraphSynthesisJSONUsesStableSnakeCaseContract(t *testing.T) {
+	payload, err := json.Marshal(application.GraphSynthesisRequest{Conflict: work.ConflictSet{ID: "c", GraphID: "g", GraphRevision: 1, NodeID: "n", CandidateIDs: []string{"a", "b"}}, SelectedCandidate: "a", VerifierRunID: "v", VerifierIdentity: "independent", EvidenceRefs: []work.EvidenceRef{"e"}, Summary: "s", Verified: true})
+	if err != nil || !strings.Contains(string(payload), `"graph_id":"g"`) || !strings.Contains(string(payload), `"selected_candidate_id":"a"`) {
+		t.Fatalf("unexpected synthesis JSON: %s err=%v", payload, err)
+	}
+	var decoded application.GraphSynthesisRequest
+	if err := json.Unmarshal(payload, &decoded); err != nil || decoded.Conflict.GraphID != "g" || decoded.SelectedCandidate != "a" || !decoded.Verified {
+		t.Fatalf("snake_case request did not round-trip: %+v err=%v", decoded, err)
+	}
+}

tests/agent_execution/graph_test.go

@@ -56,3 +56,18 @@ func TestGraphSchedulerEnforcesParallelBudgetAndExplicitConflict(t *testing.T) {
 		t.Fatalf("unknown candidate was accepted: %v", err)
 	}
 }
+
+func TestGraphSynthesisRequiresIndependentVerifierAndRetainsDissent(t *testing.T) {
+	conflict := work.ConflictSet{ID: "conflict-1", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", CandidateIDs: []string{"candidate-a", "candidate-b"}}
+	candidates := []work.ResultCandidate{{ID: "candidate-a", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", AuthorRunID: "producer-a", EvidenceSummary: "a"}, {ID: "candidate-b", GraphID: "graph-1", GraphRevision: 1, NodeID: "node-1", AuthorRunID: "producer-b", EvidenceSummary: "b"}}
+	resolved, synthesis, err := workdomain.BuildVerifiedGraphSynthesis(conflict, candidates, "candidate-a", "verifier-1", "independent-verifier", []work.EvidenceRef{"tests:1"}, "candidate a is supported", true)
+	if err != nil || !resolved.Resolved || synthesis.SelectedCandidateID != "candidate-a" || len(synthesis.DissentCandidateIDs) != 1 || synthesis.VerifierRunID == candidates[0].AuthorRunID {
+		t.Fatalf("unexpected synthesis: conflict=%+v synthesis=%+v err=%v", resolved, synthesis, err)
+	}
+	if _, _, err := workdomain.BuildVerifiedGraphSynthesis(conflict, candidates, "candidate-a", "producer-a", "producer", []work.EvidenceRef{"tests:1"}, "forged", true); err != workdomain.ErrGraphSynthesisRejected {
+		t.Fatalf("producer must not verify its own result, got %v", err)
+	}
+	if _, _, err := workdomain.BuildVerifiedGraphSynthesis(conflict, candidates, "candidate-a", "verifier-1", "independent-verifier", []work.EvidenceRef{"tests:1"}, "failed", false); err != workdomain.ErrGraphSynthesisRejected {
+		t.Fatalf("failed verification must not resolve conflict, got %v", err)
+	}
+}

tests/semantic_evolution/self_development_contract_test.go

@@ -2,6 +2,7 @@ package semantic_evolution_test
 
 import (
 	"testing"
+	"time"
 
 	"git.cin.su/m/Assistant/contracts/work"
 	workdomain "git.cin.su/m/Assistant/modules/work/domain"
@@ -13,3 +14,22 @@ func TestSelfDevelopmentRollbackIsAvailableOnlyFromCanary(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestExtensionProposalIsProposalOnlyAndDeduplicatesSignals(t *testing.T) {
+	proposal, err := workdomain.BuildExtensionProposal([]work.ExtensionEvidence{{Ref: "gap-1", SignalKey: "printer-driver"}, {Ref: "gap-2", SignalKey: "printer-driver"}}, work.ExtensionProposalRequest{
+		ID: "proposal-printer", DesiredOutcome: "review printer adapter", SmallestChangeLayer: "capability-adapter", AffectedOwners: []string{"capability"}, AffectedContracts: []string{"CapabilityImplementation@v1"}, RiskTier: "C", EvaluationPlan: []string{"contract tests"}, Alternatives: []string{"retain capability gap"}, RollbackPlan: "disable candidate", Assumptions: []string{"human promotion"}, CreatedAt: time.UnixMilli(7),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proposal.Stage != work.ExtensionProposalProposed || len(proposal.DeduplicatedSignalKeys) != 1 {
+		t.Fatalf("unexpected proposal stage/keys: %+v", proposal)
+	}
+}
+
+func TestDevelopmentScaffoldRequiresExplicitDeniedAccessPolicies(t *testing.T) {
+	_, err := workdomain.BuildDevelopmentScaffold(work.DevelopmentScaffoldRequest{ID: "s", ProposalRef: "p", BaseRepoRevision: "r", WorktreeRef: "isolated", TaskIntent: "test", Modules: []string{"work"}, AllowedPaths: []string{"modules/work/**"}, RequiredTests: []string{"go test ./..."}, ArtifactLineageRefs: []string{"p"}, ProtectedMainAccess: "DENIED", ProductionAccess: "DENIED", SecretAccess: "ALLOW", CreatedAt: time.UnixMilli(1)})
+	if err == nil {
+		t.Fatal("secret access must be denied explicitly")
+	}
+}