docs: record fleet and execution status evidence

Reviewed-on: #109

.gitea/workflows/ci.yml

@@ -15,6 +15,8 @@ jobs:
           go-version: '1.26.6'
       - name: Active task preflight
         run: go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json
+      - name: Independent governance verifier
+        run: go run ./cmd/devctl/independent
       - name: Exact diff scope
         run: go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json
       - name: Format check
@@ -25,3 +27,5 @@ jobs:
         run: go test ./...
       - name: Vet
         run: go vet ./...
+      - name: Diff whitespace check
+        run: git diff --check

adapters/agentbridge/http.go

@@ -0,0 +1,61 @@
+package agentbridge
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+var ErrUnavailable = errors.New("agent execution bridge unavailable")
+
+type HTTPExecutor struct {
+	URL    string
+	Client *http.Client
+}
+
+func NewHTTPExecutor(url string, client *http.Client) (*HTTPExecutor, error) {
+	url = strings.TrimSpace(url)
+	if url == "" || !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
+		return nil, ErrUnavailable
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return &HTTPExecutor{URL: strings.TrimRight(url, "/"), Client: client}, nil
+}
+
+func (e *HTTPExecutor) Execute(ctx context.Context, request work.AgentExecutionRequest) (work.AgentExecutionResult, error) {
+	body, err := json.Marshal(request)
+	if err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	httpRequest, err := http.NewRequestWithContext(ctx, http.MethodPost, e.URL+"/v1/execute", bytes.NewReader(body))
+	if err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	httpRequest.Header.Set("Content-Type", "application/json")
+	response, err := e.Client.Do(httpRequest)
+	if err != nil {
+		return work.AgentExecutionResult{}, fmt.Errorf("%w: %v", ErrUnavailable, err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return work.AgentExecutionResult{}, fmt.Errorf("%w: status=%s", ErrUnavailable, response.Status)
+	}
+	decoder := json.NewDecoder(io.LimitReader(response.Body, 1<<20))
+	var result work.AgentExecutionResult
+	if err := decoder.Decode(&result); err != nil {
+		return work.AgentExecutionResult{}, err
+	}
+	if result.State == "" || result.Summary == "" || result.ObservedAtUnixMillis < 1 {
+		return work.AgentExecutionResult{}, errors.New("agent execution bridge returned invalid result")
+	}
+	return result, nil
+}

adapters/agentbridge/http_test.go

@@ -0,0 +1,43 @@
+package agentbridge
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+func TestHTTPExecutorCarriesTypedDispatchAndDecodesResult(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost || r.URL.Path != "/v1/execute" {
+			t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
+		}
+		var request work.AgentExecutionRequest
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			t.Fatal(err)
+		}
+		if request.WorkerID != "worker-1" || request.FencingToken != 7 || request.Intent.DispatchID != "dispatch-1" {
+			t.Fatalf("request=%+v", request)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(work.AgentExecutionResult{State: work.AgentExecutionCompleted, Summary: "completed", ObservedAtUnixMillis: 2})
+	}))
+	defer server.Close()
+	executor, err := NewHTTPExecutor(server.URL, server.Client())
+	if err != nil {
+		t.Fatal(err)
+	}
+	result, err := executor.Execute(context.Background(), work.AgentExecutionRequest{Intent: work.AgentDispatchIntent{DispatchID: "dispatch-1"}, WorkerID: "worker-1", FencingToken: 7})
+	if err != nil || result.State != work.AgentExecutionCompleted || result.Summary != "completed" {
+		t.Fatalf("result=%+v err=%v", result, err)
+	}
+}
+
+func TestHTTPExecutorRejectsUnavailableEndpoint(t *testing.T) {
+	if _, err := NewHTTPExecutor("", nil); err != ErrUnavailable {
+		t.Fatalf("expected unavailable, got %v", err)
+	}
+}

adapters/models/openai_compatible_local.go

@@ -22,9 +22,16 @@ import (
 type OpenAICompatibleLocalAdapter struct {
 	base   *url.URL
 	client *http.Client
+	apiKey string
 }
 
 func NewOpenAICompatibleLocalAdapter(raw string, transport http.RoundTripper) (*OpenAICompatibleLocalAdapter, error) {
+	return NewOpenAICompatibleLocalAdapterWithAPIKey(raw, "", transport)
+}
+
+// NewOpenAICompatibleLocalAdapterWithAPIKey creates an adapter for a gateway
+// whose bearer credential was resolved by the trusted runtime boundary.
+func NewOpenAICompatibleLocalAdapterWithAPIKey(raw, apiKey string, transport http.RoundTripper) (*OpenAICompatibleLocalAdapter, error) {
 	base, err := url.Parse(raw)
 	if err != nil || base.Scheme != "http" || base.Host == "" || strings.TrimSuffix(base.Path, "/") != "/v1" || base.RawQuery != "" || base.Fragment != "" || base.User != nil {
 		return nil, errors.New("invalid local compatible endpoint")
@@ -32,7 +39,7 @@ func NewOpenAICompatibleLocalAdapter(raw string, transport http.RoundTripper) (*
 	if transport == nil {
 		transport = http.DefaultTransport
 	}
-	return &OpenAICompatibleLocalAdapter{base: base, client: &http.Client{Transport: transport, Timeout: 10 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}, nil
+	return &OpenAICompatibleLocalAdapter{base: base, client: &http.Client{Transport: transport, Timeout: 10 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}, apiKey: strings.TrimSpace(apiKey)}, nil
 }
 
 type compatibleModelsResponse struct {
@@ -145,6 +152,9 @@ func (a *OpenAICompatibleLocalAdapter) requestJSON(ctx context.Context, method,
 		return 0, err
 	}
 	request.Header.Set("Accept", "application/json")
+	if a.apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+a.apiKey)
+	}
 	if input != nil {
 		request.Header.Set("Content-Type", "application/json")
 	}

adapters/models/openai_compatible_local_test.go

@@ -0,0 +1,42 @@
+package models
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+type captureRoundTripper struct {
+	authorization string
+}
+
+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
+}
+
+func TestOpenAICompatibleLocalAdapterUsesResolvedAPIKey(t *testing.T) {
+	transport := &captureRoundTripper{}
+	adapter, err := NewOpenAICompatibleLocalAdapterWithAPIKey("http://gateway/v1", "resolved-key", transport)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _ = adapter.Discover(context.Background())
+	if transport.authorization != "Bearer resolved-key" {
+		t.Fatalf("unexpected authorization header: %q", transport.authorization)
+	}
+}
+
+func TestOpenAICompatibleLocalAdapterDoesNotSendAuthorizationWithoutKey(t *testing.T) {
+	transport := &captureRoundTripper{}
+	adapter, err := NewOpenAICompatibleLocalAdapter("http://gateway/v1", transport)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, _ = adapter.Discover(context.Background())
+	if transport.authorization != "" {
+		t.Fatalf("unexpected authorization header")
+	}
+}

adapters/postgres/capability_repository.go

@@ -28,6 +28,89 @@ func OpenCapability(ctx context.Context, config ContinuityConfig) (*CapabilityRe
 
 func (r *CapabilityRepository) Close() { r.pool.Close() }
 
+func (r *CapabilityRepository) AdmitCognitive(ctx context.Context, leaseID string, policy capability.AdmissionPolicy, request capability.AdmissionRequest, nowUnixMillis int64) (capability.AdmissionDecision, capability.AdmissionLease, error) {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+	if leaseID == "" || nowUnixMillis < 1 {
+		return capability.AdmissionDecision{State: capability.AdmissionRejected, Reason: capability.AdmissionReasonInputBudget, PolicyID: policy.ID}, capability.AdmissionLease{}, nil
+	}
+	var existingState string
+	var existingPolicy string
+	err = tx.QueryRow(ctx, `SELECT state, policy_id FROM capability.cognitive_admission_leases WHERE lease_id=$1`, leaseID).Scan(&existingState, &existingPolicy)
+	if err == nil {
+		if existingState == "ACTIVE" {
+			return capability.AdmissionDecision{State: capability.AdmissionAdmitted, Reason: capability.AdmissionReasonNone, PolicyID: existingPolicy}, capability.AdmissionLease{ID: leaseID, PolicyID: existingPolicy}, tx.Commit(ctx)
+		}
+		return capability.AdmissionDecision{State: capability.AdmissionRejected, Reason: capability.AdmissionReasonConcurrency, PolicyID: existingPolicy}, capability.AdmissionLease{}, tx.Commit(ctx)
+	}
+	if !errors.Is(err, pgx.ErrNoRows) {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	windowStart := nowUnixMillis - 60*60*1000
+	_, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_admission_counters(policy_id,window_start_unix_millis,accepted_count,concurrent_count,updated_at_unix_millis) VALUES($1,$2,0,0,$3) ON CONFLICT(policy_id) DO NOTHING`, policy.ID, windowStart, nowUnixMillis)
+	if err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	var storedWindow int64
+	var accepted, concurrent int
+	if err = tx.QueryRow(ctx, `SELECT window_start_unix_millis,accepted_count,concurrent_count FROM capability.cognitive_admission_counters WHERE policy_id=$1 FOR UPDATE`, policy.ID).Scan(&storedWindow, &accepted, &concurrent); err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	if nowUnixMillis-storedWindow >= 60*60*1000 {
+		storedWindow, accepted = windowStart, 0
+	}
+	var expired int64
+	if err = tx.QueryRow(ctx, `WITH expired AS (UPDATE capability.cognitive_admission_leases SET state='EXPIRED' WHERE policy_id=$1 AND state='ACTIVE' AND expires_at_unix_millis <= $2 RETURNING lease_id) SELECT count(*) FROM expired`, policy.ID, nowUnixMillis).Scan(&expired); err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	concurrent -= int(expired)
+	if concurrent < 0 {
+		concurrent = 0
+	}
+	decision := capability.Admit(request, policy, capability.AdmissionCounters{Concurrent: concurrent, AcceptedLastHour: accepted}, nowUnixMillis)
+	if decision.State != capability.AdmissionAdmitted {
+		if _, err = tx.Exec(ctx, `UPDATE capability.cognitive_admission_counters SET window_start_unix_millis=$2,accepted_count=$3,concurrent_count=$4,updated_at_unix_millis=$5 WHERE policy_id=$1`, policy.ID, storedWindow, accepted, concurrent, nowUnixMillis); err != nil {
+			return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+		}
+		return decision, capability.AdmissionLease{}, tx.Commit(ctx)
+	}
+	expires := nowUnixMillis + 60*1000
+	if request.DeadlineMillis > nowUnixMillis && request.DeadlineMillis < expires {
+		expires = request.DeadlineMillis
+	}
+	if _, err = tx.Exec(ctx, `UPDATE capability.cognitive_admission_counters SET window_start_unix_millis=$2,accepted_count=$3,concurrent_count=$4,updated_at_unix_millis=$5 WHERE policy_id=$1`, policy.ID, storedWindow, accepted+1, concurrent+1, nowUnixMillis); err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_admission_leases(lease_id,policy_id,state,expires_at_unix_millis,created_at_unix_millis) VALUES($1,$2,'ACTIVE',$3,$4)`, leaseID, policy.ID, expires, nowUnixMillis); err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	return decision, capability.AdmissionLease{ID: leaseID, PolicyID: policy.ID}, tx.Commit(ctx)
+}
+
+func (r *CapabilityRepository) ReleaseCognitiveAdmission(ctx context.Context, lease capability.AdmissionLease, nowUnixMillis int64) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+	var policyID string
+	err = tx.QueryRow(ctx, `UPDATE capability.cognitive_admission_leases SET state='RELEASED' WHERE lease_id=$1 AND state='ACTIVE' RETURNING policy_id`, lease.ID).Scan(&policyID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return tx.Commit(ctx)
+	}
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(ctx, `UPDATE capability.cognitive_admission_counters SET concurrent_count=GREATEST(0,concurrent_count-1),updated_at_unix_millis=$2 WHERE policy_id=$1`, policyID, nowUnixMillis)
+	if err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
 func (r *CapabilityRepository) SaveHealth(ctx context.Context, health capability.Health) error {
 	_, err := r.pool.Exec(ctx, `INSERT INTO capability.health (capability_id, state, reason, revision, semantic_version, observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6) ON CONFLICT (capability_id) DO UPDATE SET state=EXCLUDED.state, reason=EXCLUDED.reason, revision=EXCLUDED.revision, semantic_version=EXCLUDED.semantic_version, observed_at_unix_millis=EXCLUDED.observed_at_unix_millis WHERE capability.health.revision < EXCLUDED.revision`, health.CapabilityID, health.State, health.Reason, health.Revision, health.SemanticVersion, health.ObservedAtUnixMillis)
 	return err

adapters/postgres/epistemics_repository.go

@@ -3,6 +3,7 @@ package postgres
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"git.cin.su/m/Assistant/contracts/epistemics"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -20,6 +21,10 @@ func OpenEpistemics(ctx context.Context, config ContinuityConfig) (*EpistemicsRe
 
 func (r *EpistemicsRepository) Close() { r.pool.Close() }
 
+func (r *EpistemicsRepository) Ping(ctx context.Context) error {
+	return r.pool.Ping(ctx)
+}
+
 func (r *EpistemicsRepository) SaveSystemExpectation(ctx context.Context, value epistemics.SystemExpectation) error {
 	_, err := r.pool.Exec(ctx, `INSERT INTO epistemics.system_expectations (
 		expectation_id, original_intent_id, source_utterance_id, expected_outcome, expected_effect,
@@ -64,7 +69,7 @@ func (r *EpistemicsRepository) RecentReflectionCandidates(ctx context.Context, l
 	}
 	rows, err := r.pool.Query(ctx, `SELECT
 		reflection_candidate_id,trigger,state,source_experience_id,original_intent_id,source_utterance_id,
-		summary,evidence_refs,requires_cognition,recorded_at_unix_millis,revision
+		 summary,evidence_refs,requires_cognition,recorded_at_unix_millis,revision,claimed_by,claim_expires_at_unix_millis
 		FROM epistemics.reflection_candidates ORDER BY recorded_at_unix_millis DESC, reflection_candidate_id DESC LIMIT $1`, limit)
 	if err != nil {
 		return nil, err
@@ -74,7 +79,7 @@ func (r *EpistemicsRepository) RecentReflectionCandidates(ctx context.Context, l
 	for rows.Next() {
 		var value epistemics.ReflectionCandidate
 		if err := rows.Scan(&value.ID, &value.Trigger, &value.State, &value.SourceExperienceID, &value.OriginalIntentID, &value.SourceUtteranceID,
-			&value.Summary, &value.EvidenceRefs, &value.RequiresCognition, &value.RecordedAtUnixMillis, &value.Revision); err != nil {
+			&value.Summary, &value.EvidenceRefs, &value.RequiresCognition, &value.RecordedAtUnixMillis, &value.Revision, &value.ClaimedBy, &value.ClaimExpiresAtUnixMillis); err != nil {
 			return nil, err
 		}
 		result = append(result, value)
@@ -82,6 +87,61 @@ func (r *EpistemicsRepository) RecentReflectionCandidates(ctx context.Context, l
 	return result, rows.Err()
 }
 
+func (r *EpistemicsRepository) ClaimReflectionCandidate(ctx context.Context, workerID string, nowUnixMillis, leaseMillis int64) (epistemics.ReflectionCandidate, error) {
+	if workerID == "" || leaseMillis < 1 {
+		return epistemics.ReflectionCandidate{}, fmt.Errorf("invalid reflection claim")
+	}
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return epistemics.ReflectionCandidate{}, err
+	}
+	defer tx.Rollback(ctx)
+	var value epistemics.ReflectionCandidate
+	err = tx.QueryRow(ctx, `SELECT reflection_candidate_id,trigger,state,source_experience_id,original_intent_id,source_utterance_id,summary,evidence_refs,requires_cognition,recorded_at_unix_millis,revision,claimed_by,claim_expires_at_unix_millis
+		FROM epistemics.reflection_candidates
+		WHERE state='OPEN' AND (claim_expires_at_unix_millis=0 OR claim_expires_at_unix_millis < $1)
+		ORDER BY recorded_at_unix_millis,reflection_candidate_id
+		FOR UPDATE SKIP LOCKED LIMIT 1`, nowUnixMillis).Scan(&value.ID, &value.Trigger, &value.State, &value.SourceExperienceID, &value.OriginalIntentID, &value.SourceUtteranceID, &value.Summary, &value.EvidenceRefs, &value.RequiresCognition, &value.RecordedAtUnixMillis, &value.Revision, &value.ClaimedBy, &value.ClaimExpiresAtUnixMillis)
+	if err != nil {
+		return epistemics.ReflectionCandidate{}, err
+	}
+	value.State = epistemics.ReflectionCandidateEvaluating
+	value.ClaimedBy = workerID
+	value.ClaimExpiresAtUnixMillis = nowUnixMillis + leaseMillis
+	_, err = tx.Exec(ctx, `UPDATE epistemics.reflection_candidates SET state=$1,claimed_by=$2,claim_expires_at_unix_millis=$3 WHERE reflection_candidate_id=$4 AND state='OPEN'`, value.State, value.ClaimedBy, value.ClaimExpiresAtUnixMillis, value.ID)
+	if err != nil {
+		return epistemics.ReflectionCandidate{}, err
+	}
+	if err := tx.Commit(ctx); err != nil {
+		return epistemics.ReflectionCandidate{}, err
+	}
+	return value, nil
+}
+
+func (r *EpistemicsRepository) RecoverReflectionClaims(ctx context.Context, nowUnixMillis int64) (int64, error) {
+	result, err := r.pool.Exec(ctx, `UPDATE epistemics.reflection_candidates SET state='OPEN',claimed_by='',claim_expires_at_unix_millis=0 WHERE state='EVALUATING' AND claim_expires_at_unix_millis > 0 AND claim_expires_at_unix_millis < $1`, nowUnixMillis)
+	return result.RowsAffected(), err
+}
+
+func (r *EpistemicsRepository) ResolveReflectionCandidate(ctx context.Context, id epistemics.ReflectionCandidateID, workerID string, nowUnixMillis int64) error {
+	if id == "" || workerID == "" {
+		return fmt.Errorf("invalid reflection resolution")
+	}
+	result, err := r.pool.Exec(ctx, `UPDATE epistemics.reflection_candidates SET state='RESOLVED',claimed_by='',claim_expires_at_unix_millis=0,revision=revision+1 WHERE reflection_candidate_id=$1 AND state='EVALUATING' AND claimed_by=$2 AND claim_expires_at_unix_millis >= $3`, id, workerID, nowUnixMillis)
+	if err == nil && result.RowsAffected() != 1 {
+		return fmt.Errorf("reflection candidate claim lost")
+	}
+	return err
+}
+
+func (r *EpistemicsRepository) WaitForReflectionCandidate(ctx context.Context, interval time.Duration) error {
+	if interval <= 0 {
+		return fmt.Errorf("invalid reflection poll interval")
+	}
+	_, err := r.pool.Exec(ctx, `SELECT pg_sleep($1)`, interval.Seconds())
+	return err
+}
+
 func (r *EpistemicsRepository) SaveExperienceRecord(ctx context.Context, value epistemics.ExperienceRecord) error {
 	_, err := r.pool.Exec(ctx, `INSERT INTO epistemics.experience_records (
 		experience_id, source_kind, original_intent_id, source_utterance_id, context_refs, help_method, help_method_ref,
@@ -105,3 +165,21 @@ func (r *EpistemicsRepository) SaveReflectionCandidate(ctx context.Context, valu
 		value.Summary, value.EvidenceRefs, value.RequiresCognition, value.RecordedAtUnixMillis, value.Revision)
 	return err
 }
+
+func (r *EpistemicsRepository) SaveTruthBundle(ctx context.Context, value epistemics.TruthBundle, recordedAtUnixMillis int64) error {
+	if value.Source.ID == "" || value.Snapshot.ID == "" || value.Excerpt.ID == "" || value.Claim.ID == "" || value.Belief.ID == "" || value.Citation.ID == "" || recordedAtUnixMillis < 1 {
+		return fmt.Errorf("invalid truth bundle")
+	}
+	_, err := r.pool.Exec(ctx, `INSERT INTO epistemics.truth_bundles (
+		bundle_id,source_id,source_kind,source_locator,source_title,source_publisher,snapshot_id,snapshot_source_id,snapshot_content_digest,snapshot_captured_at_unix_millis,snapshot_freshness,
+		excerpt_id,excerpt_snapshot_id,excerpt_text,excerpt_start,excerpt_end,observation_id,observation_observed_at_unix_millis,claim_id,claim_statement,claim_observation_id,claim_citation_id,claim_verification,
+		belief_id,belief_claim_id,belief_state,citation_id,citation_excerpt_id,citation_evidence,citation_coverage,citation_conflict,citation_resolved_at_unix_millis,recorded_at_unix_millis)
+		VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33)
+		ON CONFLICT (bundle_id) DO UPDATE SET recorded_at_unix_millis=EXCLUDED.recorded_at_unix_millis`,
+		"bundle:"+string(value.Citation.ID), value.Source.ID, value.Source.Kind, value.Source.Locator, value.Source.Title, value.Source.Publisher,
+		value.Snapshot.ID, value.Snapshot.SourceID, value.Snapshot.ContentDigest, value.Snapshot.CapturedAtUnixMillis, value.Snapshot.Freshness,
+		value.Excerpt.ID, value.Excerpt.SnapshotID, value.Excerpt.Text, value.Excerpt.Start, value.Excerpt.End,
+		value.Observation.ID, value.Observation.ObservedAt, value.Claim.ID, value.Claim.Statement, value.Claim.ObservationID, value.Claim.CitationID, value.Claim.Verification,
+		value.Belief.ID, value.Belief.ClaimID, value.Belief.State, value.Citation.ID, value.Citation.ExcerptID, value.Citation.Evidence, value.Citation.Coverage, value.Citation.Conflict, value.Citation.ResolvedAtUnixMillis, recordedAtUnixMillis)
+	return err
+}

adapters/postgres/work_repository.go

@@ -2,14 +2,23 @@ package postgres
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"time"
 
 	"git.cin.su/m/Assistant/contracts/work"
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 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")
+)
+
 func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, error) {
 	pool, err := openPool(ctx, config)
 	if err != nil {
@@ -17,7 +26,8 @@ func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, er
 	}
 	return &WorkRepository{pool}, nil
 }
-func (r *WorkRepository) Close() { r.pool.Close() }
+func (r *WorkRepository) Close()                         { r.pool.Close() }
+func (r *WorkRepository) Ping(ctx context.Context) error { return r.pool.Ping(ctx) }
 func (r *WorkRepository) Create(ctx context.Context, target work.TaskTarget) error {
 	_, err := r.pool.Exec(ctx, `INSERT INTO work.tasks (task_id,goal_id,scope_id,revision) VALUES ($1,$2,$3,$4) ON CONFLICT (task_id) DO NOTHING`, target.TaskID, target.GoalID, target.ScopeID, target.Revision)
 	return err
@@ -39,6 +49,198 @@ func (r *WorkRepository) Load(ctx context.Context, id work.TaskID) (work.TaskTar
 	return target, nil
 }
 
+func (r *WorkRepository) SaveDispatchIntent(ctx context.Context, intent work.AgentDispatchIntent) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	_, err = tx.Exec(ctx, `INSERT INTO work.agent_dispatch_intents(dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(idempotency_key) DO NOTHING`, intent.DispatchID, intent.IdempotencyKey, intent.DelegationID, intent.RunID, intent.ImplementationID, intent.ImplementationRevision, intent.SourceRevision, intent.WorktreeID, intent.VerificationPlanRef, intent.CreatedAtUnixMillis)
+	if err != nil {
+		return fmt.Errorf("save dispatch intent: %w", err)
+	}
+	var existing work.AgentDispatchIntent
+	err = tx.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis FROM work.agent_dispatch_intents WHERE idempotency_key=$1`, intent.IdempotencyKey).Scan(&existing.DispatchID, &existing.IdempotencyKey, &existing.DelegationID, &existing.RunID, &existing.ImplementationID, &existing.ImplementationRevision, &existing.SourceRevision, &existing.WorktreeID, &existing.VerificationPlanRef, &existing.CreatedAtUnixMillis)
+	if err != nil {
+		return fmt.Errorf("read dispatch intent: %w", err)
+	}
+	if existing != intent {
+		return ErrDispatchIntentConflict
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) LoadDispatchIntent(ctx context.Context, dispatchID string) (work.AgentDispatchIntent, error) {
+	var intent work.AgentDispatchIntent
+	err := r.pool.QueryRow(ctx, `SELECT dispatch_id,idempotency_key,delegation_id,run_id,implementation_id,implementation_revision,source_revision,worktree_id,verification_plan_ref,created_at_unix_millis FROM work.agent_dispatch_intents WHERE dispatch_id=$1`, dispatchID).Scan(&intent.DispatchID, &intent.IdempotencyKey, &intent.DelegationID, &intent.RunID, &intent.ImplementationID, &intent.ImplementationRevision, &intent.SourceRevision, &intent.WorktreeID, &intent.VerificationPlanRef, &intent.CreatedAtUnixMillis)
+	if err != nil {
+		return work.AgentDispatchIntent{}, fmt.Errorf("load dispatch intent: %w", err)
+	}
+	return intent, nil
+}
+
+func (r *WorkRepository) EnqueueDispatch(ctx context.Context, item work.AgentDispatchQueueItem) error {
+	_, err := r.pool.Exec(ctx, `INSERT INTO work.agent_dispatch_queue(dispatch_id,state,available_at_unix_millis,attempts,claimed_by,updated_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6) ON CONFLICT(dispatch_id) DO NOTHING`, item.DispatchID, item.State, item.AvailableAtUnixMillis, item.Attempts, item.ClaimedBy, item.UpdatedAtUnixMillis)
+	return err
+}
+
+func (r *WorkRepository) ClaimNextDispatch(ctx context.Context, workerID string, nowUnixMillis int64) (work.AgentDispatchQueueItem, error) {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return work.AgentDispatchQueueItem{}, err
+	}
+	defer tx.Rollback(ctx)
+	var item work.AgentDispatchQueueItem
+	err = tx.QueryRow(ctx, `SELECT dispatch_id,state,available_at_unix_millis,attempts,claimed_by,updated_at_unix_millis FROM work.agent_dispatch_queue WHERE state='QUEUED' AND available_at_unix_millis <= $1 ORDER BY available_at_unix_millis,dispatch_id FOR UPDATE SKIP LOCKED LIMIT 1`, nowUnixMillis).Scan(&item.DispatchID, &item.State, &item.AvailableAtUnixMillis, &item.Attempts, &item.ClaimedBy, &item.UpdatedAtUnixMillis)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return work.AgentDispatchQueueItem{}, nil
+		}
+		return work.AgentDispatchQueueItem{}, err
+	}
+	item.State = work.AgentDispatchClaimed
+	item.Attempts++
+	item.ClaimedBy = workerID
+	item.UpdatedAtUnixMillis = nowUnixMillis
+	_, err = tx.Exec(ctx, `UPDATE work.agent_dispatch_queue SET state=$1,attempts=$2,claimed_by=$3,updated_at_unix_millis=$4 WHERE dispatch_id=$5 AND state='QUEUED'`, item.State, item.Attempts, item.ClaimedBy, item.UpdatedAtUnixMillis, item.DispatchID)
+	if err != nil {
+		return work.AgentDispatchQueueItem{}, err
+	}
+	if err := tx.Commit(ctx); err != nil {
+		return work.AgentDispatchQueueItem{}, err
+	}
+	return item, nil
+}
+
+func (r *WorkRepository) WaitForDispatch(ctx context.Context, interval time.Duration) error {
+	if interval <= 0 {
+		return fmt.Errorf("invalid worker poll interval")
+	}
+	_, err := r.pool.Exec(ctx, `SELECT pg_sleep($1)`, interval.Seconds())
+	return err
+}
+
+func (r *WorkRepository) CompleteDispatch(ctx context.Context, dispatchID, workerID string, state work.AgentDispatchQueueState, nowUnixMillis int64) error {
+	if state != work.AgentDispatchCompleted && state != work.AgentDispatchFailed {
+		return fmt.Errorf("invalid terminal dispatch state: %s", state)
+	}
+	command, err := r.pool.Exec(ctx, `UPDATE work.agent_dispatch_queue SET state=$1,updated_at_unix_millis=$2 WHERE dispatch_id=$3 AND state='CLAIMED' AND claimed_by=$4`, state, nowUnixMillis, dispatchID, workerID)
+	if err != nil {
+		return err
+	}
+	if command.RowsAffected() != 1 {
+		return ErrAgentCallbackRejected
+	}
+	return nil
+}
+
+func (r *WorkRepository) SaveWorkGraph(ctx context.Context, graph work.WorkGraph) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err := tx.Exec(ctx, `INSERT INTO work.graphs(graph_id,revision,state,max_parallel,max_attempts) VALUES($1,$2,$3,$4,$5) ON CONFLICT(graph_id,revision) DO NOTHING`, graph.ID, graph.Revision, graph.State, graph.Budget.MaxParallel, graph.Budget.MaxAttempts); err != nil {
+		return err
+	}
+	for _, node := range graph.Nodes {
+		if _, err := tx.Exec(ctx, `INSERT INTO work.graph_nodes(graph_id,revision,node_id,dispatch_id,idempotency_key,state,attempts) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(graph_id,revision,node_id) DO NOTHING`, graph.ID, graph.Revision, node.ID, node.DispatchID, node.IdempotencyKey, node.State, node.Attempts); err != nil {
+			return err
+		}
+	}
+	for _, edge := range graph.Edges {
+		if _, err := tx.Exec(ctx, `INSERT INTO work.graph_edges(graph_id,revision,from_node_id,to_node_id) VALUES($1,$2,$3,$4) ON CONFLICT(graph_id,revision,from_node_id,to_node_id) DO NOTHING`, graph.ID, graph.Revision, edge.From, edge.To); err != nil {
+			return err
+		}
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) LoadWorkGraph(ctx context.Context, graphID string, revision int64) (work.WorkGraph, error) {
+	var graph work.WorkGraph
+	err := r.pool.QueryRow(ctx, `SELECT graph_id,revision,state,max_parallel,max_attempts FROM work.graphs WHERE graph_id=$1 AND revision=$2`, graphID, revision).Scan(&graph.ID, &graph.Revision, &graph.State, &graph.Budget.MaxParallel, &graph.Budget.MaxAttempts)
+	if err != nil {
+		return work.WorkGraph{}, fmt.Errorf("load graph: %w", err)
+	}
+	rows, err := r.pool.Query(ctx, `SELECT node_id,dispatch_id,idempotency_key,state,attempts FROM work.graph_nodes WHERE graph_id=$1 AND revision=$2 ORDER BY node_id`, graphID, revision)
+	if err != nil {
+		return work.WorkGraph{}, err
+	}
+	for rows.Next() {
+		var node work.GraphNode
+		if err := rows.Scan(&node.ID, &node.DispatchID, &node.IdempotencyKey, &node.State, &node.Attempts); err != nil {
+			rows.Close()
+			return work.WorkGraph{}, err
+		}
+		graph.Nodes = append(graph.Nodes, node)
+	}
+	if err := rows.Err(); err != nil {
+		rows.Close()
+		return work.WorkGraph{}, err
+	}
+	rows.Close()
+	edges, err := r.pool.Query(ctx, `SELECT from_node_id,to_node_id FROM work.graph_edges WHERE graph_id=$1 AND revision=$2 ORDER BY from_node_id,to_node_id`, graphID, revision)
+	if err != nil {
+		return work.WorkGraph{}, err
+	}
+	for edges.Next() {
+		var edge work.GraphEdge
+		if err := edges.Scan(&edge.From, &edge.To); err != nil {
+			edges.Close()
+			return work.WorkGraph{}, err
+		}
+		graph.Edges = append(graph.Edges, edge)
+	}
+	if err := edges.Err(); err != nil {
+		edges.Close()
+		return work.WorkGraph{}, err
+	}
+	edges.Close()
+	return graph, nil
+}
+
+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 {
+		return 0, err
+	}
+	return command.RowsAffected(), nil
+}
+
+func (r *WorkRepository) SaveAgentLease(ctx context.Context, lease work.AgentLease) error {
+	err := r.pool.QueryRow(ctx, `INSERT INTO work.agent_leases(lease_id,run_id,worker_id,fencing_token,state,acquired_at_unix_millis,expires_at_unix_millis) VALUES($1,$2,$3,$4,$5,$6,$7) ON CONFLICT(run_id) DO UPDATE SET lease_id=EXCLUDED.lease_id,worker_id=EXCLUDED.worker_id,fencing_token=EXCLUDED.fencing_token,state=EXCLUDED.state,acquired_at_unix_millis=EXCLUDED.acquired_at_unix_millis,expires_at_unix_millis=EXCLUDED.expires_at_unix_millis WHERE work.agent_leases.state='EXPIRED' OR work.agent_leases.expires_at_unix_millis <= EXCLUDED.acquired_at_unix_millis RETURNING run_id`, lease.ID, lease.RunID, lease.WorkerID, lease.FencingToken, lease.State, lease.AcquiredAt.UnixMilli(), lease.ExpiresAt.UnixMilli()).Scan(new(string))
+	if err != nil {
+		return ErrAgentLeaseUnavailable
+	}
+	return nil
+}
+
+func (r *WorkRepository) RenewAgentLease(ctx context.Context, lease work.AgentLease, expiresAt time.Time) error {
+	command, err := r.pool.Exec(ctx, `UPDATE work.agent_leases SET expires_at_unix_millis=$1 WHERE run_id=$2 AND worker_id=$3 AND fencing_token=$4 AND state='ACTIVE' AND expires_at_unix_millis > $5`, expiresAt.UnixMilli(), lease.RunID, lease.WorkerID, lease.FencingToken, time.Now().UnixMilli())
+	if err != nil || command.RowsAffected() != 1 {
+		return ErrAgentLeaseUnavailable
+	}
+	return nil
+}
+
+func (r *WorkRepository) AcceptAgentCallback(ctx context.Context, callback work.AgentCallback) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	var runID string
+	err = tx.QueryRow(ctx, `SELECT run_id FROM work.agent_leases WHERE run_id=$1 AND worker_id=$2 AND fencing_token=$3 AND state='ACTIVE' AND expires_at_unix_millis > $4 FOR UPDATE`, callback.RunID, callback.WorkerID, callback.FencingToken, callback.ObservedAt.UnixMilli()).Scan(&runID)
+	if err != nil {
+		return ErrAgentCallbackRejected
+	}
+	command, err := tx.Exec(ctx, `INSERT INTO work.agent_callback_heads(run_id,last_sequence,updated_at_unix_millis) VALUES($1,$2,$3) ON CONFLICT(run_id) DO UPDATE SET last_sequence=EXCLUDED.last_sequence,updated_at_unix_millis=EXCLUDED.updated_at_unix_millis WHERE work.agent_callback_heads.last_sequence < EXCLUDED.last_sequence`, runID, callback.Sequence, callback.ObservedAt.UnixMilli())
+	if err != nil || command.RowsAffected() != 1 {
+		return ErrAgentCallbackRejected
+	}
+	return tx.Commit(ctx)
+}
+
 func (r *WorkRepository) SavePlanningResult(ctx context.Context, result work.PlanningResult) error {
 	tx, err := r.pool.Begin(ctx)
 	if err != nil {

adapters/research/http_connector.go

@@ -0,0 +1,74 @@
+package research
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/epistemics"
+)
+
+var ErrHTTPSourceRejected = errors.New("http research source rejected")
+
+type HTTPConnector struct {
+	Client       *http.Client
+	AllowedHosts map[string]struct{}
+	MaxBytes     int64
+}
+
+func (c HTTPConnector) Collect(ctx context.Context, request epistemics.WebResearchRequest, nowUnixMillis int64) (epistemics.ResearchCandidate, error) {
+	if request.Plan.Validate() != nil || request.SourceID == "" || strings.TrimSpace(request.Statement) == "" || nowUnixMillis < 1 {
+		return epistemics.ResearchCandidate{}, ErrHTTPSourceRejected
+	}
+	u, err := url.Parse(request.URL)
+	if err != nil || u.Scheme != "https" || u.User != nil || u.Host == "" || !c.allowedHost(strings.ToLower(u.Hostname())) {
+		return epistemics.ResearchCandidate{}, ErrHTTPSourceRejected
+	}
+	client := c.Client
+	if client == nil {
+		client = &http.Client{}
+	}
+	maxBytes := c.MaxBytes
+	if maxBytes <= 0 || maxBytes > 4<<20 {
+		maxBytes = 256 << 10
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+	if err != nil {
+		return epistemics.ResearchCandidate{}, ErrHTTPSourceRejected
+	}
+	response, err := client.Do(req)
+	if err != nil {
+		return epistemics.ResearchCandidate{}, fmt.Errorf("read web source: %w", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return epistemics.ResearchCandidate{}, fmt.Errorf("web source status: %s", response.Status)
+	}
+	body, err := io.ReadAll(io.LimitReader(response.Body, maxBytes+1))
+	if err != nil || int64(len(body)) > maxBytes || len(body) == 0 {
+		return epistemics.ResearchCandidate{}, ErrHTTPSourceRejected
+	}
+	digest := sha256.Sum256(body)
+	digestText := "sha256:" + hex.EncodeToString(digest[:])
+	key := sha256.Sum256([]byte(u.String() + "\x00" + digestText))
+	keyText := hex.EncodeToString(key[:])
+	snapshotID := epistemics.SourceSnapshotID("snapshot:" + keyText)
+	return epistemics.ResearchCandidate{
+		PropositionKey: request.PropositionKey, Statement: request.Statement,
+		Source:   epistemics.Source{ID: request.SourceID, Kind: "web", Locator: u.String(), Title: request.Title, Publisher: u.Hostname()},
+		Snapshot: epistemics.SourceSnapshot{ID: snapshotID, SourceID: request.SourceID, ContentDigest: digestText, CapturedAtUnixMillis: nowUnixMillis, Freshness: epistemics.FreshnessCurrent},
+		Excerpt:  epistemics.SourceExcerpt{ID: epistemics.SourceExcerptID("excerpt:" + keyText), SnapshotID: snapshotID, Text: string(body), Start: 0, End: int64(len(body))},
+		Evidence: epistemics.EvidenceObserved, Coverage: epistemics.CoverageComplete, Conflict: epistemics.ConflictNone,
+	}, nil
+}
+
+func (c HTTPConnector) allowedHost(host string) bool {
+	_, ok := c.AllowedHosts[host]
+	return ok
+}

adapters/research/repository_connector.go

@@ -0,0 +1,63 @@
+package research
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/epistemics"
+)
+
+var ErrRepositoryPathRejected = errors.New("repository source path rejected")
+
+type RepositoryConnector struct{ Root string }
+
+func (c RepositoryConnector) Collect(ctx context.Context, request epistemics.RepositoryResearchRequest, nowUnixMillis int64) (epistemics.ResearchCandidate, error) {
+	if err := request.Plan.Validate(); err != nil {
+		return epistemics.ResearchCandidate{}, err
+	}
+	if request.SourceID == "" || strings.TrimSpace(request.Statement) == "" || nowUnixMillis < 1 {
+		return epistemics.ResearchCandidate{}, ErrRepositoryPathRejected
+	}
+	root, err := filepath.Abs(c.Root)
+	if err != nil || root == "" {
+		return epistemics.ResearchCandidate{}, ErrRepositoryPathRejected
+	}
+	path, err := filepath.Abs(filepath.Join(root, filepath.FromSlash(request.Path)))
+	if err != nil || !withinRoot(root, path) {
+		return epistemics.ResearchCandidate{}, ErrRepositoryPathRejected
+	}
+	select {
+	case <-ctx.Done():
+		return epistemics.ResearchCandidate{}, ctx.Err()
+	default:
+	}
+	content, err := os.ReadFile(path)
+	if err != nil || len(content) == 0 {
+		return epistemics.ResearchCandidate{}, fmt.Errorf("read repository source: %w", err)
+	}
+	digest := sha256.Sum256(content)
+	digestText := "sha256:" + hex.EncodeToString(digest[:])
+	key := sha256.Sum256([]byte(filepath.ToSlash(path) + "\x00" + digestText))
+	keyText := hex.EncodeToString(key[:])
+	return epistemics.ResearchCandidate{
+		PropositionKey: request.PropositionKey,
+		Statement:      request.Statement,
+		Source:         epistemics.Source{ID: request.SourceID, Kind: "repository", Locator: "file://" + filepath.ToSlash(path), Title: filepath.Base(path), Publisher: "local-repository"},
+		Snapshot:       epistemics.SourceSnapshot{ID: epistemics.SourceSnapshotID("snapshot:" + keyText), SourceID: request.SourceID, ContentDigest: digestText, CapturedAtUnixMillis: nowUnixMillis, Freshness: epistemics.FreshnessCurrent},
+		Excerpt:        epistemics.SourceExcerpt{ID: epistemics.SourceExcerptID("excerpt:" + keyText), SnapshotID: epistemics.SourceSnapshotID("snapshot:" + keyText), Text: string(content), Start: 0, End: int64(len(content))},
+		Evidence:       epistemics.EvidenceObserved,
+		Coverage:       epistemics.CoverageComplete,
+		Conflict:       epistemics.ConflictNone,
+	}, nil
+}
+
+func withinRoot(root, path string) bool {
+	rel, err := filepath.Rel(root, path)
+	return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) && !filepath.IsAbs(rel)
+}

architecture/architecture-registry.json

@@ -65,7 +65,12 @@
         "WorkPlan",
         "PlanStep",
         "CapabilityRequirement",
-        "DelegationCandidate"
+        "DelegationCandidate",
+        "Delegation",
+        "AgentRun",
+        "AgentCheckpoint",
+        "AgentResult",
+        "DelegationVerification"
       ],
       "database_schema": "work",
       "boundary_class": "remote_capable",

architecture/architecture-registry.md

@@ -25,17 +25,17 @@ modules:
 
   situation:
     id: mod.situation
-    owns: [Situation, FocusBinding]
+    owns: [Situation, FocusBinding, ProjectRegistry, ActiveProjectFocus]
     database_schema: situation
     boundary_class: remote_capable
-    may_depend_on: [contracts.identity, contracts.work, contracts.capability]
+    may_depend_on: [contracts.identity, contracts.authority, contracts.work, contracts.capability]
 
   work:
     id: mod.work
-    owns: [Goal, Task, Decision]
+    owns: [Goal, HelpPath, GoalLifecycle, Task, Decision, PlanCandidate, WorkPlan, PlanStep, CapabilityRequirement, DelegationCandidate, Delegation, AgentRun, AgentCheckpoint, AgentResult, DelegationVerification]
     database_schema: work
     boundary_class: remote_capable
-    may_depend_on: [contracts.identity, contracts.authority, platform.events]
+    may_depend_on: [contracts.identity, contracts.authority, contracts.epistemics, contracts.capability, platform.ids, platform.events]
 
   epistemics:
     id: mod.epistemics
@@ -53,7 +53,7 @@ modules:
 
   capability:
     id: mod.capability
-    owns: [Capability, CapabilityBinding, CapabilityHealth]
+    owns: [Capability, CapabilityBinding, CapabilityHealth, CapabilityImplementation, CapabilityResolution, CapabilitySelection, CapabilityGap, AcquisitionStrategyCandidate, CapabilityUsageObservation, SkillProfile, SkillEvidence, FastPathDecision]
     database_schema: capability
     boundary_class: remote_capable
     may_depend_on: [contracts.identity, contracts.authority, contracts.artifact]
@@ -81,11 +81,12 @@ platform:
     - platform.inbox
     - platform.telemetry
     - platform.errors
+    - platform.secrets
   rule: "platform owns mechanisms, never domain meaning"
 
 runtime_topology_v1:
   core_runtime:
-    modules: [identity, situation, work, epistemics, capability, artifact]
+    modules: [identity, situation, work, epistemics, capability, artifact, interaction]
   continuity_runtime:
     modules: [continuity]
   commit_runtime:
@@ -107,6 +108,7 @@ storage_topology_v1:
     capability: capability_role
     commit: commit_role
     artifact: artifact_role
+    interaction: interaction_role
   cross_owner_fk: forbidden_by_default
   cross_owner_write: forbidden
   cross_owner_application_join: forbidden
@@ -142,6 +144,10 @@ protected_paths:
   - architecture/architecture-registry.yaml
   - architecture/adrs/**
   - ci/architecture/**
+  - .gitea/workflows/ci.yml
+  - cmd/devctl/**
+  - dev/ACTIVE_TASK.json
+  - ci/architecture/**
   - security/**
 
 default_feature_task_authority:

architecture/architecture-registry.yaml

@@ -27,7 +27,7 @@ modules:
 
   work:
     id: mod.work
-    owns: [Goal, HelpPath, GoalLifecycle, Task, Decision, PlanCandidate, WorkPlan, PlanStep, CapabilityRequirement, DelegationCandidate]
+    owns: [Goal, HelpPath, GoalLifecycle, Task, Decision, PlanCandidate, WorkPlan, PlanStep, CapabilityRequirement, DelegationCandidate, Delegation, AgentRun, AgentCheckpoint, AgentResult, DelegationVerification]
     database_schema: work
     boundary_class: remote_capable
     may_depend_on: [contracts.identity, contracts.authority, contracts.epistemics, contracts.capability, platform.ids, platform.events]

cmd/agent-canary/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"time"
+
+	"git.cin.su/m/Assistant/adapters/postgres"
+	"git.cin.su/m/Assistant/contracts/work"
+	"git.cin.su/m/Assistant/modules/work/application"
+	"git.cin.su/m/Assistant/modules/work/ports"
+)
+
+type memoryStore struct{ writes int }
+
+func (s *memoryStore) SaveDispatchIntent(context.Context, work.AgentDispatchIntent) error {
+	s.writes++
+	return nil
+}
+func (s *memoryStore) SaveAgentLease(context.Context, work.AgentLease) error { s.writes++; return nil }
+func (s *memoryStore) AcceptAgentCallback(context.Context, work.AgentCallback) error {
+	s.writes++
+	return nil
+}
+
+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")
+	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()}
+	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")})
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		store = repository
+		closeStore = repository.Close
+	}
+	if closeStore != nil {
+		defer closeStore()
+	}
+	result, err := application.ExecuteCanaryDryRun(context.Background(), store, application.CanaryConfig{Enabled: *enabled, ImplementationID: "fake-worker", MaxDispatches: 1}, 0, intent, "manual-worker", 1, now, 15*time.Minute)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	output := struct {
+		DispatchID    string `json:"dispatch_id"`
+		RunID         string `json:"run_id"`
+		CallbackCount int    `json:"callback_count"`
+		StoreWrites   int    `json:"store_writes"`
+	}{result.Intent.DispatchID, string(result.Intent.RunID), result.CallbackCount(), 0}
+	if memory, ok := store.(*memoryStore); ok {
+		output.StoreWrites = memory.writes
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(output); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

cmd/agent-worker/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"net/http"
+	"os"
+	"time"
+
+	"git.cin.su/m/Assistant/adapters/agentbridge"
+	"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"
+)
+
+func main() {
+	workerID := flag.String("worker-id", "agent-worker-1", "durable worker identity")
+	statusAddr := flag.String("status-addr", ":8090", "internal status HTTP address")
+	staleAfter := flag.Duration("stale-after", 10*time.Minute, "age after which a claimed item is recovered")
+	leaseTTL := flag.Duration("lease-ttl", 15*time.Minute, "executor lease duration")
+	pollInterval := flag.Duration("poll-interval", 5*time.Second, "database-owned idle wake-up interval")
+	once := flag.Bool("once", false, "run one cycle and exit")
+	flag.Parse()
+
+	password, err := resolveDatabasePassword("WORK_POSTGRES_PASSWORD", "WORK_POSTGRES_CREDENTIAL_REF", secretcontracts.RuntimeConsumerWorkWorker)
+	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)
+	}
+	defer repository.Close()
+	var executor ports.AgentExecutor
+	if bridgeURL := os.Getenv("AGENT_EXECUTION_BRIDGE_URL"); bridgeURL != "" {
+		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")
+	}
+	go func() {
+		if serveErr := http.ListenAndServe(*statusAddr, workerStatusHandler(executor != nil)); serveErr != nil {
+			fmt.Fprintln(os.Stderr, "agent worker status server:", serveErr)
+		}
+	}()
+	ctx := context.Background()
+	for {
+		var result application.WorkerCycleResult
+		var cycleErr error
+		if executor == nil {
+			result, cycleErr = application.RecoverOnlyWorkerCycle(ctx, repository, time.Now().UTC(), *staleAfter)
+		} else {
+			result, cycleErr = application.ExecuteWorkerCycleWithExecutor(ctx, repository, executor, *workerID, work.AgentFencingToken(1), time.Now().UTC(), *staleAfter, *leaseTTL)
+		}
+		if cycleErr != nil {
+			fmt.Fprintln(os.Stderr, cycleErr)
+			if *once {
+				os.Exit(1)
+			}
+		}
+		if cycleErr == nil && (result.Completed || result.RecoveredClaims > 0) {
+			_ = json.NewEncoder(os.Stdout).Encode(result)
+		}
+		if *once {
+			return
+		}
+		if err := repository.WaitForDispatch(ctx, *pollInterval); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+	}
+}
+
+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)
+	}
+	path, ref := os.Getenv(name+"_FILE"), os.Getenv(refName)
+	if path == "" || ref == "" {
+		return "", fmt.Errorf("%s_FILE and %s are required", name, refName)
+	}
+	root := os.Getenv("SECRET_BACKEND_ROOT")
+	if root == "" {
+		root = "/run/secrets"
+	}
+	resolver, err := platformsecrets.NewFileResolver(root)
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeDatabasePassword, Consumer: consumer, Path: path})
+}

cmd/agent-worker/status.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+type workerStatusResponse struct {
+	Runtime            string `json:"runtime"`
+	ExecutorConfigured bool   `json:"executor_configured"`
+	Mode               string `json:"mode"`
+	Ready              bool   `json:"ready"`
+	Reason             string `json:"reason"`
+}
+
+func workerStatusHandler(executorConfigured bool) http.Handler {
+	status := workerStatusResponse{
+		Runtime:            "agent-worker",
+		ExecutorConfigured: executorConfigured,
+		Mode:               "recovery-only",
+		Ready:              false,
+		Reason:             "AGENT_EXECUTION_BRIDGE_URL is not configured",
+	}
+	if executorConfigured {
+		status.Mode = "execution"
+		status.Ready = true
+		status.Reason = "typed agent execution bridge configured"
+	}
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet || (r.URL.Path != "/healthz" && r.URL.Path != "/readyz" && r.URL.Path != "/status") {
+			http.NotFound(w, r)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if r.URL.Path == "/readyz" && !status.Ready {
+			w.WriteHeader(http.StatusServiceUnavailable)
+		}
+		_ = json.NewEncoder(w).Encode(status)
+	})
+}

cmd/agent-worker/status_test.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestWorkerStatusReportsRecoveryOnlyWithoutExecutor(t *testing.T) {
+	response := httptest.NewRecorder()
+	workerStatusHandler(false).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 != "recovery-only" || value.ExecutorConfigured {
+		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))
+	if response.Code != http.StatusServiceUnavailable {
+		t.Fatalf("readyz status=%d", response.Code)
+	}
+	response = httptest.NewRecorder()
+	workerStatusHandler(true).ServeHTTP(response, httptest.NewRequest(http.MethodGet, "/readyz", nil))
+	if response.Code != http.StatusOK {
+		t.Fatalf("configured readyz status=%d", response.Code)
+	}
+}

cmd/cognitive-worker/admission.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+type httpAdmissionClient struct {
+	baseURL string
+	client  *http.Client
+}
+
+func newHTTPAdmissionClient(baseURL string, client *http.Client) *httpAdmissionClient {
+	return &httpAdmissionClient{baseURL: strings.TrimRight(baseURL, "/"), client: client}
+}
+
+func (c *httpAdmissionClient) Admit(ctx context.Context, leaseID string, request capability.AdmissionRequest) (capability.AdmissionDecision, capability.AdmissionLease, error) {
+	payload, err := json.Marshal(struct {
+		LeaseID string                      `json:"lease_id"`
+		Request capability.AdmissionRequest `json:"request"`
+	}{leaseID, request})
+	if err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/v1/internal/cognitive/admission", bytes.NewReader(payload))
+	if err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, fmt.Errorf("admission status %d", resp.StatusCode)
+	}
+	var result struct {
+		Decision capability.AdmissionDecision `json:"decision"`
+		Lease    capability.AdmissionLease    `json:"lease"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return capability.AdmissionDecision{}, capability.AdmissionLease{}, err
+	}
+	return result.Decision, result.Lease, nil
+}
+
+func (c *httpAdmissionClient) Release(ctx context.Context, lease capability.AdmissionLease) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/v1/internal/cognitive/admission/"+lease.ID+"/release", nil)
+	if err != nil {
+		return err
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("admission release status %d", resp.StatusCode)
+	}
+	return nil
+}

cmd/cognitive-worker/admission_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"context"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/cognitive"
+)
+
+type admissionTestProvider struct{ calls int }
+
+func (p *admissionTestProvider) Advise(context.Context, cognitive.AdvisoryRequest) (cognitive.AdvisoryResponse, error) {
+	p.calls++
+	return cognitive.AdvisoryResponse{FinishReason: cognitive.FinishCompleted}, nil
+}
+
+type admissionTestClient struct {
+	decision capability.AdmissionDecision
+	releases int
+}
+
+func (c *admissionTestClient) Admit(context.Context, string, capability.AdmissionRequest) (capability.AdmissionDecision, capability.AdmissionLease, error) {
+	return c.decision, capability.AdmissionLease{ID: "lease-1", PolicyID: "policy-1"}, nil
+}
+func (c *admissionTestClient) Release(context.Context, capability.AdmissionLease) error {
+	c.releases++
+	return nil
+}
+
+func TestInvokeAdmittedDoesNotCallProviderWhenRejected(t *testing.T) {
+	provider := &admissionTestProvider{}
+	client := &admissionTestClient{decision: capability.AdmissionDecision{State: capability.AdmissionRejected, Reason: capability.AdmissionReasonConcurrency, PolicyID: "policy-1"}}
+	gateway := cognitiveGateway{admission: client}
+	response, err := gateway.invokeAdmitted(context.Background(), "request-1", provider, cognitive.AdvisoryRequest{Message: "hello"}, 100)
+	if err != nil || response.FinishReason != cognitive.FinishRateLimited || provider.calls != 0 || client.releases != 0 {
+		t.Fatalf("rejected admission leaked provider call: response=%#v err=%v calls=%d releases=%d", response, err, provider.calls, client.releases)
+	}
+}
+
+func TestInvokeAdmittedReleasesDurableLeaseAfterProvider(t *testing.T) {
+	provider := &admissionTestProvider{}
+	client := &admissionTestClient{decision: capability.AdmissionDecision{State: capability.AdmissionAdmitted, Reason: capability.AdmissionReasonNone, PolicyID: "policy-1"}}
+	gateway := cognitiveGateway{admission: client}
+	response, err := gateway.invokeAdmitted(context.Background(), "request-1", provider, cognitive.AdvisoryRequest{Message: "hello"}, 100)
+	if err != nil || response.FinishReason != cognitive.FinishCompleted || provider.calls != 1 || client.releases != 1 {
+		t.Fatalf("admitted lease was not released: response=%#v err=%v calls=%d releases=%d", response, err, provider.calls, client.releases)
+	}
+}

cmd/cognitive-worker/fleet_status.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	fleetdomain "git.cin.su/m/Assistant/modules/capability/domain"
+)
+
+type fleetEndpoint struct {
+	ProviderID string
+	ModelID    string
+	Tier       capability.FleetTier
+	URL        string
+}
+
+type fleetStatusResponse struct {
+	Readiness capability.FleetReadiness `json:"readiness"`
+	Preferred capability.FleetTier      `json:"preferred_tier"`
+	Selected  capability.FleetTier      `json:"selected_tier,omitempty"`
+	Error     string                    `json:"error,omitempty"`
+}
+
+func fleetReadinessHandler(client *http.Client, preferred capability.FleetTier, endpoints []fleetEndpoint) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		members := make([]capability.FleetMember, 0, len(endpoints))
+		for _, endpoint := range endpoints {
+			member := capability.FleetMember{ProviderInstanceID: capability.ProviderInstanceID(endpoint.ProviderID), ModelDescriptorID: capability.ModelDescriptorID(endpoint.ModelID), Tier: endpoint.Tier, Reason: "NOT_CONFIGURED"}
+			if strings.TrimSpace(endpoint.URL) == "" {
+				members = append(members, member)
+				continue
+			}
+			request, err := http.NewRequestWithContext(r.Context(), http.MethodGet, endpoint.URL, nil)
+			if err == nil {
+				response, requestErr := client.Do(request)
+				if requestErr == nil {
+					response.Body.Close()
+					if response.StatusCode >= 200 && response.StatusCode < 300 {
+						member.Ready, member.Reason = true, "AVAILABLE"
+					} else {
+						member.Reason = fmt.Sprintf("status=%s", response.Status)
+					}
+				} else {
+					member.Reason = requestErr.Error()
+				}
+			}
+			members = append(members, member)
+		}
+		readiness, err := fleetdomain.BuildFleetReadiness(time.Now().UnixMilli(), members)
+		response := fleetStatusResponse{Readiness: readiness, Preferred: preferred}
+		if err == nil {
+			response.Selected, err = fleetdomain.SelectFleetTier(readiness, preferred)
+		}
+		if err != nil {
+			response.Error = err.Error()
+		}
+		w.Header().Set("Content-Type", "application/json")
+		if response.Selected == "" {
+			w.WriteHeader(http.StatusServiceUnavailable)
+		}
+		_ = json.NewEncoder(w).Encode(response)
+	})
+}
+
+func fleetContext(ctx context.Context) context.Context { return ctx }

cmd/cognitive-worker/fleet_status_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+func TestFleetReadinessSelectsLifeboatWhenPrimaryTiersUnavailable(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) }))
+	defer server.Close()
+	handler := fleetReadinessHandler(server.Client(), capability.FleetTierHeavy, []fleetEndpoint{
+		{ProviderID: "cpu", ModelID: "cpu-model", Tier: capability.FleetTierFast, URL: server.URL},
+		{ProviderID: "medium", ModelID: "medium-model", Tier: capability.FleetTierMedium},
+		{ProviderID: "heavy", ModelID: "heavy-model", Tier: capability.FleetTierHeavy},
+		{ProviderID: "lifeboat", ModelID: "lifeboat-model", Tier: capability.FleetTierLifeboat, URL: server.URL},
+	})
+	recorder := httptest.NewRecorder()
+	request := httptest.NewRequest(http.MethodGet, "/v1/fleet/readiness", nil)
+	handler.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusOK || !strings.Contains(recorder.Body.String(), `"selected_tier":"LIFEBOAT"`) || !strings.Contains(recorder.Body.String(), `"tier":"MEDIUM"`) {
+		t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+}

cmd/cognitive-worker/gateway.go

@@ -26,6 +26,11 @@ type bindingResolver interface {
 	RegisterDiscovery(context.Context, capability.CognitiveDiscoverySnapshot) (capability.CognitiveDiscoveryRegistration, error)
 }
 
+type admissionClient interface {
+	Admit(context.Context, string, capability.AdmissionRequest) (capability.AdmissionDecision, capability.AdmissionLease, error)
+	Release(context.Context, capability.AdmissionLease) error
+}
+
 type providerRegistration struct {
 	ProviderInstanceID capability.ProviderInstanceID
 	Kind               capability.ProviderKind
@@ -46,6 +51,7 @@ type cognitiveGateway struct {
 	now                  func() time.Time
 	allowCanary          bool
 	canaryMaxOutputBytes int
+	admission            admissionClient
 }
 
 func (g cognitiveGateway) policyHandler(w http.ResponseWriter, r *http.Request) {
@@ -95,9 +101,9 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
 	}
 	invocation := cognitive.AdvisoryRequest{Version: request.Version, RequestID: request.RequestID, ActorID: request.ActorID, PrincipalID: request.PrincipalID, ScopeID: request.ScopeID, Message: request.Message, Context: request.Context, Locale: request.Locale, MaxOutputBytes: maxOutputBytes, ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, ProviderInstanceID: selected.Provider.ID, ModelDescriptorID: selected.Model.ID, ProviderModelID: selected.Model.ProviderModelID}
 	started := g.now()
-	response, invokeErr := provider.Advise(r.Context(), invocation)
+	response, invokeErr := g.invokeAdmitted(r.Context(), string(request.RequestID), provider, invocation, maxOutputBytes)
 	if invokeErr != nil {
-		response = cognitive.AdvisoryResponse{Version: request.Version, RequestID: request.RequestID, ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, FinishReason: cognitive.FinishInvalidProviderResponse}
+		response = cognitive.AdvisoryResponse{Version: request.Version, RequestID: request.RequestID, ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, FinishReason: cognitive.FinishProviderUnavailable}
 	}
 	g.observe(r.Context(), selected, response, started)
 	if fallbackEligible(response.FinishReason) {
@@ -109,9 +115,9 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
 			fallbackRequest.ProviderBindingID, fallbackRequest.ProviderBindingRevision = fallback.Binding.ID, fallback.Binding.Revision
 			fallbackRequest.ProviderInstanceID, fallbackRequest.ModelDescriptorID, fallbackRequest.ProviderModelID = fallback.Provider.ID, fallback.Model.ID, fallback.Model.ProviderModelID
 			fallbackStarted := g.now()
-			fallbackResponse, fallbackErr := fallbackProvider.Advise(r.Context(), fallbackRequest)
+			fallbackResponse, fallbackErr := g.invokeAdmitted(r.Context(), string(request.RequestID)+":fallback", fallbackProvider, fallbackRequest, maxOutputBytes)
 			if fallbackErr != nil {
-				fallbackResponse = cognitive.AdvisoryResponse{Version: request.Version, RequestID: request.RequestID, ProviderBindingID: fallback.Binding.ID, ProviderBindingRevision: fallback.Binding.Revision, FinishReason: cognitive.FinishInvalidProviderResponse}
+				fallbackResponse = cognitive.AdvisoryResponse{Version: request.Version, RequestID: request.RequestID, ProviderBindingID: fallback.Binding.ID, ProviderBindingRevision: fallback.Binding.Revision, FinishReason: cognitive.FinishProviderUnavailable}
 			}
 			g.observe(r.Context(), fallback, fallbackResponse, fallbackStarted)
 			response = fallbackResponse
@@ -124,6 +130,22 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
 	writeGatewayResponse(w, cognitive.GatewayAdvisoryResponse{Version: response.Version, RequestID: response.RequestID, AdvisoryText: response.AdvisoryText, ReferencedExcerptIDs: response.ReferencedExcerptIDs, FinishReason: response.FinishReason, Usage: response.Usage})
 }
 
+func (g cognitiveGateway) invokeAdmitted(ctx context.Context, leaseID string, provider advisoryProvider, invocation cognitive.AdvisoryRequest, maxOutputBytes int) (cognitive.AdvisoryResponse, error) {
+	var lease capability.AdmissionLease
+	if g.admission != nil {
+		decision, admittedLease, err := g.admission.Admit(ctx, leaseID, capability.AdmissionRequest{InputBytes: len(invocation.Message), MaxOutputBytes: maxOutputBytes, DeadlineMillis: 0})
+		if err != nil {
+			return cognitive.AdvisoryResponse{}, err
+		}
+		if decision.State != capability.AdmissionAdmitted {
+			return cognitive.AdvisoryResponse{Version: invocation.Version, RequestID: invocation.RequestID, ProviderBindingID: invocation.ProviderBindingID, ProviderBindingRevision: invocation.ProviderBindingRevision, FinishReason: cognitive.FinishRateLimited}, nil
+		}
+		lease = admittedLease
+		defer func() { _ = g.admission.Release(ctx, lease) }()
+	}
+	return provider.Advise(ctx, invocation)
+}
+
 func selectionObjectiveForMessage(message string) capability.SelectionObjective {
 	lower := strings.ToLower(message)
 	if strings.Contains(lower, "дешев") || strings.Contains(lower, "бесплат") || strings.Contains(lower, "эконом") || strings.Contains(lower, "cost") || strings.Contains(lower, "cheap") {

cmd/cognitive-worker/main.go

@@ -10,11 +10,14 @@ import (
 	"git.cin.su/m/Assistant/contracts/capability"
 	"git.cin.su/m/Assistant/contracts/cognitive"
 	"git.cin.su/m/Assistant/contracts/identity"
+	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
+	platformsecrets "git.cin.su/m/Assistant/platform/secrets"
 	"git.cin.su/m/Assistant/runtime/health"
 	"io"
 	"log"
 	"net/http"
 	"os"
+	"strings"
 	"time"
 )
 
@@ -42,11 +45,21 @@ func main() {
 	discoveries := map[string]providerRegistration{}
 	var builtinLocal *providerRegistration
 	externalRecovery := []providerRegistration{}
-	cpuAdapter, err := models.NewOpenAICompatibleLocalAdapter(envOr("LOCAL_CPU_PROVIDER_URL", "http://docker.cin.su:18082/v1"), nil)
+	cpuAPIKey, err := loadLocalCPUProviderAPIKey()
 	if err != nil {
 		log.Fatal(err)
 	}
-	cpu := providerRegistration{ProviderInstanceID: "local-cpu-primary", Kind: "openai-compatible-chat-v1", EndpointRef: "local-cpu-primary-v1", AuthMode: capability.AuthNone, BillingMode: capability.BillingFree, DataPolicy: capability.DataPolicyLocalOnly, Provider: cpuAdapter, Discovery: cpuAdapter}
+	cpuAdapter, err := models.NewOpenAICompatibleLocalAdapterWithAPIKey(envOr("LOCAL_CPU_PROVIDER_URL", "http://docker.cin.su:18082/v1"), cpuAPIKey, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	cpuAuthMode := capability.AuthNone
+	cpuCredentialRef := capability.CredentialRef("")
+	if cpuAPIKey != "" {
+		cpuAuthMode = capability.AuthKey
+		cpuCredentialRef = capability.CredentialRef(envOr("LOCAL_CPU_PROVIDER_CREDENTIAL_REF", "credential://domovoy/local-cpu/provider-api-key/v1"))
+	}
+	cpu := providerRegistration{ProviderInstanceID: "local-cpu-primary", Kind: "openai-compatible-chat-v1", EndpointRef: "local-cpu-primary-v1", CredentialRef: cpuCredentialRef, AuthMode: cpuAuthMode, BillingMode: capability.BillingFree, DataPolicy: capability.DataPolicyLocalOnly, Provider: cpuAdapter, Discovery: cpuAdapter}
 	providers[cpu.Kind] = append(providers[cpu.Kind], cpu)
 	discoveries["cpu"] = cpu
 	if lifeboat, enabled, lifeboatErr := newLifeboatProvider(os.Getenv("LOCAL_LIFEBOAT_PROVIDER_URL")); lifeboatErr != nil {
@@ -69,8 +82,24 @@ func main() {
 		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})
 	}
-	gateway := cognitiveGateway{resolver: resolver, providers: providers, builtinLocal: builtinLocal, externalRecovery: externalRecovery, now: time.Now, allowCanary: os.Getenv("COGNITIVE_ALLOW_CANARY") == "true", canaryMaxOutputBytes: 4096}
+	gateway := cognitiveGateway{resolver: resolver, providers: providers, builtinLocal: builtinLocal, externalRecovery: externalRecovery, now: time.Now, allowCanary: os.Getenv("COGNITIVE_ALLOW_CANARY") == "true", canaryMaxOutputBytes: 4096, admission: newHTTPAdmissionClient(envOr("CORE_RUNTIME_URL", "http://core-runtime:8080"), &http.Client{Timeout: 5 * time.Second})}
 	mux.Handle("/healthz", health.Handler{Runtime: "cognitive-worker", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	readinessClient := &http.Client{Timeout: 2 * time.Second}
+	lifeboatURL := strings.TrimSuffix(strings.TrimRight(envOr("LOCAL_LIFEBOAT_PROVIDER_URL", "http://cognitive-lifeboat:8086/v1"), "/"), "/v1") + "/health"
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "cognitive-worker", Probes: []health.Probe{
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("CORE_RUNTIME_URL", "http://core-runtime:8080"), "/")+"/healthz"),
+		health.OptionalHTTPProbe(readinessClient, strings.TrimRight(envOr("LOCAL_CPU_PROVIDER_URL", "http://docker.cin.su:18082/v1"), "/")+"/models"),
+		health.HTTPProbe(readinessClient, lifeboatURL),
+		health.OptionalHTTPProbe(readinessClient, strings.TrimRight(envOr("LOCAL_GPU_PROVIDER_URL", "http://192.168.220.91:11434"), "/")+"/api/tags"),
+	}})
+	fleetClient := &http.Client{Timeout: 2 * time.Second}
+	preferredFleet := capability.FleetTier(envOr("COGNITIVE_PREFERRED_FLEET_TIER", string(capability.FleetTierHeavy)))
+	mux.Handle("/v1/fleet/readiness", fleetReadinessHandler(fleetClient, preferredFleet, []fleetEndpoint{
+		{ProviderID: "local-cpu-primary", ModelID: "local-cpu-model", Tier: capability.FleetTierFast, URL: strings.TrimRight(envOr("LOCAL_CPU_PROVIDER_URL", "http://docker.cin.su:18082/v1"), "/") + "/models"},
+		{ProviderID: "local-medium-unconfigured", ModelID: "medium-unconfigured", Tier: capability.FleetTierMedium},
+		{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},
+	}))
 	mux.HandleFunc("POST /v1/proposals/deterministic", deterministicProposal)
 	mux.HandleFunc("POST /v1/advisory-policy", gateway.policyHandler)
 	mux.HandleFunc("POST /v1/advisories", gateway.advisoryHandler)
@@ -128,6 +157,25 @@ func refreshProviderDiscoveries(resolver bindingResolver, service discoveryServi
 	}
 }
 
+func loadLocalCPUProviderAPIKey() (string, error) {
+	if _, set := os.LookupEnv("LOCAL_CPU_PROVIDER_API_KEY"); set {
+		return "", fmt.Errorf("LOCAL_CPU_PROVIDER_API_KEY direct environment secret is forbidden; use LOCAL_CPU_PROVIDER_API_KEY_FILE")
+	}
+	fileName := strings.TrimSpace(os.Getenv("LOCAL_CPU_PROVIDER_API_KEY_FILE"))
+	if fileName == "" {
+		return "", nil
+	}
+	ref := strings.TrimSpace(os.Getenv("LOCAL_CPU_PROVIDER_CREDENTIAL_REF"))
+	if ref == "" {
+		return "", fmt.Errorf("LOCAL_CPU_PROVIDER_CREDENTIAL_REF is required when LOCAL_CPU_PROVIDER_API_KEY_FILE is configured")
+	}
+	resolver, err := platformsecrets.NewFileResolver(envOr("SECRET_BACKEND_ROOT", "/run/secrets"))
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeProviderAPIKey, Consumer: secretcontracts.RuntimeConsumerCognitive, Path: fileName})
+}
+
 func deterministicAdvisory(w http.ResponseWriter, r *http.Request) {
 	request, ok := decodeAdvisoryRequest(w, r)
 	if !ok {

cmd/cognitive-worker/main_test.go

@@ -1,6 +1,10 @@
 package main
 
-import "testing"
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
 
 func TestLifeboatProviderIsOptionalAndLocalAdapterBacked(t *testing.T) {
 	if _, enabled, err := newLifeboatProvider(""); err != nil || enabled {
@@ -14,3 +18,28 @@ func TestLifeboatProviderIsOptionalAndLocalAdapterBacked(t *testing.T) {
 		t.Fatalf("unexpected lifeboat registration: %+v", provider)
 	}
 }
+
+func TestLoadLocalCPUProviderAPIKeyUsesProtectedFileReference(t *testing.T) {
+	t.Setenv("LOCAL_CPU_PROVIDER_API_KEY", "")
+	_ = os.Unsetenv("LOCAL_CPU_PROVIDER_API_KEY")
+	root := t.TempDir()
+	path := filepath.Join(root, "local_cpu_provider_api_key")
+	if err := os.WriteFile(path, []byte("resolved-key\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("LOCAL_CPU_PROVIDER_API_KEY_FILE", path)
+	t.Setenv("LOCAL_CPU_PROVIDER_CREDENTIAL_REF", "credential://domovoy/local-cpu/provider-api-key/v1")
+	t.Setenv("SECRET_BACKEND_ROOT", root)
+	key, err := loadLocalCPUProviderAPIKey()
+	if err != nil || key != "resolved-key" {
+		t.Fatalf("unexpected key resolution result: err=%v", err)
+	}
+}
+
+func TestLoadLocalCPUProviderAPIKeyRejectsDirectEnvironmentSecret(t *testing.T) {
+	t.Setenv("LOCAL_CPU_PROVIDER_API_KEY", "must-not-be-used")
+	t.Setenv("LOCAL_CPU_PROVIDER_API_KEY_FILE", "")
+	if _, err := loadLocalCPUProviderAPIKey(); err == nil {
+		t.Fatal("expected direct environment secret to be rejected")
+	}
+}

cmd/commit-runtime/main.go

@@ -84,6 +84,13 @@ func main() {
 	dispatcher := operationDispatcher{continuityExecutor: continuityExecutor, continuityReconciler: continuityExecutor, bindings: creatorCore, secretRef: notificationSecretRef, secret: notificationSecret, client: creatorHTTPClient}
 	mux := http.NewServeMux()
 	mux.Handle("/healthz", health.Handler{Runtime: "commit-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	readinessClient := &http.Client{Timeout: 2 * time.Second}
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "commit-runtime", Probes: []health.Probe{
+		health.TCPProbe("commit-postgres", envOr("POSTGRES_HOST", "postgres"), envOr("POSTGRES_PORT", "5432")),
+		health.TCPProbe("authority-postgres", envOr("POSTGRES_HOST", "postgres"), envOr("POSTGRES_PORT", "5432")),
+		health.HTTPProbe(readinessClient, strings.TrimRight(coreURL, "/")+"/healthz"),
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("CONTINUITY_RUNTIME_URL", "http://continuity-runtime:8081"), "/")+"/healthz"),
+	}})
 	registerExecutionRoutes(mux, repository, dispatcher, dispatcher, executorToken)
 	registerCreatorCommandRoutes(mux, creatorCommandHandler{
 		core: creatorCore, continuity: creatorContinuity, authority: authorityRepository, repository: repository,

cmd/continuity-runtime/main.go

@@ -7,6 +7,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"strings"
 	"time"
 
 	"git.cin.su/m/Assistant/adapters/postgres"
@@ -31,6 +32,12 @@ func main() {
 	}
 	mux := http.NewServeMux()
 	mux.Handle("/healthz", health.Handler{Runtime: "continuity-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	readinessClient := &http.Client{Timeout: 2 * time.Second}
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "continuity-runtime", Probes: []health.Probe{
+		health.TCPProbe("postgres", envOr("POSTGRES_HOST", "postgres"), envOr("POSTGRES_PORT", "5432")),
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("CORE_RUNTIME_URL", "http://core-runtime:8080"), "/")+"/healthz"),
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("COMMIT_RUNTIME_URL", "http://commit-runtime:8082"), "/")+"/healthz"),
+	}})
 	executorToken := os.Getenv("COMMIT_EXECUTOR_TOKEN")
 	if executorToken == "" {
 		log.Fatal("COMMIT_EXECUTOR_TOKEN is required")

cmd/core-runtime/main.go

@@ -135,6 +135,40 @@ func main() {
 		return situationdomain.NewResolver(bindings).Resolve(runtime)
 	}
 	mux.Handle("/healthz", health.Handler{Runtime: "core-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	readinessClient := &http.Client{Timeout: 2 * time.Second}
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "core-runtime", Probes: []health.Probe{
+		health.TCPProbe("postgres", envOr("POSTGRES_HOST", "postgres"), envOr("POSTGRES_PORT", "5432")),
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("CONTINUITY_RUNTIME_URL", "http://continuity-runtime:8081"), "/")+"/healthz"),
+		health.HTTPProbe(readinessClient, strings.TrimRight(envOr("COGNITIVE_RUNTIME_URL", "http://cognitive-worker:8083"), "/")+"/healthz"),
+	}})
+	admissionPolicy := capability.AdmissionPolicy{ID: envOr("COGNITIVE_ADMISSION_POLICY_ID", "creator-advisory-local-v1"), MaxConcurrent: envInt("COGNITIVE_ADMISSION_MAX_CONCURRENT", 1), MaxAcceptedPerHour: envInt("COGNITIVE_ADMISSION_MAX_ACCEPTED_PER_HOUR", 60), MaxInputBytes: envInt("COGNITIVE_ADMISSION_MAX_INPUT_BYTES", 80<<10), MaxOutputBytes: envInt("COGNITIVE_ADMISSION_MAX_OUTPUT_BYTES", 16<<10)}
+	mux.HandleFunc("POST /v1/internal/cognitive/admission", func(w http.ResponseWriter, r *http.Request) {
+		var request struct {
+			LeaseID string                      `json:"lease_id"`
+			Request capability.AdmissionRequest `json:"request"`
+		}
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil || request.LeaseID == "" {
+			http.Error(w, "invalid admission request", http.StatusBadRequest)
+			return
+		}
+		decision, lease, err := capabilityRepository.AdmitCognitive(r.Context(), request.LeaseID, admissionPolicy, request.Request, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, "admission unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(struct {
+			Decision capability.AdmissionDecision `json:"decision"`
+			Lease    capability.AdmissionLease    `json:"lease"`
+		}{decision, lease})
+	})
+	mux.HandleFunc("POST /v1/internal/cognitive/admission/{lease}/release", func(w http.ResponseWriter, r *http.Request) {
+		if err := capabilityRepository.ReleaseCognitiveAdmission(r.Context(), capability.AdmissionLease{ID: r.PathValue("lease")}, time.Now().UnixMilli()); err != nil {
+			http.Error(w, "admission release unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		w.WriteHeader(http.StatusNoContent)
+	})
 	mux.HandleFunc("POST /v1/creator/sessions", creatorSessionHandler(bootstrapToken, creatorUsername, creatorPassword, sessionKey, time.Now))
 	mux.HandleFunc("GET /v1/creator/sessions/current", func(w http.ResponseWriter, r *http.Request) {
 		session, ok := authenticateCreator(w, r)
@@ -1153,6 +1187,14 @@ func envOr(name, fallback string) string {
 	return fallback
 }
 
+func envInt(name string, fallback int) int {
+	value, err := strconv.Atoi(os.Getenv(name))
+	if err != nil || value < 1 {
+		return fallback
+	}
+	return value
+}
+
 func humanCognitiveModelInventory(candidates []capability.ResolvedCognitiveBinding, inventoryErr error) string {
 	if inventoryErr != nil {
 		return "Я не смогла прочитать реестр подключённых моделей. Встроенный канал Домового остаётся доступен; настройки можно проверить повторно после восстановления реестра. Ключи и пароли не выводятся в чат."

cmd/creator-web/main.go

@@ -15,6 +15,7 @@ func main() {
 		envOr("COMMIT_RUNTIME_URL", "http://commit-runtime:8082"),
 		&http.Client{Timeout: 10 * time.Second},
 		envOr("COGNITIVE_RUNTIME_URL", "http://cognitive-worker:8083"),
+		envOr("AGENT_WORKER_URL", "http://agent-worker:8090"),
 	)
 	if err != nil {
 		log.Fatal(err)

cmd/creator-web/server.go

@@ -33,13 +33,14 @@ const (
 var staticFiles embed.FS
 
 type gateway struct {
-	core       *url.URL
-	continuity *url.URL
-	commit     *url.URL
-	cognitive  *url.URL
-	client     *http.Client
-	static     http.Handler
-	build      buildMetadata
+	core        *url.URL
+	continuity  *url.URL
+	commit      *url.URL
+	cognitive   *url.URL
+	agentWorker *url.URL
+	client      *http.Client
+	static      http.Handler
+	build       buildMetadata
 }
 
 type buildMetadata struct {
@@ -76,6 +77,14 @@ func newHandler(coreURL, continuityURL, commitURL string, client *http.Client, c
 	if err != nil {
 		return nil, err
 	}
+	agentWorkerURL := "http://agent-worker:8090"
+	if len(cognitiveURLs) > 1 {
+		agentWorkerURL = cognitiveURLs[1]
+	}
+	agentWorker, err := parseRuntimeURL(agentWorkerURL, "Agent worker")
+	if err != nil {
+		return nil, err
+	}
 	assets, err := fs.Sub(staticFiles, "static")
 	if err != nil {
 		return nil, fmt.Errorf("load embedded console: %w", err)
@@ -96,7 +105,7 @@ func newHandler(coreURL, continuityURL, commitURL string, client *http.Client, c
 	if len(revision) > 12 {
 		revision = revision[:12]
 	}
-	return securityHeaders(&gateway{core: core, continuity: continuity, commit: commit, cognitive: cognitiveRuntime, client: client, static: http.FileServer(http.FS(assets)), build: buildMetadata{revision: revision, updated: updated}}), nil
+	return securityHeaders(&gateway{core: core, continuity: continuity, commit: commit, cognitive: cognitiveRuntime, agentWorker: agentWorker, client: client, static: http.FileServer(http.FS(assets)), build: buildMetadata{revision: revision, updated: updated}}), nil
 }
 
 func parseRuntimeURL(rawURL, name string) (*url.URL, error) {
@@ -126,6 +135,14 @@ func (g *gateway) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			g.handleChatMessage(w, r)
 			return
 		}
+		if r.Method == http.MethodGet && r.URL.Path == "/api/fleet/readiness" {
+			g.handleFleetReadiness(w, r)
+			return
+		}
+		if r.Method == http.MethodGet && r.URL.Path == "/api/agent-worker/status" {
+			g.handleAgentWorkerStatus(w, r)
+			return
+		}
 		g.forwardAPI(w, r)
 		return
 	}
@@ -248,6 +265,82 @@ func (g *gateway) handleAdvisoryPolicy(w http.ResponseWriter, r *http.Request) {
 	_ = json.NewEncoder(w).Encode(policy)
 }
 
+func (g *gateway) handleFleetReadiness(w http.ResponseWriter, r *http.Request) {
+	authorization := r.Header.Get("Authorization")
+	if authorization == "" {
+		http.Error(w, "creator session denied", http.StatusUnauthorized)
+		return
+	}
+	var session identity.CreatorSession
+	status, err := g.getTrustedJSON(r, g.core, "/v1/creator/sessions/current", "", authorization, &session)
+	if err != nil {
+		http.Error(w, "creator session unavailable", http.StatusBadGateway)
+		return
+	}
+	if status != http.StatusOK || session.ActorID == "" || session.PrincipalID == "" {
+		if status == 0 {
+			status = http.StatusUnauthorized
+		}
+		http.Error(w, "creator session denied", status)
+		return
+	}
+	target := *g.cognitive
+	target.Path = "/v1/fleet/readiness"
+	request, err := http.NewRequestWithContext(r.Context(), http.MethodGet, target.String(), nil)
+	if err != nil {
+		http.Error(w, "fleet readiness unavailable", http.StatusBadGateway)
+		return
+	}
+	response, err := g.client.Do(request)
+	if err != nil {
+		http.Error(w, "fleet readiness unavailable", http.StatusBadGateway)
+		return
+	}
+	defer response.Body.Close()
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-store")
+	w.WriteHeader(response.StatusCode)
+	_, _ = io.Copy(w, io.LimitReader(response.Body, maxResponseBytes))
+}
+
+func (g *gateway) handleAgentWorkerStatus(w http.ResponseWriter, r *http.Request) {
+	authorization := r.Header.Get("Authorization")
+	if authorization == "" {
+		http.Error(w, "creator session denied", http.StatusUnauthorized)
+		return
+	}
+	var session identity.CreatorSession
+	status, err := g.getTrustedJSON(r, g.core, "/v1/creator/sessions/current", "", authorization, &session)
+	if err != nil {
+		http.Error(w, "creator session unavailable", http.StatusBadGateway)
+		return
+	}
+	if status != http.StatusOK || session.ActorID == "" || session.PrincipalID == "" {
+		if status == 0 {
+			status = http.StatusUnauthorized
+		}
+		http.Error(w, "creator session denied", status)
+		return
+	}
+	target := *g.agentWorker
+	target.Path = "/status"
+	request, err := http.NewRequestWithContext(r.Context(), http.MethodGet, target.String(), nil)
+	if err != nil {
+		http.Error(w, "agent worker status unavailable", http.StatusBadGateway)
+		return
+	}
+	response, err := g.client.Do(request)
+	if err != nil {
+		http.Error(w, "agent worker status unavailable", http.StatusBadGateway)
+		return
+	}
+	defer response.Body.Close()
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-store")
+	w.WriteHeader(response.StatusCode)
+	_, _ = io.Copy(w, io.LimitReader(response.Body, maxResponseBytes))
+}
+
 func (g *gateway) handleAdvisory(w http.ResponseWriter, r *http.Request) {
 	var browserRequest browserAdvisoryRequest
 	if err := decodeStrictJSON(r.Body, maxAdvisoryRequestBytes, &browserRequest); err != nil || browserRequest.Message == "" || len(browserRequest.Message) > 16*1024 || !validID(browserRequest.SessionID) || !validID(browserRequest.WorkspaceID) {
@@ -378,7 +471,7 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
 		cognition = "unavailable"
 		requestID, idErr := ids.New()
 		if idErr == nil {
-			trusted := cognitive.GatewayAdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(requestID), ActorID: session.ActorID, PrincipalID: session.PrincipalID, ScopeID: "domovoy-global-scope", Message: browserRequest.Message, Context: []cognitive.ContextExcerpt{}, Locale: "ru-RU", MaxOutputBytes: 4096, DataPolicy: capability.DataPolicyLocalOnly, EgressAcknowledged: false, Meaning: cognitive.TaskMeaning{SpeechAct: string(saved.SpeechAct), CapabilityKind: saved.CapabilityKind, CapabilityHints: saved.CapabilityHints, RequestedOutcome: saved.RequestedOutcome, InformationRequestKind: saved.InformationRequestKind, ConfidenceMillis: saved.InterpretationConfidenceMillis}}
+			trusted := cognitive.GatewayAdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(requestID), ActorID: session.ActorID, PrincipalID: session.PrincipalID, ScopeID: "domovoy-global-scope", Message: browserRequest.Message, Context: localChatContext(saved), Locale: "ru-RU", MaxOutputBytes: 4096, DataPolicy: capability.DataPolicyLocalOnly, EgressAcknowledged: false, Meaning: cognitive.TaskMeaning{SpeechAct: string(saved.SpeechAct), CapabilityKind: saved.CapabilityKind, CapabilityHints: saved.CapabilityHints, RequestedOutcome: saved.RequestedOutcome, InformationRequestKind: saved.InformationRequestKind, ConfidenceMillis: saved.InterpretationConfidenceMillis}}
 			payload, err = json.Marshal(trusted)
 			if err == nil {
 				var advisory cognitive.GatewayAdvisoryResponse
@@ -415,6 +508,30 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
+func localChatContext(saved interaction.ChatMessageResponse) []cognitive.ContextExcerpt {
+	if strings.TrimSpace(saved.ActiveProjectName) == "" {
+		return []cognitive.ContextExcerpt{}
+	}
+	bundle, err := cognitive.CompileContext(cognitive.ContextCompileInput{
+		DataPolicy: capability.DataPolicyLocalOnly,
+		MaxBytes:   2048,
+		Candidates: []cognitive.ContextCandidate{{
+			Excerpt: cognitive.ContextExcerpt{
+				ID:          cognitive.ContextExcerptID("active-project-focus"),
+				SourceKind:  "situation-active-project",
+				SourceID:    strings.TrimSpace(saved.ActiveProjectName),
+				Sensitivity: cognitive.SensitivityPrivateAllowed,
+				Text:        "Текущий проект: " + strings.TrimSpace(saved.ActiveProjectName),
+			},
+			Relevance: 100,
+		}},
+	})
+	if err != nil {
+		return []cognitive.ContextExcerpt{}
+	}
+	return bundle.Excerpts
+}
+
 func asksAttention(message string) bool {
 	lower := strings.ToLower(message)
 	return strings.Contains(lower, "требует моего внимания") || strings.Contains(lower, "требует внимания") || strings.Contains(lower, "что сейчас важно")
@@ -597,6 +714,16 @@ func creatorRoute(method, path string) (routeTarget, string, bool) {
 		}
 	case method == http.MethodGet && path == "/api/learning/recent":
 		return targetCore, "/v1/creator/learning/recent", true
+	case method == http.MethodGet && strings.HasPrefix(path, "/api/delegations/") && strings.HasSuffix(path, "/latest-checkpoint"):
+		id := strings.TrimSuffix(strings.TrimPrefix(path, "/api/delegations/"), "/latest-checkpoint")
+		if validID(id) {
+			return targetCore, "/v1/creator/delegations/" + id + "/latest-checkpoint", true
+		}
+	case method == http.MethodGet && strings.HasPrefix(path, "/api/delegations/"):
+		id := strings.TrimPrefix(path, "/api/delegations/")
+		if validID(id) {
+			return targetCore, "/v1/creator/delegations/" + id, true
+		}
 	case method == http.MethodGet && strings.HasPrefix(path, "/api/prospective-items/"):
 		id := strings.TrimPrefix(path, "/api/prospective-items/")
 		if validID(id) {

cmd/creator-web/server_test.go

@@ -10,8 +10,105 @@ import (
 	"testing"
 
 	"git.cin.su/m/Assistant/contracts/cognitive"
+	"git.cin.su/m/Assistant/contracts/interaction"
 )
 
+func TestLocalChatContextUsesOnlyActiveProject(t *testing.T) {
+	context := localChatContext(interaction.ChatMessageResponse{ActiveProjectName: "Домовой"})
+	if len(context) != 1 || context[0].SourceKind != "situation-active-project" || context[0].Text != "Текущий проект: Домовой" {
+		t.Fatalf("unexpected local context: %#v", context)
+	}
+	if empty := localChatContext(interaction.ChatMessageResponse{}); len(empty) != 0 {
+		t.Fatalf("expected empty context without active project: %#v", empty)
+	}
+}
+
+func TestCreatorRouteAllowsOnlyBoundedDelegationReads(t *testing.T) {
+	tests := []struct {
+		path string
+		want string
+	}{
+		{"/api/delegations/delegation-1", "/v1/creator/delegations/delegation-1"},
+		{"/api/delegations/delegation-1/latest-checkpoint", "/v1/creator/delegations/delegation-1/latest-checkpoint"},
+	}
+	for _, test := range tests {
+		_, got, ok := creatorRoute(http.MethodGet, test.path)
+		if !ok || got != test.want {
+			t.Fatalf("creatorRoute(%q) = %q, %t; want %q, true", test.path, got, ok, test.want)
+		}
+	}
+	if _, _, ok := creatorRoute(http.MethodGet, "/api/delegations/../secrets"); ok {
+		t.Fatal("path traversal-like delegation route must be denied")
+	}
+}
+
+func TestAgentWorkerStatusProxyRequiresCreatorSession(t *testing.T) {
+	core := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/creator/sessions/current" || r.Header.Get("Authorization") != "Bearer bounded-session" {
+			t.Fatalf("unexpected session request path=%s auth=%q", r.URL.Path, r.Header.Get("Authorization"))
+		}
+		_, _ = io.WriteString(w, `{"ActorID":"creator-actor","PrincipalID":"creator-principal","ExpiresAtUnix":2000000000}`)
+	}))
+	defer core.Close()
+	worker := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/status" {
+			t.Fatalf("unexpected worker path %s", r.URL.Path)
+		}
+		_, _ = io.WriteString(w, `{"runtime":"agent-worker","executor_configured":false,"mode":"recovery-only","ready":false,"reason":"bridge missing"}`)
+	}))
+	defer worker.Close()
+	handler, err := newHandler(core.URL, "http://continuity.invalid", "http://commit.invalid", core.Client(), "http://cognitive.invalid", worker.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	denied := httptest.NewRecorder()
+	handler.ServeHTTP(denied, httptest.NewRequest(http.MethodGet, "/api/agent-worker/status", nil))
+	if denied.Code != http.StatusUnauthorized {
+		t.Fatalf("unauthenticated status=%d", denied.Code)
+	}
+	request := httptest.NewRequest(http.MethodGet, "/api/agent-worker/status", nil)
+	request.Header.Set("Authorization", "Bearer bounded-session")
+	response := httptest.NewRecorder()
+	handler.ServeHTTP(response, request)
+	if response.Code != http.StatusOK || !strings.Contains(response.Body.String(), `"mode":"recovery-only"`) || response.Header().Get("Cache-Control") != "no-store" {
+		t.Fatalf("response=%d cache=%q body=%s", response.Code, response.Header().Get("Cache-Control"), response.Body.String())
+	}
+}
+
+func TestFleetReadinessRequiresCreatorSessionAndProxiesCognitiveState(t *testing.T) {
+	core := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/creator/sessions/current" || r.Header.Get("Authorization") != "Bearer bounded-session" {
+			t.Fatalf("unexpected session request path=%s auth=%q", r.URL.Path, r.Header.Get("Authorization"))
+		}
+		_, _ = io.WriteString(w, `{"ActorID":"creator-actor","PrincipalID":"creator-principal","ExpiresAtUnix":2000000000}`)
+	}))
+	defer core.Close()
+	cognitiveRuntime := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/fleet/readiness" {
+			t.Fatalf("unexpected cognitive path %s", r.URL.Path)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, `{"readiness":{"members":[{"provider_instance_id":"lifeboat","model_descriptor_id":"qwen","tier":"LIFEBOAT","ready":true,"reason":"AVAILABLE"}],"ready_tiers":["LIFEBOAT"],"fallback_tier":"LIFEBOAT"},"preferred_tier":"HEAVY","selected_tier":"LIFEBOAT"}`)
+	}))
+	defer cognitiveRuntime.Close()
+	handler, err := newHandler(core.URL, "http://continuity.invalid", "http://commit.invalid", core.Client(), cognitiveRuntime.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	denied := httptest.NewRecorder()
+	handler.ServeHTTP(denied, httptest.NewRequest(http.MethodGet, "/api/fleet/readiness", nil))
+	if denied.Code != http.StatusUnauthorized {
+		t.Fatalf("unauthenticated status=%d", denied.Code)
+	}
+	request := httptest.NewRequest(http.MethodGet, "/api/fleet/readiness", nil)
+	request.Header.Set("Authorization", "Bearer bounded-session")
+	response := httptest.NewRecorder()
+	handler.ServeHTTP(response, request)
+	if response.Code != http.StatusOK || !strings.Contains(response.Body.String(), `"selected_tier":"LIFEBOAT"`) || response.Header().Get("Cache-Control") != "no-store" {
+		t.Fatalf("response=%d cache=%q body=%s", response.Code, response.Header().Get("Cache-Control"), response.Body.String())
+	}
+}
+
 const legacyExternalMode = "legacy-external-test-mode"
 
 func newHandlerWithAdvisoryMode(coreURL, continuityURL, commitURL string, client *http.Client, mode string, cognitiveURLs ...string) (http.Handler, error) {

cmd/creator-web/static/assets/console.css

@@ -253,6 +253,40 @@ html[data-reduced-motion="true"] *, html[data-reduced-motion="true"] *::before,
 .activity-reconcile:disabled { opacity: .55; cursor: wait; }
 .activity-error { color: var(--bad); }
 
+.fleet-panel { margin-bottom: 18px; border: 1px solid rgba(201,168,95,.32); background: linear-gradient(135deg, rgba(31,27,18,.92), rgba(13,20,17,.96)); box-shadow: inset 3px 0 0 rgba(201,168,95,.45); }
+.fleet-panel > header { min-height: 66px; padding: 13px 18px; display: flex; align-items: center; justify-content: space-between; gap: 18px; border-bottom: 1px solid var(--line); }
+.fleet-panel header p { margin: 0 0 6px; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .13em; text-transform: uppercase; }
+.fleet-panel h2 { margin: 0; font: 400 22px/1 var(--serif); }
+.fleet-overview { padding: 16px 18px; display: flex; align-items: end; justify-content: space-between; gap: 18px; border-bottom: 1px solid var(--line-soft); }
+.fleet-overview span { display: block; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .1em; text-transform: uppercase; }
+.fleet-overview strong { display: block; margin-top: 6px; color: var(--signal); font: 600 16px/1 var(--mono); }
+.fleet-overview p { max-width: 620px; margin: 0; color: var(--muted); font: 10px/1.45 var(--mono); }
+.fleet-list { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+.fleet-list[aria-busy="true"] { opacity: .72; }
+.fleet-row { min-width: 0; padding: 14px 18px; display: grid; gap: 7px; border-right: 1px solid var(--line-soft); }
+.fleet-row:last-child { border-right: 0; }
+.fleet-row strong, .fleet-row span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.fleet-row strong { color: var(--ink); font: 600 11px/1.3 var(--mono); }
+.fleet-row span { color: var(--muted); font: 9px/1.4 var(--mono); }
+.fleet-row .learning-state[data-state="READY"] { color: var(--good); }
+.fleet-row .learning-state[data-state="DEGRADED"] { color: var(--warn); }
+
+.agent-panel { margin-bottom: 18px; border: 1px solid rgba(120,198,163,.3); background: rgba(13,20,17,.92); box-shadow: inset 3px 0 0 rgba(120,198,163,.38); }
+.agent-panel > header { min-height: 66px; padding: 13px 18px; display: flex; align-items: center; justify-content: space-between; gap: 18px; border-bottom: 1px solid var(--line); }
+.agent-panel header p { margin: 0 0 6px; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .13em; text-transform: uppercase; }
+.agent-panel h2 { margin: 0; font: 400 22px/1 var(--serif); }
+.agent-empty { padding: 20px 18px; color: var(--muted); font: 10px/1.5 var(--mono); }
+.agent-details { padding: 16px 18px; display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 18px; }
+.agent-details div { min-width: 0; }
+.agent-details span { display: block; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .1em; text-transform: uppercase; }
+.agent-details strong { display: block; margin-top: 7px; overflow: hidden; color: var(--ink); font: 600 10px/1.4 var(--mono); text-overflow: ellipsis; white-space: nowrap; }
+.agent-details p { grid-column: 1 / -1; margin: 0; padding-top: 12px; border-top: 1px solid var(--line-soft); color: var(--muted); font: 10px/1.5 var(--mono); }
+.agent-worker-status { margin: 0 18px 16px; padding-top: 13px; display: grid; grid-template-columns: auto 1fr; gap: 6px 14px; border-top: 1px solid var(--line-soft); }
+.agent-worker-status span { color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .1em; text-transform: uppercase; }
+.agent-worker-status strong { color: var(--warn); font: 600 10px/1.3 var(--mono); }
+.agent-worker-status strong[data-state="ready"] { color: var(--good); }
+.agent-worker-status p { grid-column: 1 / -1; margin: 0; color: var(--muted); font: 10px/1.45 var(--mono); }
+
 .learning-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); }
 .learning-grid article { min-width: 0; border-right: 1px solid var(--line-soft); }
 .learning-grid article:last-child { border-right: 0; }
@@ -404,6 +438,12 @@ html[data-reduced-motion="true"] *, html[data-reduced-motion="true"] *::before,
 	.learning-grid { grid-template-columns: 1fr; }
 	.learning-grid article { border-right: 0; border-bottom: 1px solid var(--line-soft); }
 	.learning-grid article:last-child { border-bottom: 0; }
+	.fleet-overview { align-items: flex-start; flex-direction: column; }
+	.fleet-list { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+	.fleet-row:nth-child(2n) { border-right: 0; }
+	.fleet-row { border-bottom: 1px solid var(--line-soft); }
+	.agent-details { grid-template-columns: 1fr; gap: 14px; }
+	.agent-details p { grid-column: auto; }
 	.activity-row { padding: 14px 16px; grid-template-columns: minmax(0, 1fr) auto; gap: 8px 12px; }
 	.activity-state { grid-column: 2; grid-row: 1; }
 	.activity-operation { grid-column: 1; grid-row: 1; }

cmd/creator-web/static/assets/console.js

@@ -6,7 +6,7 @@ const contextForm = byId("context-form");
 const advisoryForm = byId("advisory-form");
 const loginError = byId("login-error");
 const toast = byId("toast");
-const contextFields = ["session-id", "workspace-id", "task-id", "prospective-id", "capability-id"];
+const contextFields = ["session-id", "workspace-id", "task-id", "prospective-id", "capability-id", "delegation-id"];
 const settingsStorageKey = "domovoy.creator.settings";
 const contextPresetsStorageKey = "domovoy.creator.context.presets";
 let sessionToken = sessionStorage.getItem("domovoy.creator.session") || "";
@@ -172,6 +172,9 @@ async function showConsole() {
   else {
     loadActionHistory();
     loadLearning();
+    loadFleetReadiness();
+    loadAgentDelegation();
+    loadAgentWorkerStatus();
   }
   runDiagnostics();
 }
@@ -353,6 +356,8 @@ byId("reset-settings").addEventListener("click", () => {
 byId("refresh-all").addEventListener("click", loadDashboard);
 byId("refresh-actions").addEventListener("click", loadActionHistory);
 byId("refresh-learning").addEventListener("click", loadLearning);
+byId("refresh-fleet").addEventListener("click", loadFleetReadiness);
+byId("refresh-agent").addEventListener("click", loadAgentDelegation);
 byId("logout").addEventListener("click", () => endSession());
 byId("run-diagnostics").addEventListener("click", runDiagnostics);
 
@@ -442,6 +447,9 @@ async function loadDashboard() {
   work.push(loadProspectiveRegister(context["prospective-id"]));
   work.push(loadActionHistory());
   work.push(loadLearning());
+  work.push(loadFleetReadiness());
+  work.push(loadAgentDelegation());
+  work.push(loadAgentWorkerStatus());
   if (context["capability-id"]) work.push(loadCapability(context["capability-id"]));
   else setSignal("capability", "не выбрана", "idle");
 
@@ -500,6 +508,93 @@ function createDiagnosticItem(label, key, state, detail = "Проверяю…")
   return item;
 }
 
+async function loadFleetReadiness() {
+  const list = byId("fleet-list");
+  list.setAttribute("aria-busy", "true");
+  list.replaceChildren();
+  const loading = document.createElement("p");
+  loading.className = "register-empty";
+  loading.textContent = "Проверяю доступность model fleet…";
+  list.append(loading);
+  try {
+    const result = await request("/api/fleet/readiness");
+    const readiness = result.readiness || {};
+    const members = Array.isArray(readiness.members) ? readiness.members : [];
+    setText("fleet-selected", result.selected_tier || "не выбран");
+    setText("fleet-summary", `${members.filter((member) => member.ready).length}/${members.length} ГОТОВЫ`);
+    setText("fleet-explanation", result.selected_tier ? `Активный маршрут: ${result.selected_tier}. Остальные tier остаются видимыми с их фактической причиной.` : "Ни один tier не выбран: проверьте конфигурацию и health провайдеров.");
+    list.replaceChildren(...members.map(createFleetRow));
+  } catch (error) {
+    setText("fleet-selected", "недоступен");
+    setText("fleet-summary", "ОШИБКА");
+    setText("fleet-explanation", safeClientError(error));
+    const failed = document.createElement("p");
+    failed.className = "register-empty activity-error";
+    failed.textContent = safeClientError(error);
+    list.replaceChildren(failed);
+  } finally {
+    list.setAttribute("aria-busy", "false");
+  }
+}
+
+function createFleetRow(member) {
+  const row = document.createElement("article");
+  row.className = "fleet-row";
+  const state = document.createElement("em");
+  state.className = "learning-state";
+  state.dataset.state = member.ready ? "READY" : "DEGRADED";
+  state.textContent = member.ready ? "READY" : "DEGRADED";
+  const title = document.createElement("strong");
+  title.textContent = member.tier || "UNKNOWN TIER";
+  const detail = document.createElement("span");
+  detail.textContent = `${member.model_descriptor_id || "model"} · ${member.reason || "причина не указана"}`;
+  row.append(state, title, detail);
+  return row;
+}
+
+async function loadAgentDelegation() {
+  const delegationID = byId("delegation-id").value.trim();
+  const empty = byId("agent-empty");
+  const details = byId("agent-details");
+  if (!delegationID) {
+    empty.hidden = false;
+    details.hidden = true;
+    setText("agent-summary", "DELEGATION НЕ ВЫБРАНА");
+    return;
+  }
+  empty.hidden = false;
+  empty.textContent = "Читаю durable delegation…";
+  details.hidden = true;
+  try {
+    const delegation = await request(`/api/delegations/${encodeURIComponent(delegationID)}`);
+    const checkpoint = await request(`/api/delegations/${encodeURIComponent(delegationID)}/latest-checkpoint`).catch(() => ({}));
+    setText("agent-summary", delegation.State || "СОСТОЯНИЕ НЕИЗВЕСТНО");
+    setText("agent-delegation-state", delegation.State);
+    setText("agent-run-state", `${delegation.LatestRunID || "run не выбран"} · ${delegation.SelectedImplementationID || "implementation не указана"}`);
+    setText("agent-blocker", checkpoint.BlockerClass || "нет checkpoint");
+    setText("agent-next-step", checkpoint.NextStep || checkpoint.RemainingSummary || delegation.DesiredOutcome || "Следующий шаг не записан.");
+    empty.hidden = true;
+    details.hidden = false;
+  } catch (error) {
+    setText("agent-summary", "ОШИБКА");
+    empty.textContent = safeClientError(error);
+    empty.hidden = false;
+  }
+}
+
+async function loadAgentWorkerStatus() {
+  try {
+    const status = await request("/api/agent-worker/status");
+    setText("agent-worker-state", status.mode || "UNKNOWN");
+    setText("agent-worker-message", status.reason || "Причина не указана.");
+    byId("agent-worker-state").dataset.state = status.ready === true ? "ready" : "degraded";
+  } catch (error) {
+    setText("agent-worker-state", "НЕДОСТУПЕН");
+    setText("agent-worker-message", safeClientError(error));
+    byId("agent-worker-state").dataset.state = "degraded";
+  }
+}
+
 async function loadLearning() {
   const experienceList = byId("experience-list");
   const reflectionList = byId("reflection-list");

cmd/creator-web/static/index.html

@@ -94,6 +94,8 @@
             <input id="prospective-id" autocomplete="off" placeholder="prospective-item-id">
             <label for="capability-id">Возможность</label>
             <input id="capability-id" autocomplete="off" value="cognitive-proposal">
+            <label for="delegation-id">Delegation / агентская работа</label>
+            <input id="delegation-id" autocomplete="off" placeholder="delegation-id из чата">
           </div>
         </details>
         <div class="context-actions"><button class="secondary-button" type="submit">Загрузить контекст</button><button id="reset-context" class="text-button" type="button">Сбросить</button></div>
@@ -181,6 +183,30 @@
         </div>
       </section>
 
+      <section class="fleet-panel" aria-labelledby="fleet-title" data-page="operations">
+        <header>
+          <div><p>Cognitive / capability health</p><h2 id="fleet-title">Модели и fallback</h2></div>
+          <div class="activity-tools"><span id="fleet-summary">СОСТОЯНИЕ НЕ ЗАГРУЖЕНО</span><button id="refresh-fleet" class="icon-button" type="button" aria-label="Обновить состояние моделей" title="Обновить состояние моделей">↻</button></div>
+        </header>
+        <div class="fleet-overview"><div><span>Выбранный tier</span><strong id="fleet-selected">—</strong></div><p id="fleet-explanation">Проверка доступности провайдеров ещё не выполнялась.</p></div>
+        <div id="fleet-list" class="fleet-list" aria-live="polite" aria-busy="false"><p class="register-empty">Состояние fleet ещё не загружено.</p></div>
+      </section>
+
+      <section class="agent-panel" aria-labelledby="agent-title" data-page="operations">
+        <header>
+          <div><p>Work / durable execution</p><h2 id="agent-title">Агентская работа</h2></div>
+          <div class="activity-tools"><span id="agent-summary">DELEGATION НЕ ВЫБРАНА</span><button id="refresh-agent" class="icon-button" type="button" aria-label="Обновить агентскую работу" title="Обновить агентскую работу">↻</button></div>
+        </header>
+        <div id="agent-empty" class="agent-empty">Укажите delegation ID в расширенных идентификаторах, чтобы прочитать durable state.</div>
+        <div id="agent-details" class="agent-details" hidden>
+          <div><span>Состояние delegation</span><strong id="agent-delegation-state">—</strong></div>
+          <div><span>Run / implementation</span><strong id="agent-run-state">—</strong></div>
+          <div><span>Последний blocker</span><strong id="agent-blocker">—</strong></div>
+          <p id="agent-next-step">—</p>
+        </div>
+        <div class="agent-worker-status"><span>Executor capability</span><strong id="agent-worker-state">ПРОВЕРКА НЕ ВЫПОЛНЯЛАСЬ</strong><p id="agent-worker-message">Статус worker виден только в авторизованной диагностике.</p></div>
+      </section>
+
       <section class="activity-panel" aria-labelledby="activity-title" data-page="operations">
         <header>
           <div><p>Commit / владелец</p><h2 id="activity-title">Журнал действий</h2></div>

cmd/devctl/diff_scope.go

@@ -166,7 +166,7 @@ func loadSelectedTask(root string, selection taskSelection) (TaskPacket, string,
 
 func loadTaskPacket(root, taskPath string) (TaskPacket, error) {
 	var taskPacket TaskPacket
-	if err := decodeJSONFile(filepath.Join(root, filepath.FromSlash(taskPath)), &taskPacket, false); err != nil {
+	if err := decodeJSONFile(filepath.Join(root, filepath.FromSlash(taskPath)), &taskPacket, true); err != nil {
 		return TaskPacket{}, fmt.Errorf("task packet: %w", err)
 	}
 	return taskPacket, nil

cmd/devctl/independent/main.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+var required = []string{
+	"task_id", "task_revision", "architecture_revision", "base_repo_revision", "risk_tier", "intent",
+	"requirement_ids", "allowed_change_scope", "forbidden_change_scope", "allowed_architecture_delta",
+	"contracts", "semantic_owner", "canonical_state", "state_transitions", "side_effects_and_privileges",
+	"persistence_and_migrations", "failure_retry_restart", "assumptions", "acceptance_scenarios",
+	"required_tests", "terminal_gap_states",
+}
+
+func main() {
+	activePath := filepath.FromSlash("dev/ACTIVE_TASK.json")
+	var active struct {
+		TaskFile     string `json:"task_file"`
+		TaskID       string `json:"task_id"`
+		TaskRevision int    `json:"task_revision"`
+	}
+	if err := decode(activePath, &active); err != nil {
+		fail("active pointer: %v", err)
+	}
+	if active.TaskFile == "" || active.TaskID == "" || active.TaskRevision < 1 {
+		fail("active pointer is incomplete")
+	}
+	var raw map[string]json.RawMessage
+	if err := decode(filepath.FromSlash(active.TaskFile), &raw); err != nil {
+		fail("task packet: %v", err)
+	}
+	for _, key := range required {
+		if _, ok := raw[key]; !ok {
+			fail("task packet missing required field %q", key)
+		}
+	}
+	var packet struct {
+		TaskID       string `json:"task_id"`
+		TaskRevision int    `json:"task_revision"`
+	}
+	if err := decode(filepath.FromSlash(active.TaskFile), &packet); err != nil {
+		fail("task identity: %v", err)
+	}
+	if packet.TaskID != active.TaskID || packet.TaskRevision != active.TaskRevision {
+		fail("active pointer and packet identity differ")
+	}
+	fmt.Printf("independent governance verification: OK task=%s revision=%d\n", packet.TaskID, packet.TaskRevision)
+}
+
+func decode(path string, target any) error {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, target)
+}
+
+func fail(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, "independent verifier: "+format+"\n", args...)
+	os.Exit(1)
+}

cmd/devctl/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"go/parser"
 	"go/token"
@@ -24,19 +23,41 @@ type Registry struct {
 		BoundaryClass  string   `json:"boundary_class"`
 		MayDependOn    []string `json:"may_depend_on"`
 		Forbidden      []string `json:"forbidden"`
+		Privileged     bool     `json:"privileged"`
 	} `json:"modules"`
 	ProtectedPaths []string `json:"protected_paths"`
 }
 
 type TaskPacket struct {
-	TaskID             string `json:"task_id"`
-	TaskRevision       int    `json:"task_revision"`
-	BaseRepoRevision   string `json:"base_repo_revision"`
-	RiskTier           string `json:"risk_tier"`
-	Intent             string `json:"intent"`
-	AllowedChangeScope struct {
-		Paths []string `json:"paths"`
+	TaskID               string   `json:"task_id"`
+	TaskRevision         int      `json:"task_revision"`
+	ArchitectureRevision string   `json:"architecture_revision"`
+	BaseRepoRevision     string   `json:"base_repo_revision"`
+	RiskTier             string   `json:"risk_tier"`
+	Intent               string   `json:"intent"`
+	RequirementIDs       []string `json:"requirement_ids"`
+	AllowedChangeScope   struct {
+		Modules []string `json:"modules"`
+		Paths   []string `json:"paths"`
 	} `json:"allowed_change_scope"`
+	ForbiddenChangeScope struct {
+		Paths []string `json:"paths"`
+	} `json:"forbidden_change_scope"`
+	AllowedArchitectureDelta map[string]int `json:"allowed_architecture_delta"`
+	Contracts                struct {
+		Consume   []string `json:"consume"`
+		MayChange []string `json:"may_change"`
+	} `json:"contracts"`
+	SemanticOwner            string   `json:"semantic_owner"`
+	CanonicalState           []string `json:"canonical_state"`
+	StateTransitions         []string `json:"state_transitions"`
+	SideEffectsAndPrivileges []string `json:"side_effects_and_privileges"`
+	PersistenceAndMigrations []string `json:"persistence_and_migrations"`
+	FailureRetryRestart      []string `json:"failure_retry_restart"`
+	Assumptions              []string `json:"assumptions"`
+	AcceptanceScenarios      []string `json:"acceptance_scenarios"`
+	RequiredTests            []string `json:"required_tests"`
+	TerminalGapStates        []string `json:"terminal_gap_states"`
 }
 
 func main() {
@@ -207,12 +228,12 @@ func preflight(args []string) error {
 	if err != nil {
 		return err
 	}
-	taskPacket, _, _, err := loadSelectedTask(root, selection)
+	taskPacket, taskPath, _, err := loadSelectedTask(root, selection)
 	if err != nil {
 		return err
 	}
-	if taskPacket.TaskID == "" || taskPacket.Intent == "" || taskPacket.RiskTier == "" {
-		return errors.New("task packet missing task_id, intent, or risk_tier")
+	if err := validateTaskPacket(root, taskPacket, taskPath); err != nil {
+		return err
 	}
 	registry, err := loadRegistry()
 	if err != nil {

cmd/devctl/task_validation.go

@@ -0,0 +1,215 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var requiredPacketKeys = []string{
+	"task_id", "task_revision", "architecture_revision", "base_repo_revision", "risk_tier", "intent",
+	"requirement_ids", "allowed_change_scope", "forbidden_change_scope", "allowed_architecture_delta",
+	"contracts", "semantic_owner", "canonical_state", "state_transitions", "side_effects_and_privileges",
+	"persistence_and_migrations", "failure_retry_restart", "assumptions", "acceptance_scenarios",
+	"required_tests", "terminal_gap_states",
+}
+
+var requiredDeltaKeys = []string{
+	"new_cross_module_dependencies", "new_canonical_owners", "new_privileges",
+	"new_third_party_dependencies", "new_database_owner_roles",
+}
+
+func validateTaskPacket(root string, task TaskPacket, taskPath string) error {
+	if task.TaskID == "" || task.TaskRevision < 1 || task.ArchitectureRevision == "" || task.BaseRepoRevision == "" || task.RiskTier == "" || task.Intent == "" {
+		return fmt.Errorf("task %s is incomplete: identity, revision, architecture_revision, base_repo_revision, risk_tier and intent are required", task.TaskID)
+	}
+	if taskPath == "" || !matchesAny(taskPath, mustCompile([]string{"dev/tasks/*.json"})) {
+		return fmt.Errorf("task %s must be selected from dev/tasks", task.TaskID)
+	}
+	if task.RiskTier < "A" || task.RiskTier > "E" {
+		return fmt.Errorf("task %s has invalid risk_tier %q", task.TaskID, task.RiskTier)
+	}
+	if len(task.RequirementIDs) == 0 || len(task.AcceptanceScenarios) == 0 || len(task.RequiredTests) == 0 || len(task.TerminalGapStates) == 0 {
+		return fmt.Errorf("task %s must declare requirements, acceptance_scenarios, required_tests and terminal_gap_states", task.TaskID)
+	}
+	if len(task.AllowedChangeScope.Paths) == 0 {
+		return fmt.Errorf("task %s must declare allowed_change_scope.paths", task.TaskID)
+	}
+	if err := validateScopeOverlap(task.AllowedChangeScope.Paths, task.ForbiddenChangeScope.Paths); err != nil {
+		return fmt.Errorf("task %s scope: %w", task.TaskID, err)
+	}
+	if err := validateDelta(task.AllowedArchitectureDelta); err != nil {
+		return fmt.Errorf("task %s architecture delta: %w", task.TaskID, err)
+	}
+	if err := validateRequiredTests(task.RequiredTests); err != nil {
+		return fmt.Errorf("task %s required_tests: %w", task.TaskID, err)
+	}
+	if err := validateArchitectureRevision(root, task.ArchitectureRevision); err != nil {
+		return fmt.Errorf("task %s architecture_revision: %w", task.TaskID, err)
+	}
+	if _, err := resolveBaseCommit(root, task.BaseRepoRevision); err != nil {
+		return fmt.Errorf("task %s base_repo_revision: %w", task.TaskID, err)
+	}
+	if err := validateObservedDelta(root, task); err != nil {
+		return fmt.Errorf("task %s observed architecture delta: %w", task.TaskID, err)
+	}
+	return nil
+}
+
+func validateRequiredTests(tests []string) error {
+	joined := strings.Join(tests, "\n")
+	for _, required := range []string{"go test", "go vet", "preflight", "check-diff", "git diff --check", "independent"} {
+		if !strings.Contains(joined, required) {
+			return fmt.Errorf("missing required governance evidence %q", required)
+		}
+	}
+	return nil
+}
+
+func validateObservedDelta(root string, task TaskPacket) error {
+	changed, err := changedPaths(root, task.BaseRepoRevision)
+	if err != nil {
+		return err
+	}
+	if err := validateRegistryDelta(root, task); err != nil {
+		return err
+	}
+	for _, changedPath := range changed {
+		if (strings.HasPrefix(changedPath, "security/") || strings.HasPrefix(changedPath, "deploy/")) && task.AllowedArchitectureDelta["new_privileges"] == 0 {
+			return fmt.Errorf("privileged surface changed with new_privileges=0: %s", changedPath)
+		}
+		if strings.HasPrefix(changedPath, "database/") && task.AllowedArchitectureDelta["new_database_owner_roles"] == 0 {
+			return fmt.Errorf("database surface changed with new_database_owner_roles=0: %s", changedPath)
+		}
+		if (changedPath == "go.mod" || changedPath == "go.sum") && task.AllowedArchitectureDelta["new_third_party_dependencies"] == 0 {
+			return fmt.Errorf("dependency manifest changed with new_third_party_dependencies=0: %s", changedPath)
+		}
+		if strings.HasPrefix(changedPath, "contracts/") && len(task.Contracts.MayChange) == 0 {
+			return fmt.Errorf("contract surface changed but contracts.may_change is empty: %s", changedPath)
+		}
+	}
+	return nil
+}
+
+func validateRegistryDelta(root string, task TaskPacket) error {
+	baseBytes, err := runGit(root, "show", task.BaseRepoRevision+":architecture/architecture-registry.json")
+	if err != nil {
+		return fmt.Errorf("read base architecture registry: %w", err)
+	}
+	currentBytes, err := os.ReadFile(filepath.Join(root, "architecture", "architecture-registry.json"))
+	if err != nil {
+		return err
+	}
+	var base, current Registry
+	if err := json.Unmarshal(baseBytes, &base); err != nil {
+		return fmt.Errorf("parse base architecture registry: %w", err)
+	}
+	if err := json.Unmarshal(currentBytes, &current); err != nil {
+		return fmt.Errorf("parse current architecture registry: %w", err)
+	}
+	if task.AllowedArchitectureDelta["new_canonical_owners"] == 0 {
+		for name := range current.Modules {
+			if _, ok := base.Modules[name]; !ok {
+				return fmt.Errorf("new canonical module owner %q with new_canonical_owners=0", name)
+			}
+		}
+	}
+	if task.AllowedArchitectureDelta["new_cross_module_dependencies"] == 0 {
+		for name, module := range current.Modules {
+			previous, ok := base.Modules[name]
+			if !ok {
+				continue
+			}
+			old := map[string]bool{}
+			for _, dep := range previous.MayDependOn {
+				old[dep] = true
+			}
+			for _, dep := range module.MayDependOn {
+				if !old[dep] {
+					return fmt.Errorf("new dependency %q in module %q with new_cross_module_dependencies=0", dep, name)
+				}
+			}
+		}
+	}
+	if task.AllowedArchitectureDelta["new_privileges"] == 0 {
+		for name, module := range current.Modules {
+			if previous, ok := base.Modules[name]; ok && module.Privileged && !previous.Privileged {
+				return fmt.Errorf("new privilege in module %q with new_privileges=0", name)
+			}
+		}
+	}
+	return nil
+}
+
+func validateDelta(delta map[string]int) error {
+	if len(delta) != len(requiredDeltaKeys) {
+		return fmt.Errorf("must contain exactly %s", strings.Join(requiredDeltaKeys, ", "))
+	}
+	for _, key := range requiredDeltaKeys {
+		value, ok := delta[key]
+		if !ok || value < 0 {
+			return fmt.Errorf("%s must be a non-negative integer", key)
+		}
+	}
+	return nil
+}
+
+func validateArchitectureRevision(root, revision string) error {
+	if strings.HasPrefix(revision, "ADR-") {
+		matches, err := filepath.Glob(filepath.Join(root, "architecture", "adrs", revision+"-*.md"))
+		if err != nil || len(matches) != 1 {
+			return fmt.Errorf("accepted ADR %q is missing or ambiguous", revision)
+		}
+		return nil
+	}
+	if strings.HasPrefix(revision, "ARCH-") {
+		matches, err := filepath.Glob(filepath.Join(root, "dev", "tasks", revision+"*.json"))
+		if err != nil || len(matches) == 0 {
+			return fmt.Errorf("architecture task %q is missing", revision)
+		}
+		return nil
+	}
+	return fmt.Errorf("must reference an accepted ADR-NNNN or architecture task")
+}
+
+func validateScopeOverlap(allowed, forbidden []string) error {
+	allowedPatterns, err := compileScopePatterns(allowed)
+	if err != nil {
+		return err
+	}
+	forbiddenPatterns, err := compileScopePatterns(forbidden)
+	if err != nil {
+		return fmt.Errorf("forbidden_change_scope: %w", err)
+	}
+	for _, a := range allowedPatterns {
+		for _, f := range forbiddenPatterns {
+			if scopePatternsOverlap(a, f) {
+				return fmt.Errorf("allowed path %q overlaps forbidden path %q", a.raw, f.raw)
+			}
+		}
+	}
+	return nil
+}
+
+func scopePatternsOverlap(a, b scopePattern) bool {
+	if a.subtree != "" && b.subtree != "" {
+		return a.subtree == b.subtree || strings.HasPrefix(a.subtree, b.subtree+"/") || strings.HasPrefix(b.subtree, a.subtree+"/")
+	}
+	if a.subtree != "" {
+		return b.raw == a.subtree || strings.HasPrefix(b.raw, a.subtree+"/")
+	}
+	if b.subtree != "" {
+		return a.raw == b.subtree || strings.HasPrefix(a.raw, b.subtree+"/")
+	}
+	return a.raw == b.raw
+}
+
+func mustCompile(values []string) []scopePattern {
+	patterns, err := compileScopePatterns(values)
+	if err != nil {
+		panic(err)
+	}
+	return patterns
+}

cmd/devctl/task_validation_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateScopeOverlapRejectsAllowedForbiddenConflict(t *testing.T) {
+	err := validateScopeOverlap([]string{"cmd/creator-web/server.go"}, []string{"cmd/creator-web/**"})
+	if err == nil || !strings.Contains(err.Error(), "overlaps forbidden") {
+		t.Fatalf("overlap error = %v", err)
+	}
+}
+
+func TestValidateRequiredTestsRejectsIncompleteEvidence(t *testing.T) {
+	err := validateRequiredTests([]string{"go test ./..."})
+	if err == nil || !strings.Contains(err.Error(), "missing required governance evidence") {
+		t.Fatalf("required test error = %v", err)
+	}
+}
+
+func TestValidateDeltaRejectsUnknownOrMissingFields(t *testing.T) {
+	err := validateDelta(map[string]int{"new_privileges": 0})
+	if err == nil || !strings.Contains(err.Error(), "exactly") {
+		t.Fatalf("delta error = %v", err)
+	}
+}

cmd/reflection-worker/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"time"
+
+	"git.cin.su/m/Assistant/adapters/postgres"
+	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
+	platformsecrets "git.cin.su/m/Assistant/platform/secrets"
+)
+
+func main() {
+	workerID := flag.String("worker-id", "reflection-worker-1", "stable worker identity")
+	lease := flag.Duration("lease-ttl", 5*time.Minute, "candidate claim lease")
+	pollInterval := flag.Duration("poll-interval", 15*time.Second, "database-owned idle wake-up interval")
+	once := flag.Bool("once", false, "run one cycle and exit")
+	flag.Parse()
+	ctx := context.Background()
+	password, err := resolveDatabasePassword("EPISTEMICS_POSTGRES_PASSWORD", "EPISTEMICS_POSTGRES_CREDENTIAL_REF")
+	if err != nil {
+		panic(err)
+	}
+	config := postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: os.Getenv("EPISTEMICS_POSTGRES_USER"), Password: password}
+	repository, err := postgres.OpenEpistemics(ctx, config)
+	if err != nil {
+		panic(err)
+	}
+	defer repository.Close()
+	for {
+		now := time.Now().UnixMilli()
+		if _, err := repository.RecoverReflectionClaims(ctx, now); err != nil {
+			panic(err)
+		}
+		candidate, claimErr := repository.ClaimReflectionCandidate(ctx, *workerID, now, lease.Milliseconds())
+		if claimErr == nil {
+			// This worker only closes the durable evaluation loop. Any cognitive
+			// proposal remains a candidate and must be admitted by a separate governed flow.
+			if err := repository.ResolveReflectionCandidate(ctx, candidate.ID, *workerID, time.Now().UnixMilli()); err != nil {
+				panic(err)
+			}
+			fmt.Printf("resolved reflection candidate %s\n", candidate.ID)
+		} else if *once {
+			fmt.Println("no reflection candidate")
+		}
+		if *once {
+			return
+		}
+		if err := repository.WaitForReflectionCandidate(ctx, *pollInterval); err != nil {
+			panic(err)
+		}
+	}
+}
+
+func resolveDatabasePassword(name, refName string) (string, error) {
+	if _, ok := os.LookupEnv(name); ok {
+		return "", fmt.Errorf("%s direct environment secret is forbidden", name)
+	}
+	path, ref := os.Getenv(name+"_FILE"), os.Getenv(refName)
+	if path == "" || ref == "" {
+		return "", fmt.Errorf("%s_FILE and %s are required", name, refName)
+	}
+	root := os.Getenv("SECRET_BACKEND_ROOT")
+	if root == "" {
+		root = "/run/secrets"
+	}
+	resolver, err := platformsecrets.NewFileResolver(root)
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeDatabasePassword, Consumer: secretcontracts.RuntimeConsumerEpistemicsWorker, Path: path})
+}

cmd/research-runtime/main.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"git.cin.su/m/Assistant/adapters/postgres"
+	researchadapter "git.cin.su/m/Assistant/adapters/research"
+	"git.cin.su/m/Assistant/contracts/epistemics"
+	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
+	"git.cin.su/m/Assistant/modules/epistemics/application"
+	"git.cin.su/m/Assistant/platform/secrets"
+	"git.cin.su/m/Assistant/runtime/health"
+)
+
+func main() {
+	ctx := context.Background()
+	password, err := resolveDatabasePassword()
+	if err != nil {
+		log.Fatal(err)
+	}
+	repository, err := postgres.OpenEpistemics(ctx, postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: os.Getenv("EPISTEMICS_POSTGRES_USER"), Password: password})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer repository.Close()
+
+	mux := http.NewServeMux()
+	mux.Handle("/healthz", health.Handler{Runtime: "research-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "research-runtime", Probes: []health.Probe{{Name: "epistemics-postgres", Check: func(ctx context.Context) error { return repository.Ping(ctx) }}}})
+	mux.HandleFunc("POST /v1/research/evaluate", func(w http.ResponseWriter, r *http.Request) {
+		var request epistemics.ResearchEvaluationRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 2<<20)).Decode(&request); err != nil {
+			http.Error(w, "invalid research evidence", http.StatusBadRequest)
+			return
+		}
+		result, err := application.EvaluateAndPersist(r.Context(), request, repository, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(result)
+	})
+	connector := researchadapter.RepositoryConnector{Root: os.Getenv("RESEARCH_SOURCE_ROOT")}
+	mux.HandleFunc("POST /v1/research/repository/evaluate", func(w http.ResponseWriter, r *http.Request) {
+		var request epistemics.RepositoryResearchRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 128<<10)).Decode(&request); err != nil {
+			http.Error(w, "invalid repository research request", http.StatusBadRequest)
+			return
+		}
+		candidate, err := connector.Collect(r.Context(), request, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		result, err := application.EvaluateAndPersist(r.Context(), epistemics.ResearchEvaluationRequest{Plan: request.Plan, Candidates: []epistemics.ResearchCandidate{candidate}}, repository, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(result)
+	})
+	webConnector := researchadapter.HTTPConnector{AllowedHosts: allowedHosts(os.Getenv("RESEARCH_HTTP_ALLOWED_HOSTS")), Client: &http.Client{Timeout: 5 * time.Second}}
+	mux.HandleFunc("POST /v1/research/web/evaluate", func(w http.ResponseWriter, r *http.Request) {
+		var request epistemics.WebResearchRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 128<<10)).Decode(&request); err != nil {
+			http.Error(w, "invalid web research request", http.StatusBadRequest)
+			return
+		}
+		candidate, err := webConnector.Collect(r.Context(), request, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		result, err := application.EvaluateAndPersist(r.Context(), epistemics.ResearchEvaluationRequest{Plan: request.Plan, Candidates: []epistemics.ResearchCandidate{candidate}}, repository, time.Now().UnixMilli())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(result)
+	})
+	addr := os.Getenv("LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8087"
+	}
+	log.Printf("research-runtime listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func allowedHosts(value string) map[string]struct{} {
+	result := map[string]struct{}{}
+	for _, host := range strings.Split(value, ",") {
+		if host = strings.ToLower(strings.TrimSpace(host)); host != "" {
+			result[host] = struct{}{}
+		}
+	}
+	return result
+}
+
+func resolveDatabasePassword() (string, error) {
+	if _, ok := os.LookupEnv("EPISTEMICS_POSTGRES_PASSWORD"); ok {
+		return "", fmt.Errorf("EPISTEMICS_POSTGRES_PASSWORD direct environment secret is forbidden")
+	}
+	path, ref := os.Getenv("EPISTEMICS_POSTGRES_PASSWORD_FILE"), os.Getenv("EPISTEMICS_POSTGRES_CREDENTIAL_REF")
+	if path == "" || ref == "" {
+		return "", fmt.Errorf("EPISTEMICS_POSTGRES_PASSWORD_FILE and EPISTEMICS_POSTGRES_CREDENTIAL_REF are required")
+	}
+	root := os.Getenv("SECRET_BACKEND_ROOT")
+	if root == "" {
+		root = "/run/secrets"
+	}
+	resolver, err := secrets.NewFileResolver(root)
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeDatabasePassword, Consumer: secretcontracts.RuntimeConsumerEpistemicsWorker, Path: path})
+}

cmd/work-graph-runtime/main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+
+	"git.cin.su/m/Assistant/adapters/postgres"
+	secretcontracts "git.cin.su/m/Assistant/contracts/secrets"
+	"git.cin.su/m/Assistant/modules/work/application"
+	"git.cin.su/m/Assistant/platform/secrets"
+	"git.cin.su/m/Assistant/runtime/health"
+)
+
+func main() {
+	ctx := context.Background()
+	password, err := resolveDatabasePassword()
+	if err != nil {
+		log.Fatal(err)
+	}
+	repository, err := postgres.OpenWork(ctx, 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 {
+		log.Fatal(err)
+	}
+	defer repository.Close()
+	mux := http.NewServeMux()
+	mux.Handle("/healthz", health.Handler{Runtime: "work-graph-runtime", SemanticGeneration: 1, ArchitectureGeneration: 1})
+	mux.Handle("/readyz", health.ReadinessHandler{Runtime: "work-graph-runtime", Probes: []health.Probe{{Name: "work-postgres", Check: func(ctx context.Context) error { return repository.Ping(ctx) }}}})
+	mux.HandleFunc("POST /v1/work-graphs/schedule", func(w http.ResponseWriter, r *http.Request) {
+		var request application.GraphScheduleRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<20)).Decode(&request); err != nil {
+			http.Error(w, "invalid graph schedule request", http.StatusBadRequest)
+			return
+		}
+		graph, ready, err := application.AdmitAndSchedule(r.Context(), repository, request)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		writeJSON(w, map[string]any{"graph": graph, "scheduled_nodes": ready})
+	})
+	mux.HandleFunc("POST /v1/work-graphs/complete", func(w http.ResponseWriter, r *http.Request) {
+		var request application.GraphCompleteRequest
+		if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 64<<10)).Decode(&request); err != nil {
+			http.Error(w, "invalid graph completion request", http.StatusBadRequest)
+			return
+		}
+		graph, err := application.CompleteGraphNode(r.Context(), repository, request.GraphID, request.Revision, request.NodeID, request.Succeeded)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnprocessableEntity)
+			return
+		}
+		writeJSON(w, graph)
+	})
+	addr := os.Getenv("LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8088"
+	}
+	log.Printf("work-graph-runtime listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func writeJSON(w http.ResponseWriter, value any) {
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(value)
+}
+
+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"
+	}
+	resolver, err := secrets.NewFileResolver(root)
+	if err != nil {
+		return "", err
+	}
+	return resolver.ResolveFile(secretcontracts.SecretFileRef{CredentialRef: secretcontracts.CredentialRef(ref), Purpose: secretcontracts.SecretPurposeDatabasePassword, Consumer: secretcontracts.RuntimeConsumerWorkWorker, Path: path})
+}

contracts/artifact/types.go

@@ -2,4 +2,23 @@ package artifact
 
 import "git.cin.su/m/Assistant/platform/ids"
 
+import "errors"
+
 type ArtifactID ids.ID
+
+type AgentArtifactAttestation struct {
+	ArtifactID          ArtifactID
+	ProducerRunID       string
+	SourceRevision      string
+	WorktreeID          string
+	ContentDigest       string
+	TestEvidenceRef     string
+	CreatedAtUnixMillis int64
+}
+
+func (a AgentArtifactAttestation) Validate() error {
+	if a.ArtifactID == "" || a.ProducerRunID == "" || a.SourceRevision == "" || a.WorktreeID == "" || a.ContentDigest == "" || a.TestEvidenceRef == "" || a.CreatedAtUnixMillis < 1 {
+		return errors.New("agent artifact attestation is incomplete")
+	}
+	return nil
+}

contracts/capability/admission.go

@@ -0,0 +1,73 @@
+package capability
+
+type AdmissionComplexity string
+type AdmissionDecisionState string
+type AdmissionReason string
+
+const (
+	AdmissionSimple             AdmissionComplexity    = "SIMPLE"
+	AdmissionNormal             AdmissionComplexity    = "NORMAL"
+	AdmissionHeavy              AdmissionComplexity    = "HEAVY"
+	AdmissionAdmitted           AdmissionDecisionState = "ADMITTED"
+	AdmissionRejected           AdmissionDecisionState = "REJECTED"
+	AdmissionReasonNone         AdmissionReason        = "NONE"
+	AdmissionReasonConcurrency  AdmissionReason        = "CONCURRENCY_LIMIT"
+	AdmissionReasonAcceptedHour AdmissionReason        = "ACCEPTED_PER_HOUR_LIMIT"
+	AdmissionReasonDeadline     AdmissionReason        = "DEADLINE"
+	AdmissionReasonInputBudget  AdmissionReason        = "INPUT_BUDGET"
+	AdmissionReasonOutputBudget AdmissionReason        = "OUTPUT_BUDGET"
+)
+
+type AdmissionPolicy struct {
+	ID                 string
+	MaxConcurrent      int
+	MaxAcceptedPerHour int
+	MaxInputBytes      int
+	MaxOutputBytes     int
+}
+
+type AdmissionRequest struct {
+	Complexity     AdmissionComplexity `json:"complexity"`
+	InputBytes     int                 `json:"input_bytes"`
+	MaxOutputBytes int                 `json:"max_output_bytes"`
+	DeadlineMillis int64               `json:"deadline_millis"`
+}
+
+type AdmissionCounters struct {
+	Concurrent       int
+	AcceptedLastHour int
+}
+
+type AdmissionDecision struct {
+	State    AdmissionDecisionState `json:"state"`
+	Reason   AdmissionReason        `json:"reason"`
+	PolicyID string                 `json:"policy_id"`
+}
+
+type AdmissionLease struct {
+	ID       string `json:"id"`
+	PolicyID string `json:"policy_id"`
+}
+
+func Admit(request AdmissionRequest, policy AdmissionPolicy, counters AdmissionCounters, nowMillis int64) AdmissionDecision {
+	decision := AdmissionDecision{State: AdmissionAdmitted, Reason: AdmissionReasonNone, PolicyID: policy.ID}
+	if policy.ID == "" || policy.MaxConcurrent < 1 || policy.MaxAcceptedPerHour < 1 || policy.MaxInputBytes < 1 || policy.MaxOutputBytes < 1 {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonInputBudget, PolicyID: policy.ID}
+	}
+	if counters.Concurrent >= policy.MaxConcurrent {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonConcurrency, PolicyID: policy.ID}
+	}
+	if counters.AcceptedLastHour >= policy.MaxAcceptedPerHour {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonAcceptedHour, PolicyID: policy.ID}
+	}
+	if request.InputBytes < 0 || request.InputBytes > policy.MaxInputBytes {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonInputBudget, PolicyID: policy.ID}
+	}
+	if request.MaxOutputBytes < 1 || request.MaxOutputBytes > policy.MaxOutputBytes {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonOutputBudget, PolicyID: policy.ID}
+	}
+	if request.DeadlineMillis > 0 && request.DeadlineMillis <= nowMillis {
+		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonDeadline, PolicyID: policy.ID}
+	}
+	return decision
+}

contracts/capability/fleet.go

@@ -0,0 +1,25 @@
+package capability
+
+type FleetTier string
+
+const (
+	FleetTierFast     FleetTier = "FAST"
+	FleetTierMedium   FleetTier = "MEDIUM"
+	FleetTierHeavy    FleetTier = "HEAVY"
+	FleetTierLifeboat FleetTier = "LIFEBOAT"
+)
+
+type FleetMember struct {
+	ProviderInstanceID ProviderInstanceID `json:"provider_instance_id"`
+	ModelDescriptorID  ModelDescriptorID  `json:"model_descriptor_id"`
+	Tier               FleetTier          `json:"tier"`
+	Ready              bool               `json:"ready"`
+	Reason             string             `json:"reason"`
+}
+
+type FleetReadiness struct {
+	ObservedAtUnixMillis int64         `json:"observed_at_unix_millis"`
+	Members              []FleetMember `json:"members"`
+	ReadyTiers           []FleetTier   `json:"ready_tiers"`
+	FallbackTier         FleetTier     `json:"fallback_tier"`
+}

contracts/capability/qualification.go

@@ -0,0 +1,72 @@
+package capability
+
+import "errors"
+
+type QualificationManifestID string
+type QualificationDimension string
+
+const (
+	DimensionDialogue       QualificationDimension = "DIALOGUE"
+	DimensionInterpretation QualificationDimension = "INTERPRETATION"
+	DimensionCoding         QualificationDimension = "CODING"
+	DimensionResearch       QualificationDimension = "RESEARCH"
+	DimensionUncertainty    QualificationDimension = "UNCERTAINTY"
+	DimensionContext        QualificationDimension = "CONTEXT"
+	DimensionLatency        QualificationDimension = "LATENCY"
+	DimensionResources      QualificationDimension = "RESOURCES"
+	DimensionRestart        QualificationDimension = "RESTART"
+)
+
+type QualificationMeasurement struct {
+	Dimension QualificationDimension
+	Result    EvaluationResult
+	Artifact  string
+}
+
+type QualificationManifest struct {
+	ID                   QualificationManifestID
+	ModelDescriptorID    ModelDescriptorID
+	ModelRevision        int64
+	ModelFingerprint     ModelFingerprint
+	BenchmarkVersion     string
+	HoldoutCorpusDigest  string
+	LicenseEvidence      string
+	DataPolicyEvidence   string
+	Measurements         []QualificationMeasurement
+	ObservedAtUnixMillis int64
+}
+
+func (m QualificationManifest) Validate() error {
+	if m.ID == "" || m.ModelDescriptorID == "" || m.ModelRevision < 1 || m.ModelFingerprint == "" || m.BenchmarkVersion == "" || m.HoldoutCorpusDigest == "" || m.LicenseEvidence == "" || m.DataPolicyEvidence == "" || m.ObservedAtUnixMillis < 1 {
+		return errors.New("qualification manifest identity and evidence are incomplete")
+	}
+	required := map[QualificationDimension]bool{DimensionDialogue: false, DimensionInterpretation: false, DimensionCoding: false, DimensionResearch: false, DimensionUncertainty: false, DimensionContext: false, DimensionLatency: false, DimensionResources: false, DimensionRestart: false}
+	for _, measurement := range m.Measurements {
+		if measurement.Dimension == "" || measurement.Artifact == "" || measurement.Result == EvaluationUnknown {
+			return errors.New("qualification measurement is incomplete")
+		}
+		if _, ok := required[measurement.Dimension]; ok {
+			required[measurement.Dimension] = true
+		}
+	}
+	for _, present := range required {
+		if !present {
+			return errors.New("qualification manifest lacks required measurement")
+		}
+	}
+	return nil
+}
+
+// QualificationState projects evidence into a qualification result. It does
+// not activate a binding or mutate the model registry.
+func (m QualificationManifest) QualificationState() QualificationState {
+	if m.Validate() != nil {
+		return QualificationRejected
+	}
+	for _, measurement := range m.Measurements {
+		if measurement.Result != EvaluationSupported {
+			return QualificationRejected
+		}
+	}
+	return QualificationValidated
+}

contracts/cognitive/context_compiler.go

@@ -0,0 +1,91 @@
+package cognitive
+
+import (
+	"errors"
+	"sort"
+	"strings"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+)
+
+var ErrInvalidContextBudget = errors.New("context budget must be positive")
+
+type ContextCandidate struct {
+	Excerpt   ContextExcerpt
+	Relevance int
+}
+
+type ContextCompileInput struct {
+	Candidates []ContextCandidate
+	DataPolicy capability.DataPolicy
+	MaxBytes   int
+}
+
+type ContextOmission struct {
+	ID     ContextExcerptID
+	Reason string
+}
+
+type ContextBundle struct {
+	Excerpts  []ContextExcerpt
+	Omissions []ContextOmission
+	Bytes     int
+}
+
+// CompileContext deterministically selects permitted, relevant excerpts for a
+// gateway request. It carries no provider identity and performs no I/O.
+func CompileContext(input ContextCompileInput) (ContextBundle, error) {
+	if input.MaxBytes <= 0 {
+		return ContextBundle{}, ErrInvalidContextBudget
+	}
+	candidates := append([]ContextCandidate(nil), input.Candidates...)
+	sort.SliceStable(candidates, func(i, j int) bool {
+		if candidates[i].Relevance != candidates[j].Relevance {
+			return candidates[i].Relevance > candidates[j].Relevance
+		}
+		return string(candidates[i].Excerpt.ID) < string(candidates[j].Excerpt.ID)
+	})
+	bundle := ContextBundle{Excerpts: []ContextExcerpt{}, Omissions: []ContextOmission{}}
+	seen := make(map[ContextExcerptID]struct{}, len(candidates))
+	for _, candidate := range candidates {
+		excerpt := candidate.Excerpt
+		if _, ok := seen[excerpt.ID]; ok {
+			bundle.Omissions = append(bundle.Omissions, ContextOmission{ID: excerpt.ID, Reason: "duplicate"})
+			continue
+		}
+		seen[excerpt.ID] = struct{}{}
+		reason := permittedContextReason(excerpt, input.DataPolicy)
+		if reason != "" {
+			bundle.Omissions = append(bundle.Omissions, ContextOmission{ID: excerpt.ID, Reason: reason})
+			continue
+		}
+		if strings.TrimSpace(excerpt.Text) == "" {
+			bundle.Omissions = append(bundle.Omissions, ContextOmission{ID: excerpt.ID, Reason: "empty"})
+			continue
+		}
+		bytes := len([]byte(excerpt.Text))
+		if bundle.Bytes+bytes > input.MaxBytes {
+			bundle.Omissions = append(bundle.Omissions, ContextOmission{ID: excerpt.ID, Reason: "budget"})
+			continue
+		}
+		bundle.Excerpts = append(bundle.Excerpts, excerpt)
+		bundle.Bytes += bytes
+	}
+	return bundle, nil
+}
+
+func permittedContextReason(excerpt ContextExcerpt, policy capability.DataPolicy) string {
+	if excerpt.Sensitivity == SensitivitySecret {
+		return "secret"
+	}
+	if excerpt.Sensitivity == SensitivityUnknown {
+		return "unknown_sensitivity"
+	}
+	if policy == capability.DataPolicyExternalMessageOnly {
+		return "policy_message_only"
+	}
+	if policy == capability.DataPolicyExternalMinimizedContext && excerpt.Sensitivity != SensitivityPublic {
+		return "policy_public_only"
+	}
+	return ""
+}

contracts/epistemics/research.go

@@ -0,0 +1,170 @@
+package epistemics
+
+import (
+	"errors"
+	"strings"
+)
+
+var ErrCitationEvidenceMismatch = errors.New("citation evidence does not match source chain")
+
+type ResearchPlanID string
+type SourceID string
+type SourceSnapshotID string
+type SourceExcerptID string
+type CitationID string
+type FreshnessState string
+type CoverageState string
+type ConflictState string
+type EvidenceKind string
+type ResearchFindingState string
+
+const (
+	FreshnessCurrent  FreshnessState       = "CURRENT"
+	FreshnessStale    FreshnessState       = "STALE"
+	FreshnessUnknown  FreshnessState       = "UNKNOWN"
+	CoverageComplete  CoverageState        = "COMPLETE"
+	CoveragePartial   CoverageState        = "PARTIAL"
+	CoverageUnknown   CoverageState        = "UNKNOWN"
+	ConflictNone      ConflictState        = "NONE"
+	ConflictPresent   ConflictState        = "PRESENT"
+	ConflictUnknown   ConflictState        = "UNKNOWN"
+	EvidenceObserved  EvidenceKind         = "OBSERVED"
+	EvidenceAssumed   EvidenceKind         = "ASSUMED"
+	FindingSupported  ResearchFindingState = "SUPPORTED"
+	FindingStale      ResearchFindingState = "STALE"
+	FindingConflicted ResearchFindingState = "CONFLICTED"
+	FindingUnknown    ResearchFindingState = "UNKNOWN"
+)
+
+type ResearchPlan struct {
+	ID                  ResearchPlanID
+	Question            string
+	SourceClasses       []string
+	FreshnessPolicy     string
+	CreatedAtUnixMillis int64
+}
+
+type Source struct {
+	ID        SourceID
+	Kind      string
+	Locator   string
+	Title     string
+	Publisher string
+}
+
+type SourceSnapshot struct {
+	ID                   SourceSnapshotID
+	SourceID             SourceID
+	ContentDigest        string
+	CapturedAtUnixMillis int64
+	Freshness            FreshnessState
+}
+
+type SourceExcerpt struct {
+	ID         SourceExcerptID
+	SnapshotID SourceSnapshotID
+	Text       string
+	Start      int64
+	End        int64
+}
+
+type Citation struct {
+	ID                   CitationID
+	ExcerptID            SourceExcerptID
+	Evidence             EvidenceKind
+	Coverage             CoverageState
+	Conflict             ConflictState
+	ResolvedAtUnixMillis int64
+}
+
+// ResearchCandidate is read-only evidence returned by a connector. The
+// connector supplies the immutable snapshot and exact excerpt; the evaluator
+// never fetches, rewrites or invents either one.
+type ResearchCandidate struct {
+	PropositionKey string
+	Statement      string
+	Source         Source
+	Snapshot       SourceSnapshot
+	Excerpt        SourceExcerpt
+	Evidence       EvidenceKind
+	Coverage       CoverageState
+	Conflict       ConflictState
+}
+
+type ResearchFinding struct {
+	PropositionKey string
+	Statement      string
+	Claim          Claim
+	Citations      []Citation
+	State          ResearchFindingState
+	Reason         string
+}
+
+type ResearchResult struct {
+	PlanID                ResearchPlanID
+	Findings              []ResearchFinding
+	EvaluatedAtUnixMillis int64
+}
+
+// ResearchEvaluationRequest carries immutable evidence from a read-only
+// connector to the evaluator. The runtime never fetches or mutates a source
+// from this contract.
+type ResearchEvaluationRequest struct {
+	Plan       ResearchPlan
+	Candidates []ResearchCandidate
+}
+
+type RepositoryResearchRequest struct {
+	Plan           ResearchPlan
+	PropositionKey string
+	SourceID       SourceID
+	Path           string
+	Statement      string
+}
+
+type WebResearchRequest struct {
+	Plan           ResearchPlan
+	PropositionKey string
+	SourceID       SourceID
+	URL            string
+	Title          string
+	Statement      string
+}
+
+// ResolveCitation creates evidence only when all identifiers form one exact
+// source chain. It deliberately does not fetch, infer or rewrite source text.
+func ResolveCitation(source Source, snapshot SourceSnapshot, excerpt SourceExcerpt, evidence EvidenceKind, coverage CoverageState, conflict ConflictState, resolvedAtUnixMillis int64) (Citation, error) {
+	if source.ID == "" || strings.TrimSpace(source.Locator) == "" || snapshot.SourceID != source.ID || excerpt.SnapshotID != snapshot.ID || excerpt.Validate() != nil || resolvedAtUnixMillis < 1 || evidence == "" || coverage == "" || conflict == "" {
+		return Citation{}, ErrCitationEvidenceMismatch
+	}
+	citation := Citation{ID: CitationID("citation:" + string(excerpt.ID)), ExcerptID: excerpt.ID, Evidence: evidence, Coverage: coverage, Conflict: conflict, ResolvedAtUnixMillis: resolvedAtUnixMillis}
+	return citation, citation.Validate()
+}
+
+func (p ResearchPlan) Validate() error {
+	if p.ID == "" || strings.TrimSpace(p.Question) == "" || len(p.SourceClasses) == 0 || strings.TrimSpace(p.FreshnessPolicy) == "" {
+		return errors.New("research plan requires question, source classes and freshness policy")
+	}
+	return nil
+}
+
+func (s SourceSnapshot) Validate() error {
+	if s.ID == "" || s.SourceID == "" || strings.TrimSpace(s.ContentDigest) == "" || s.CapturedAtUnixMillis < 1 || s.Freshness == "" {
+		return errors.New("source snapshot requires source, digest, capture time and freshness")
+	}
+	return nil
+}
+
+func (e SourceExcerpt) Validate() error {
+	if e.ID == "" || e.SnapshotID == "" || strings.TrimSpace(e.Text) == "" || e.Start < 0 || e.End < e.Start {
+		return errors.New("source excerpt requires snapshot, text and valid offsets")
+	}
+	return nil
+}
+
+func (c Citation) Validate() error {
+	if c.ID == "" || c.ExcerptID == "" || c.Evidence == "" || c.Coverage == "" || c.Conflict == "" || c.ResolvedAtUnixMillis < 1 {
+		return errors.New("citation requires exact excerpt, evidence, coverage, conflict and resolution time")
+	}
+	return nil
+}

contracts/epistemics/truth.go

@@ -0,0 +1,41 @@
+package epistemics
+
+type BeliefState string
+
+const (
+	BeliefProvisional BeliefState = "PROVISIONAL"
+	BeliefConflicted  BeliefState = "CONFLICTED"
+	BeliefVerified    BeliefState = "VERIFIED"
+)
+
+type Observation struct {
+	ID             ObservationID
+	SourceSnapshot SourceSnapshotID
+	Excerpt        SourceExcerptID
+	Text           string
+	ObservedAt     int64
+}
+
+type Claim struct {
+	ID            ClaimID
+	Statement     string
+	ObservationID ObservationID
+	CitationID    CitationID
+	Verification  VerificationState
+}
+
+type Belief struct {
+	ID      BeliefID
+	ClaimID ClaimID
+	State   BeliefState
+}
+
+type TruthBundle struct {
+	Source      Source
+	Snapshot    SourceSnapshot
+	Excerpt     SourceExcerpt
+	Observation Observation
+	Claim       Claim
+	Belief      Belief
+	Citation    Citation
+}

contracts/epistemics/types.go

@@ -120,15 +120,17 @@ type ExperienceRecord struct {
 // Cognitive reflection, if used, must go through Cognitive Gateway/Router and
 // produce candidates only; it cannot directly rewrite canonical state.
 type ReflectionCandidate struct {
-	ID                   ReflectionCandidateID
-	Trigger              ReflectionTriggerKind
-	State                ReflectionCandidateState
-	SourceExperienceID   ExperienceRecordID
-	OriginalIntentID     OriginalIntentRef
-	SourceUtteranceID    SourceUtteranceRef
-	Summary              string
-	EvidenceRefs         []EvidenceRef
-	RequiresCognition    bool
-	RecordedAtUnixMillis int64
-	Revision             int64
+	ID                       ReflectionCandidateID
+	Trigger                  ReflectionTriggerKind
+	State                    ReflectionCandidateState
+	SourceExperienceID       ExperienceRecordID
+	OriginalIntentID         OriginalIntentRef
+	SourceUtteranceID        SourceUtteranceRef
+	Summary                  string
+	EvidenceRefs             []EvidenceRef
+	RequiresCognition        bool
+	RecordedAtUnixMillis     int64
+	Revision                 int64
+	ClaimedBy                string
+	ClaimExpiresAtUnixMillis int64
 }

contracts/secrets/types.go

@@ -9,13 +9,17 @@ type SecretPurpose string
 
 const (
 	SecretPurposeDatabasePassword SecretPurpose = "DATABASE_PASSWORD"
+	SecretPurposeProviderAPIKey   SecretPurpose = "PROVIDER_API_KEY"
 )
 
 // RuntimeConsumer identifies a trusted runtime allowed to resolve a credential.
 type RuntimeConsumer string
 
 const (
-	RuntimeConsumerCore RuntimeConsumer = "core-runtime"
+	RuntimeConsumerCore             RuntimeConsumer = "core-runtime"
+	RuntimeConsumerWorkWorker       RuntimeConsumer = "agent-worker"
+	RuntimeConsumerEpistemicsWorker RuntimeConsumer = "reflection-worker"
+	RuntimeConsumerCognitive        RuntimeConsumer = "cognitive-worker"
 )
 
 // SecretFileRef is bootstrap delivery metadata for the V1 protected local

contracts/work/bridge.go

@@ -0,0 +1,32 @@
+package work
+
+import "time"
+
+// AgentExecutionRequest is the serializable hand-off from the durable worker
+// to an executor. The bridge receives the already-authorized dispatch context;
+// it does not receive database credentials or ambient authority.
+type AgentExecutionRequest struct {
+	Intent         AgentDispatchIntent `json:"intent"`
+	WorkerID       string              `json:"worker_id"`
+	FencingToken   AgentFencingToken   `json:"fencing_token"`
+	LeaseExpiresAt time.Time           `json:"lease_expires_at"`
+}
+
+type AgentExecutionState string
+
+const (
+	AgentExecutionCompleted AgentExecutionState = "COMPLETED"
+	AgentExecutionWaiting   AgentExecutionState = "WAITING"
+	AgentExecutionFailed    AgentExecutionState = "FAILED"
+)
+
+// AgentExecutionResult is an acknowledgement of the external execution
+// attempt. The worker persists it through the work owner before completing a
+// dispatch, so a bridge timeout never becomes an unrecorded success.
+type AgentExecutionResult struct {
+	State                AgentExecutionState `json:"state"`
+	Summary              string              `json:"summary"`
+	OutcomeRef           string              `json:"outcome_ref"`
+	ArtifactRefs         []string            `json:"artifact_refs"`
+	ObservedAtUnixMillis int64               `json:"observed_at_unix_millis"`
+}

contracts/work/dispatch_queue.go

@@ -0,0 +1,19 @@
+package work
+
+type AgentDispatchQueueState string
+
+const (
+	AgentDispatchQueued    AgentDispatchQueueState = "QUEUED"
+	AgentDispatchClaimed   AgentDispatchQueueState = "CLAIMED"
+	AgentDispatchCompleted AgentDispatchQueueState = "COMPLETED"
+	AgentDispatchFailed    AgentDispatchQueueState = "FAILED"
+)
+
+type AgentDispatchQueueItem struct {
+	DispatchID            string                  `json:"dispatch_id"`
+	State                 AgentDispatchQueueState `json:"state"`
+	AvailableAtUnixMillis int64                   `json:"available_at_unix_millis"`
+	Attempts              int                     `json:"attempts"`
+	ClaimedBy             string                  `json:"claimed_by"`
+	UpdatedAtUnixMillis   int64                   `json:"updated_at_unix_millis"`
+}

contracts/work/dry_run_dispatch.go

@@ -0,0 +1,18 @@
+package work
+
+import "time"
+
+type DryRunDispatch struct {
+	Intent    AgentDispatchIntent
+	Lease     AgentLease
+	Callbacks []AgentCallback
+}
+
+func (value DryRunDispatch) CallbackCount() int { return len(value.Callbacks) }
+
+func (value DryRunDispatch) LastObservedAt() time.Time {
+	if len(value.Callbacks) == 0 {
+		return time.Time{}
+	}
+	return value.Callbacks[len(value.Callbacks)-1].ObservedAt
+}

contracts/work/graph.go

@@ -0,0 +1,73 @@
+package work
+
+type GraphNodeID string
+
+type GraphState string
+type GraphNodeState string
+
+const (
+	GraphDraft     GraphState = "DRAFT"
+	GraphAdmitted  GraphState = "ADMITTED"
+	GraphRunning   GraphState = "RUNNING"
+	GraphPartial   GraphState = "PARTIAL"
+	GraphVerifying GraphState = "VERIFYING"
+	GraphCompleted GraphState = "COMPLETED"
+	GraphFailed    GraphState = "FAILED"
+	GraphUnknown   GraphState = "UNKNOWN"
+
+	GraphNodeBlocked GraphNodeState = "BLOCKED_PREREQUISITE"
+	GraphNodeReady   GraphNodeState = "READY"
+	GraphNodeLeased  GraphNodeState = "LEASED"
+	GraphNodeRunning GraphNodeState = "RUNNING"
+	GraphNodeSuccess GraphNodeState = "SUCCEEDED"
+	GraphNodeFailed  GraphNodeState = "FAILED"
+	GraphNodeCancel  GraphNodeState = "CANCELLED"
+	GraphNodeUnknown GraphNodeState = "UNKNOWN"
+)
+
+type GraphBudget struct {
+	MaxParallel int `json:"max_parallel"`
+	MaxAttempts int `json:"max_attempts"`
+}
+
+type GraphNode struct {
+	ID             GraphNodeID    `json:"id"`
+	DispatchID     string         `json:"dispatch_id"`
+	IdempotencyKey string         `json:"idempotency_key"`
+	State          GraphNodeState `json:"state"`
+	Attempts       int            `json:"attempts"`
+}
+
+type GraphEdge struct {
+	From GraphNodeID `json:"from"`
+	To   GraphNodeID `json:"to"`
+}
+
+type WorkGraph struct {
+	ID       string      `json:"id"`
+	Revision int64       `json:"revision"`
+	State    GraphState  `json:"state"`
+	Nodes    []GraphNode `json:"nodes"`
+	Edges    []GraphEdge `json:"edges"`
+	Budget   GraphBudget `json:"budget"`
+}
+
+type ResultCandidate struct {
+	ID              string
+	GraphID         string
+	GraphRevision   int64
+	NodeID          GraphNodeID
+	AuthorRunID     AgentRunID
+	ArtifactRefs    []EvidenceRef
+	EvidenceSummary string
+	Summary         string
+}
+
+type ConflictSet struct {
+	ID            string
+	GraphID       string
+	GraphRevision int64
+	NodeID        GraphNodeID
+	CandidateIDs  []string
+	Resolved      bool
+}

contracts/work/lease.go

@@ -0,0 +1,63 @@
+package work
+
+import "time"
+
+type AgentLeaseID string
+type AgentFencingToken uint64
+type AgentLeaseState string
+
+const (
+	AgentLeaseActive  AgentLeaseState = "ACTIVE"
+	AgentLeaseExpired AgentLeaseState = "EXPIRED"
+)
+
+type AgentLease struct {
+	ID           AgentLeaseID
+	RunID        AgentRunID
+	WorkerID     string
+	FencingToken AgentFencingToken
+	State        AgentLeaseState
+	AcquiredAt   time.Time
+	ExpiresAt    time.Time
+}
+
+type AgentCallbackKind string
+
+const (
+	AgentCallbackHeartbeat          AgentCallbackKind = "HEARTBEAT"
+	AgentCallbackCheckpoint         AgentCallbackKind = "CHECKPOINT"
+	AgentCallbackResult             AgentCallbackKind = "RESULT"
+	AgentCallbackCancelAcknowledged AgentCallbackKind = "CANCEL_ACKNOWLEDGED"
+)
+
+type AgentCallback struct {
+	RunID        AgentRunID
+	WorkerID     string
+	FencingToken AgentFencingToken
+	Sequence     uint64
+	Kind         AgentCallbackKind
+	ObservedAt   time.Time
+}
+
+type IndependentVerification struct {
+	ProducerRunID    AgentRunID
+	VerifierRunID    AgentRunID
+	VerifierIdentity string
+	ArtifactID       string
+	TestEvidenceRef  string
+	Verified         bool
+	Summary          string
+}
+
+type AgentDispatchIntent struct {
+	DispatchID             string       `json:"dispatch_id"`
+	IdempotencyKey         string       `json:"idempotency_key"`
+	DelegationID           DelegationID `json:"delegation_id"`
+	RunID                  AgentRunID   `json:"run_id"`
+	ImplementationID       string       `json:"implementation_id"`
+	ImplementationRevision int64        `json:"implementation_revision"`
+	SourceRevision         string       `json:"source_revision"`
+	WorktreeID             string       `json:"worktree_id"`
+	VerificationPlanRef    string       `json:"verification_plan_ref"`
+	CreatedAtUnixMillis    int64        `json:"created_at_unix_millis"`
+}

contracts/work/self_development.go

@@ -0,0 +1,29 @@
+package work
+
+type DevelopmentStage string
+
+const (
+	DevelopmentEvidenceCollected DevelopmentStage = "EVIDENCE_COLLECTED"
+	DevelopmentProposalCreated   DevelopmentStage = "PROPOSAL_CREATED"
+	DevelopmentTaskAdmitted      DevelopmentStage = "TASK_ADMITTED"
+	DevelopmentIsolated          DevelopmentStage = "ISOLATED"
+	DevelopmentVerified          DevelopmentStage = "VERIFIED"
+	DevelopmentCanary            DevelopmentStage = "CANARY"
+	DevelopmentPromoted          DevelopmentStage = "PROMOTED"
+	DevelopmentRolledBack        DevelopmentStage = "ROLLED_BACK"
+)
+
+type DevelopmentGate struct {
+	ID                   string
+	Stage                DevelopmentStage
+	EvidenceRefs         []string
+	ProposalRef          string
+	TaskPacketRef        string
+	WorktreeRef          string
+	ProducerRunRefs      []AgentRunID
+	VerifierRunRefs      []AgentRunID
+	VerificationEvidence string
+	CanaryEvidence       string
+	PromotionRef         string
+	RollbackRef          string
+}

database/migrations/029_work_agent_execution_persistence.sql

@@ -0,0 +1,43 @@
+BEGIN;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.agent_dispatch_intents (
+  dispatch_id TEXT PRIMARY KEY,
+  idempotency_key TEXT NOT NULL UNIQUE,
+  delegation_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  implementation_id TEXT NOT NULL,
+  implementation_revision BIGINT NOT NULL,
+  source_revision TEXT NOT NULL,
+  worktree_id TEXT NOT NULL,
+  verification_plan_ref TEXT NOT NULL,
+  created_at_unix_millis BIGINT NOT NULL,
+  CHECK (dispatch_id <> ''), CHECK (idempotency_key <> ''), CHECK (delegation_id <> ''),
+  CHECK (run_id <> ''), CHECK (implementation_id <> ''), CHECK (implementation_revision > 0),
+  CHECK (source_revision <> ''), CHECK (worktree_id <> ''), CHECK (verification_plan_ref <> ''),
+  CHECK (created_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS work.agent_leases (
+  lease_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL UNIQUE,
+  worker_id TEXT NOT NULL,
+  fencing_token BIGINT NOT NULL,
+  state TEXT NOT NULL,
+  acquired_at_unix_millis BIGINT NOT NULL,
+  expires_at_unix_millis BIGINT NOT NULL,
+  CHECK (lease_id <> ''), CHECK (run_id <> ''), CHECK (worker_id <> ''),
+  CHECK (fencing_token > 0), CHECK (state IN ('ACTIVE','EXPIRED')),
+  CHECK (acquired_at_unix_millis > 0), CHECK (expires_at_unix_millis > acquired_at_unix_millis)
+);
+
+CREATE TABLE IF NOT EXISTS work.agent_callback_heads (
+  run_id TEXT PRIMARY KEY,
+  last_sequence BIGINT NOT NULL DEFAULT 0,
+  updated_at_unix_millis BIGINT NOT NULL,
+  CHECK (run_id <> ''), CHECK (last_sequence >= 0), CHECK (updated_at_unix_millis > 0)
+);
+
+RESET ROLE;
+COMMIT;

database/migrations/030_work_agent_dispatch_queue.sql

@@ -0,0 +1,22 @@
+BEGIN;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.agent_dispatch_queue (
+  dispatch_id TEXT PRIMARY KEY REFERENCES work.agent_dispatch_intents(dispatch_id),
+  state TEXT NOT NULL,
+  available_at_unix_millis BIGINT NOT NULL,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  claimed_by TEXT NOT NULL DEFAULT '',
+  updated_at_unix_millis BIGINT NOT NULL,
+  CHECK (state IN ('QUEUED','CLAIMED','COMPLETED','FAILED')),
+  CHECK (available_at_unix_millis > 0),
+  CHECK (attempts >= 0),
+  CHECK (updated_at_unix_millis > 0)
+);
+
+CREATE INDEX IF NOT EXISTS agent_dispatch_queue_claim_idx
+  ON work.agent_dispatch_queue(state, available_at_unix_millis, dispatch_id);
+
+RESET ROLE;
+COMMIT;

database/migrations/031_work_graph_persistence.sql

@@ -0,0 +1,41 @@
+BEGIN;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.graphs (
+  graph_id TEXT NOT NULL,
+  revision BIGINT NOT NULL,
+  state TEXT NOT NULL,
+  max_parallel INTEGER NOT NULL,
+  max_attempts INTEGER NOT NULL,
+  PRIMARY KEY (graph_id, revision),
+  CHECK (graph_id <> ''), CHECK (revision > 0),
+  CHECK (state IN ('DRAFT','ADMITTED','RUNNING','PAUSED','CANCELLING','PARTIAL','VERIFYING','COMPLETED','FAILED','UNKNOWN','RECOVERING')),
+  CHECK (max_parallel > 0), CHECK (max_attempts > 0)
+);
+
+CREATE TABLE IF NOT EXISTS work.graph_nodes (
+  graph_id TEXT NOT NULL,
+  revision BIGINT NOT NULL,
+  node_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  state TEXT NOT NULL,
+  attempts INTEGER NOT NULL,
+  PRIMARY KEY (graph_id, revision, node_id),
+  FOREIGN KEY (graph_id, revision) REFERENCES work.graphs(graph_id, revision),
+  CHECK (node_id <> ''), CHECK (idempotency_key <> ''), CHECK (attempts >= 0),
+  CHECK (state IN ('BLOCKED_PREREQUISITE','READY','LEASED','RUNNING','SUCCEEDED','FAILED','CANCELLED','UNKNOWN','RECOVERING'))
+);
+
+CREATE TABLE IF NOT EXISTS work.graph_edges (
+  graph_id TEXT NOT NULL,
+  revision BIGINT NOT NULL,
+  from_node_id TEXT NOT NULL,
+  to_node_id TEXT NOT NULL,
+  PRIMARY KEY (graph_id, revision, from_node_id, to_node_id),
+  FOREIGN KEY (graph_id, revision) REFERENCES work.graphs(graph_id, revision),
+  CHECK (from_node_id <> ''), CHECK (to_node_id <> ''), CHECK (from_node_id <> to_node_id)
+);
+
+RESET ROLE;
+COMMIT;

database/migrations/032_reflection_candidate_leases.sql

@@ -0,0 +1,19 @@
+BEGIN;
+
+SET ROLE epistemics_role;
+
+ALTER TABLE epistemics.reflection_candidates
+  ADD COLUMN IF NOT EXISTS claimed_by TEXT NOT NULL DEFAULT '',
+  ADD COLUMN IF NOT EXISTS claim_expires_at_unix_millis BIGINT NOT NULL DEFAULT 0;
+
+ALTER TABLE epistemics.reflection_candidates
+  DROP CONSTRAINT IF EXISTS reflection_candidates_claim_expiry_check;
+ALTER TABLE epistemics.reflection_candidates
+  ADD CONSTRAINT reflection_candidates_claim_expiry_check
+  CHECK (claim_expires_at_unix_millis >= 0);
+
+CREATE INDEX IF NOT EXISTS reflection_candidates_claimable_idx
+  ON epistemics.reflection_candidates (state, claim_expires_at_unix_millis, recorded_at_unix_millis, reflection_candidate_id);
+
+RESET ROLE;
+COMMIT;

database/migrations/033_cognitive_admission_leases.sql

@@ -0,0 +1,30 @@
+BEGIN;
+
+SET ROLE capability_role;
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_admission_counters (
+  policy_id TEXT PRIMARY KEY,
+  window_start_unix_millis BIGINT NOT NULL,
+  accepted_count INTEGER NOT NULL DEFAULT 0,
+  concurrent_count INTEGER NOT NULL DEFAULT 0,
+  updated_at_unix_millis BIGINT NOT NULL,
+  CHECK (policy_id <> ''), CHECK (window_start_unix_millis > 0),
+  CHECK (accepted_count >= 0), CHECK (concurrent_count >= 0),
+  CHECK (updated_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_admission_leases (
+  lease_id TEXT PRIMARY KEY,
+  policy_id TEXT NOT NULL REFERENCES capability.cognitive_admission_counters(policy_id),
+  state TEXT NOT NULL,
+  expires_at_unix_millis BIGINT NOT NULL,
+  created_at_unix_millis BIGINT NOT NULL,
+  CHECK (lease_id <> ''), CHECK (state IN ('ACTIVE','RELEASED','EXPIRED')),
+  CHECK (expires_at_unix_millis > 0), CHECK (created_at_unix_millis > 0)
+);
+
+CREATE INDEX IF NOT EXISTS cognitive_admission_lease_expiry_idx
+  ON capability.cognitive_admission_leases(policy_id, state, expires_at_unix_millis);
+
+RESET ROLE;
+COMMIT;

database/migrations/034_epistemics_truth_bundles.sql

@@ -0,0 +1,49 @@
+BEGIN;
+
+SET ROLE epistemics_role;
+
+CREATE TABLE IF NOT EXISTS epistemics.truth_bundles (
+  bundle_id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL,
+  source_kind TEXT NOT NULL,
+  source_locator TEXT NOT NULL,
+  source_title TEXT NOT NULL,
+  source_publisher TEXT NOT NULL,
+  snapshot_id TEXT NOT NULL,
+  snapshot_source_id TEXT NOT NULL,
+  snapshot_content_digest TEXT NOT NULL,
+  snapshot_captured_at_unix_millis BIGINT NOT NULL,
+  snapshot_freshness TEXT NOT NULL,
+  excerpt_id TEXT NOT NULL,
+  excerpt_snapshot_id TEXT NOT NULL,
+  excerpt_text TEXT NOT NULL,
+  excerpt_start BIGINT NOT NULL,
+  excerpt_end BIGINT NOT NULL,
+  observation_id TEXT NOT NULL,
+  observation_observed_at_unix_millis BIGINT NOT NULL,
+  claim_id TEXT NOT NULL,
+  claim_statement TEXT NOT NULL,
+  claim_observation_id TEXT NOT NULL,
+  claim_citation_id TEXT NOT NULL,
+  claim_verification TEXT NOT NULL,
+  belief_id TEXT NOT NULL,
+  belief_claim_id TEXT NOT NULL,
+  belief_state TEXT NOT NULL,
+  citation_id TEXT NOT NULL,
+  citation_excerpt_id TEXT NOT NULL,
+  citation_evidence TEXT NOT NULL,
+  citation_coverage TEXT NOT NULL,
+  citation_conflict TEXT NOT NULL,
+  citation_resolved_at_unix_millis BIGINT NOT NULL,
+  recorded_at_unix_millis BIGINT NOT NULL,
+  UNIQUE (snapshot_id, excerpt_id, claim_id),
+  CHECK (bundle_id <> ''), CHECK (source_id <> ''), CHECK (source_locator <> ''),
+  CHECK (excerpt_start >= 0), CHECK (excerpt_end >= excerpt_start),
+  CHECK (recorded_at_unix_millis > 0)
+);
+
+CREATE INDEX IF NOT EXISTS truth_bundles_source_time_idx
+  ON epistemics.truth_bundles (source_id, recorded_at_unix_millis DESC);
+
+RESET ROLE;
+COMMIT;

database/migrations/035_work_graph_dispatch_binding.sql

@@ -0,0 +1,8 @@
+BEGIN;
+
+SET ROLE work_role;
+
+ALTER TABLE work.graph_nodes ADD COLUMN IF NOT EXISTS dispatch_id TEXT NOT NULL DEFAULT '';
+
+RESET ROLE;
+COMMIT;

deploy/apply-migrations.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_DIR="${REPO_DIR:-$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)}"
+ENV_FILE="${ENV_FILE:-/home/m/assistant-deploy/production-compose.env}"
+POSTGRES_CONTAINER="${POSTGRES_CONTAINER:-assistant-postgres-1}"
+
+if [[ ! -f "$ENV_FILE" ]]; then
+  echo "migration runner: env file is missing" >&2
+  exit 1
+fi
+
+set -a
+# The deployment env file is controlled by the production operator. Values
+# are used only by the local Docker/psql boundary and are never logged.
+. "$ENV_FILE"
+set +a
+
+: "${POSTGRES_SUPERUSER:?POSTGRES_SUPERUSER is required}"
+POSTGRES_SUPERUSER="${POSTGRES_SUPERUSER//$'\r'/}"
+DATABASE="${POSTGRES_DB:-assistant}"
+DATABASE="${DATABASE//$'\r'/}"
+
+psql_exec() {
+  docker exec -i "$POSTGRES_CONTAINER" psql -v ON_ERROR_STOP=1 -U "$POSTGRES_SUPERUSER" -d "$DATABASE" "$@"
+}
+
+psql_exec -c "CREATE TABLE IF NOT EXISTS public.assistant_migration_history (migration_id TEXT PRIMARY KEY, applied_at_unix_millis BIGINT NOT NULL CHECK (applied_at_unix_millis > 0));"
+
+if [[ -n "${MIGRATION_BASELINE:-}" ]]; then
+  if [[ ! "$MIGRATION_BASELINE" =~ ^[0-9]{3}$ ]]; then
+    echo "migration runner: invalid MIGRATION_BASELINE" >&2
+    exit 1
+  fi
+  now_ms="$(date +%s%3N)"
+  for file in "$REPO_DIR"/database/migrations/[0-9][0-9][0-9]_*.sql; do
+    migration_id="$(basename "$file" .sql)"
+    number="${migration_id:0:3}"
+    if (( 10#$number <= 10#$MIGRATION_BASELINE )); then
+      psql_exec -c "INSERT INTO public.assistant_migration_history(migration_id, applied_at_unix_millis) VALUES ('$migration_id', $now_ms) ON CONFLICT (migration_id) DO NOTHING;"
+    fi
+  done
+fi
+
+for file in "$REPO_DIR"/database/migrations/[0-9][0-9][0-9]_*.sql; do
+  [[ -f "$file" ]] || continue
+  migration_id="$(basename "$file" .sql)"
+  applied="$(psql_exec -At -c "SELECT 1 FROM public.assistant_migration_history WHERE migration_id='$migration_id' LIMIT 1;")"
+  [[ "$applied" == "1" ]] && continue
+  psql_exec < "$file"
+  now_ms="$(date +%s%3N)"
+  psql_exec -c "INSERT INTO public.assistant_migration_history(migration_id, applied_at_unix_millis) VALUES ('$migration_id', $now_ms);"
+done

deploy/docker-compose.prod.yml

@@ -80,10 +80,95 @@ services:
       INTERACTION_POSTGRES_CREDENTIAL_REF: credential://domovoy/interaction/db-password/v1
       INTERACTION_POSTGRES_PASSWORD_FILE: /run/secrets/interaction_db_password
       SECRET_BACKEND_ROOT: /run/secrets
+      COGNITIVE_ADMISSION_POLICY_ID: creator-advisory-local-v1
+      COGNITIVE_ADMISSION_MAX_CONCURRENT: ${COGNITIVE_ADMISSION_MAX_CONCURRENT:-1}
+      COGNITIVE_ADMISSION_MAX_ACCEPTED_PER_HOUR: ${COGNITIVE_ADMISSION_MAX_ACCEPTED_PER_HOUR:-60}
+      COGNITIVE_ADMISSION_MAX_INPUT_BYTES: ${COGNITIVE_ADMISSION_MAX_INPUT_BYTES:-81920}
+      COGNITIVE_ADMISSION_MAX_OUTPUT_BYTES: ${COGNITIVE_ADMISSION_MAX_OUTPUT_BYTES:-16384}
     depends_on: { postgres: { condition: service_healthy } }
     volumes:
       - assistant_core_secrets:/run/secrets:ro
 
+  agent-canary:
+    profiles: ["agent-canary"]
+    build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: agent-canary, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
+    restart: "no"
+    command: ["-enable-canary", "-postgres"]
+    environment:
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
+      WORK_POSTGRES_USER: work_role
+      WORK_POSTGRES_PASSWORD: ${WORK_DB_PASSWORD}
+    depends_on: { postgres: { condition: service_healthy } }
+
+  agent-worker:
+    build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: agent-worker, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
+    restart: unless-stopped
+    command: ["-worker-id", "agent-worker-production", "-status-addr", ":8090"]
+    environment:
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
+      WORK_POSTGRES_USER: work_role
+      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
+
+  work-graph-runtime:
+    build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: work-graph-runtime, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
+    restart: unless-stopped
+    environment:
+      LISTEN_ADDR: :8088
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
+      WORK_POSTGRES_USER: work_role
+      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
+
+  reflection-worker:
+    build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: reflection-worker, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
+    restart: unless-stopped
+    command: ["-worker-id", "reflection-worker-production"]
+    environment:
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
+      EPISTEMICS_POSTGRES_USER: epistemics_role
+      EPISTEMICS_POSTGRES_CREDENTIAL_REF: credential://domovoy/epistemics/db-password/v1
+      EPISTEMICS_POSTGRES_PASSWORD_FILE: /run/secrets/epistemics_db_password
+      SECRET_BACKEND_ROOT: /run/secrets
+    depends_on: { postgres: { condition: service_healthy } }
+    volumes:
+      - assistant_core_secrets:/run/secrets:ro
+
+  research-runtime:
+    build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: research-runtime, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
+    restart: unless-stopped
+    environment:
+      LISTEN_ADDR: :8087
+      RESEARCH_SOURCE_ROOT: /var/lib/research-sources
+      RESEARCH_HTTP_ALLOWED_HOSTS: assistant.cin.su,git.cin.su
+      POSTGRES_HOST: postgres
+      POSTGRES_PORT: "5432"
+      POSTGRES_DATABASE: ${POSTGRES_DB:-assistant}
+      EPISTEMICS_POSTGRES_USER: epistemics_role
+      EPISTEMICS_POSTGRES_CREDENTIAL_REF: credential://domovoy/epistemics/db-password/v1
+      EPISTEMICS_POSTGRES_PASSWORD_FILE: /run/secrets/epistemics_db_password
+      SECRET_BACKEND_ROOT: /run/secrets
+    depends_on: { postgres: { condition: service_healthy } }
+    volumes:
+      - assistant_core_secrets:/run/secrets:ro
+      - assistant_research_sources:/var/lib/research-sources:ro
+
   continuity-runtime:
     build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: continuity-runtime, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
     restart: unless-stopped
@@ -126,11 +211,15 @@ services:
       LISTEN_ADDR: ":8083"
       CORE_RUNTIME_URL: http://core-runtime:8080
       LOCAL_CPU_PROVIDER_URL: http://docker.cin.su:18082/v1
+      LOCAL_CPU_PROVIDER_API_KEY_FILE: ${LOCAL_CPU_PROVIDER_API_KEY_FILE:-}
+      LOCAL_CPU_PROVIDER_CREDENTIAL_REF: ${LOCAL_CPU_PROVIDER_CREDENTIAL_REF:-credential://domovoy/local-cpu/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]
+    volumes:
+      - assistant_core_secrets:/run/secrets:ro
 
   cognitive-lifeboat:
     image: ghcr.io/ggml-org/llama.cpp:server
@@ -172,6 +261,7 @@ services:
       CONTINUITY_RUNTIME_URL: http://continuity-runtime:8081
       COMMIT_RUNTIME_URL: http://commit-runtime:8082
       COGNITIVE_RUNTIME_URL: http://cognitive-worker:8083
+      AGENT_WORKER_URL: http://agent-worker:8090
       ASSISTANT_BUILD_REVISION: ${ASSISTANT_SOURCE_REVISION:-unknown}
     ports: ["${CREATOR_WEB_PORT:-18080}:8084"]
     depends_on: [core-runtime, continuity-runtime, commit-runtime, cognitive-worker]
@@ -192,5 +282,7 @@ volumes:
   assistant_notification_reader_secret:
     external: true
   llm_local_models:
-    external: true
     name: llm-local-models
+    external: true
+  assistant_research_sources:
+    name: assistant_research_sources

deploy/verify-latest-postgres-backup.sh

@@ -4,10 +4,15 @@ set -eu
 backup_root="${ASSISTANT_BACKUP_DIR:-/home/m/assistant-backups/postgres}"
 verify_script="${ASSISTANT_RESTORE_VERIFY_SCRIPT:-/home/m/assistant-ops/verify-postgres-restore.sh}"
 
-latest="$(find "$backup_root" -mindepth 1 -maxdepth 1 -type d ! -name '.*' -printf '%f\n' | sort | tail -n 1)"
+latest="$(find "$backup_root" -mindepth 1 -maxdepth 1 -type d -regextype posix-extended -regex '.*/[0-9]{8}T[0-9]{6}Z$' -printf '%f\n' | sort | tail -n 1)"
 if [ -z "$latest" ]; then
   echo "No completed PostgreSQL backup found in $backup_root" >&2
   exit 1
 fi
 
+case "$latest" in
+  [0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]T[0-9][0-9][0-9][0-9][0-9][0-9]Z) ;;
+  *) echo "Selected backup directory has invalid timestamp: $latest" >&2; exit 1 ;;
+esac
+
 exec "$verify_script" "$backup_root/$latest"

deploy/windows/Sync-PostgresBackupToNas.ps1

@@ -45,7 +45,7 @@ $cipherPartial = $null
 $manifestPartial = $null
 
 try {
-    $latest = ((& ssh.exe $SshHost "find '$RemoteBackupRoot' -mindepth 1 -maxdepth 1 -type d ! -name '.*' -printf '%f\n' | sort | tail -n1") -join '').Trim()
+    $latest = ((& ssh.exe $SshHost "find '$RemoteBackupRoot' -mindepth 1 -maxdepth 1 -type d -printf '%f\n' | grep -E '^[0-9]{8}T[0-9]{6}Z$' | sort | tail -n1") -join '').Trim()
     if ($LASTEXITCODE -ne 0 -or $latest -notmatch '^\d{8}T\d{6}Z$') { throw 'No valid completed production backup found' }
 
     New-Item -ItemType Directory -Force -Path $NasBackupRoot | Out-Null

dev/ACTIVE_TASK.json

@@ -1,5 +1,5 @@
 {
-  "task_file": "dev/tasks/DEV-000096-builtin-cognitive-usage-telemetry.json",
-  "task_id": "DEV-000096",
+  "task_file": "dev/tasks/DEV-000156-fleet-execution-status-evidence.json",
+  "task_id": "DEV-000156",
   "task_revision": 1
 }

dev/tasks/DEV-000098-governance-sentinel-v2.json

@@ -0,0 +1,34 @@
+{
+  "task_id": "DEV-000098",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "b439a813e5932b1774cb3b6c2364c6cac3891314",
+  "risk_tier": "E",
+  "intent": "Implement Governance Sentinel V2 so task packets are fully validated and required governance evidence is enforced before promotion.",
+  "requirement_ids": ["WP-000", "CONSTITUTION-1.3.27", "CONSTITUTION-1.3.28"],
+  "allowed_change_scope": {
+    "modules": [],
+    "paths": ["cmd/devctl/**", ".gitea/workflows/ci.yml", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000098-governance-sentinel-v2.json"]
+  },
+  "forbidden_change_scope": {
+    "paths": ["architecture/ARCHITECTURE_CONSTITUTION.md", "architecture/CORE_SEMANTIC_MODEL_V1.md", "security/**", "database/**", "deploy/**", "modules/**", "contracts/**", "adapters/**", "platform/**"]
+  },
+  "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": ["Architecture registry", "Accepted ADR files", "Codex Task Packet JSON", "Git repository state"], "may_change": []},
+  "semantic_owner": "none-architecture-guardrail",
+  "canonical_state": [],
+  "state_transitions": ["Task packet validation returns pass or typed gap"],
+  "side_effects_and_privileges": ["Reads repository metadata and required test commands; no external mutation or secret access"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Malformed, incomplete, conflicting or unverifiable packets fail closed; checks are deterministic and rerunnable"],
+  "assumptions": ["ADR-0018 is the current accepted architecture revision", "Independent verification remains a CI/review responsibility", "docker-test remains prohibited"],
+  "acceptance_scenarios": ["Full packet fields are strictly parsed", "Allowed and forbidden scope overlap is rejected", "Architecture revision existence and base ancestry are checked", "Architecture deltas, dependencies, contracts, privileges and required tests are checked", "Tier E does not bypass validation", "CI executes the required governance checks"],
+  "required_tests": ["go test ./cmd/devctl", "go run ./cmd/devctl/independent", "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 vet ./...", "git diff --check"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000099-governance-consolidation.json

@@ -0,0 +1,26 @@
+{
+  "task_id": "DEV-000099",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "ff33a62",
+  "risk_tier": "E",
+  "intent": "Consolidate active task lineage, project status and architecture registry mirrors after the audit without changing runtime behavior or canonical ownership.",
+  "requirement_ids": ["WP-001", "ADR-0017", "Cold-agent governance reproducibility"],
+  "allowed_change_scope": {
+    "modules": [],
+    "paths": ["architecture/architecture-registry.yaml", "architecture/architecture-registry.json", "architecture/architecture-registry.md", "docs/PROJECT_STATUS.md", "docs/GOVERNANCE_LINEAGE_DECISION_2026-08-22.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000099-governance-consolidation.json", "cmd/devctl/**"]
+  },
+  "forbidden_change_scope": {"paths": ["architecture/ARCHITECTURE_CONSTITUTION.md", "architecture/adrs/**", "security/**", "database/**", "deploy/**", "modules/**", "contracts/**", "adapters/**", ".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-0017 ownership decision", "Architecture registry YAML/JSON", "Active task pointer", "Project status evidence"], "may_change": []},
+  "semantic_owner": "none-governance-projection",
+  "canonical_state": [],
+  "state_transitions": ["DEV-000098 completed -> DEV-000099 active -> DEV-000099 completed"],
+  "side_effects_and_privileges": ["Repository documentation and governance metadata only; no runtime or production mutation"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Historical checkpoints remain append-only; ambiguous lineage is recorded as a decision rather than silently rewritten"],
+  "assumptions": ["ADR-0017 remains accepted", "YAML and JSON registry are semantically equivalent authority mirrors", "docker-test remains prohibited"],
+  "acceptance_scenarios": ["Active pointer names the current packet and revision", "DEV-000073 stale lineage is explicitly resolved", "PROJECT_STATUS starts with current audit/WP-001 evidence while preserving historical checkpoints", "YAML/JSON/human registry agree on ADR-0017 ownership", "Cold agent can reconstruct current ownership and task ancestry from repository files"],
+  "required_tests": ["go test ./cmd/devctl", "go run ./cmd/devctl/independent", "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 vet ./...", "git diff --check", "registry YAML/JSON parity"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT", "BLOCKED_BY_MISSING_CAPABILITY"]
+}

dev/tasks/DEV-000100-production-recovery-repair.json

@@ -0,0 +1,22 @@
+{
+  "task_id": "DEV-000100",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "8687c9b",
+  "risk_tier": "E",
+  "intent": "Repair production backup and restore selection so only complete timestamped backups are eligible, and make provenance drift degrade readiness.",
+  "requirement_ids": ["WP-002", "INV-CONT-001", "Production recovery must be reversible"],
+  "allowed_change_scope": {"modules": [], "paths": ["deploy/verify-latest-postgres-backup.sh", "deploy/windows/Sync-PostgresBackupToNas.ps1", "deploy/windows/Test-DomovoyProductionHealth.ps1", "tests/production_recovery/**", "docs/DEPLOYMENT.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000100-production-recovery-repair.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "contracts/**", "modules/**", "cmd/**", "adapters/**", "platform/**", ".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": ["Production backup directory contract", "Deployment manifest evidence", "Production health projection"], "may_change": []},
+  "semantic_owner": "none-operational-recovery", "canonical_state": [],
+  "state_transitions": ["ineligible backup -> ignored", "verified backup -> restore candidate", "provenance/backup drift -> degraded health"],
+  "side_effects_and_privileges": ["Local script changes are read-only until explicit production verification; no secret bytes are logged"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Partial/temp/pre-* directories remain untouched and are ignored; restore checks use isolated temporary PostgreSQL only"],
+  "assumptions": ["Production host is docker.cin.su via docker-prod/docker SSH configuration", "docker-test remains prohibited"],
+  "acceptance_scenarios": ["pre-*, partial and temp directories are ignored", "latest timestamp directory is selected deterministically", "missing/hash-invalid backup is rejected", "production health is degraded on backup or deployment provenance drift", "restore verification remains isolated and cleanup-safe"],
+  "required_tests": ["shell fixture tests", "PowerShell parser", "go run ./cmd/devctl/independent", "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json", "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json", "go test ./...", "go vet ./...", "git diff --check", "production read-only health evidence"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000101-dependency-aware-readiness.json

@@ -0,0 +1,22 @@
+{
+  "task_id": "DEV-000101",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "15c9517",
+  "risk_tier": "E",
+  "intent": "Add dependency-aware readiness projections with typed degraded reasons for core, continuity, commit, cognitive and lifeboat runtimes without changing canonical ownership.",
+  "requirement_ids": ["WP-003", "Typed degraded dependency reasons", "Frontend health distinct from product readiness"],
+  "allowed_change_scope": {"modules": ["development-governance"], "paths": ["cmd/core-runtime/**", "cmd/continuity-runtime/**", "cmd/commit-runtime/**", "cmd/cognitive-worker/**", "runtime/health/**", "tests/readiness/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000101-dependency-aware-readiness.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "contracts/**", "modules/**", "adapters/**", ".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 health handlers", "Existing owner-local repository health", "Existing cognitive capability health"], "may_change": []},
+  "semantic_owner": "none-readiness-projection", "canonical_state": [],
+  "state_transitions": ["dependency available -> ready", "dependency unavailable/unknown -> typed degraded readiness"],
+  "side_effects_and_privileges": ["Read-only dependency probes; no canonical mutation, external mutation or credential expansion"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Probe timeout is UNKNOWN/DEGRADED, not false healthy; recovery returns ready on next probe"],
+  "assumptions": ["Existing /healthz endpoints remain backward compatible", "Frontend health and product readiness are separate projections", "docker-test remains prohibited"],
+  "acceptance_scenarios": ["Stopping each dependency yields the correct typed degraded reason", "DB owner connectivity is represented without cross-owner writes", "cognitive binding/model freshness and lifeboat availability are visible", "recovery returns readiness without restart", "health endpoint does not claim product readiness"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl/independent", "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", "git diff --check", "readiness dependency-stop integration tests"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000102-readiness-canary-promotion.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000102",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "3f2b008",
+  "risk_tier": "E",
+  "intent": "Promote the dependency-aware readiness implementation to a controlled production canary with explicit rollback evidence, without changing deployment topology or source contracts.",
+  "requirement_ids": ["WP-003", "Controlled canary promotion", "Production rollback evidence"],
+  "allowed_change_scope": {"modules": ["deployment-governance"], "paths": ["dev/ACTIVE_TASK.json", "dev/tasks/DEV-000102-readiness-canary-promotion.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "deploy/**", "contracts/**", "modules/**", "adapters/**", ".gitea/**", "cmd/**", "runtime/**"]},
+  "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 production compose topology", "Existing runtime health endpoints", "Existing production backup and deployment verification"], "may_change": []},
+  "semantic_owner": "none-deployment-canary",
+  "canonical_state": [],
+  "state_transitions": ["built candidate -> canary verified", "canary failure -> rollback to recorded production revision"],
+  "side_effects_and_privileges": ["Controlled production container replacement only after build/config verification; no schema, credential, or external data mutation"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Rollback target is production revision b439a813e5932b1774cb3b6c2364c6cac3891314 and recorded core image digest sha256:4fb09995df8efbbb02359e30171f593f9cf9b90489d4ac0bf85a62ed2504ac92"],
+  "assumptions": ["Production control plane is docker-prod/docker.cin.su only", "Canary is limited to readiness-capable runtime services", "Existing secrets and persistent volumes remain unchanged"],
+  "acceptance_scenarios": ["Candidate images build from 3f2b008", "Compose configuration validates without secret disclosure", "Canary readiness returns HTTP 200 with dependency checks", "Existing health and HTTPS checks remain healthy", "Rollback command and pre-canary image identity are recorded"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/devctl independent", "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", "git diff --check", "docker compose config on docker-prod", "production canary readiness and rollback verification"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000103-epistemics-truth-v1-proposal.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000103",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "6fb9184",
+  "risk_tier": "E",
+  "intent": "Prepare the proposed ADR-0019 Truth V1 boundary for review without implementing runtime, schema, connector, source or authority changes.",
+  "requirement_ids": ["WP-100", "Observation/Claim/BeliefAssessment", "Source provenance freshness conflict"],
+  "allowed_change_scope": {"modules": ["epistemics-governance"], "paths": ["docs/proposals/ADR-0019-epistemics-truth-v1.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000103-epistemics-truth-v1-proposal.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "contracts/**", "database/**", "migrations/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", "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": ["ADR-0016 Epistemics experience/reflection ownership", "ADR-0017 typed provenance references", "Core semantic model ownership boundaries"], "may_change": ["Proposed ADR-0019 only; no accepted contract changes"]},
+  "semantic_owner": "epistemics-proposal-only",
+  "canonical_state": [],
+  "state_transitions": ["observation/source evidence -> claim assessment", "assessment -> supported/corroborated/conflicted/stale/retracted/unknown", "correction -> superseding assessment"],
+  "side_effects_and_privileges": ["No runtime side effects, external mutation, connector access, credential access or authority expansion"],
+  "persistence_and_migrations": ["No schema, migration or retention job changes"],
+  "failure_retry_restart": ["Proposal failure leaves no canonical state; accepted implementation must preserve append-only evidence and rebuildable projections"],
+  "assumptions": ["Proposal is reviewed before acceptance", "Epistemics remains the only proposed truth-evidence owner", "Secrets and unapproved personal data are fail-closed"],
+  "acceptance_scenarios": ["Owner boundaries and typed references are explicit", "Unknown, assumed, stale and conflicted states cannot silently become facts", "Correction and supersession preserve history", "Freshness and coverage are separate from confidence", "No implementation or architecture registry delta is introduced"],
+  "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", "proposal scope and required-section review"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000104-agent-execution-plane-proposal.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000104",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "339f6a6",
+  "risk_tier": "E",
+  "intent": "Prepare the proposed ADR-0020 Agent Execution Plane boundary for review without implementing dispatcher, worker, schema, callback or deployment changes.",
+  "requirement_ids": ["WP-300", "Durable dispatch lease heartbeat", "Independent verification and truthful UNKNOWN outcome"],
+  "allowed_change_scope": {"modules": ["work-execution-governance"], "paths": ["docs/proposals/ADR-0020-agent-execution-plane-v1.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000104-agent-execution-plane-proposal.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "contracts/**", "database/**", "migrations/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", "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": ["ADR-0017 General Agent Delegation and Codex Bridge V1", "Proposed ADR-0019 Epistemics Truth V1", "Core semantic model Work/Capability/Artifact/Continuity boundaries"], "may_change": ["Proposed ADR-0020 only; no accepted contract changes"]},
+  "semantic_owner": "work-execution-plane-proposal-only",
+  "canonical_state": [],
+  "state_transitions": ["dispatch -> leased -> running -> result -> independently verified", "lease expiry/callback uncertainty -> UNKNOWN or RECOVERING", "cancel request -> acknowledged cancellation or typed unknown"],
+  "side_effects_and_privileges": ["No runtime side effects, external mutation, connector access, credential access or authority expansion"],
+  "persistence_and_migrations": ["No schema, migration, queue, worker or lease implementation changes"],
+  "failure_retry_restart": ["Retry creates a new run and preserves history; late or duplicate callbacks cannot become authoritative"],
+  "assumptions": ["Work remains canonical owner of durable delegation execution", "Artifact remains canonical owner of attestation metadata", "Production deployment remains outside this proposal"],
+  "acceptance_scenarios": ["Worker identity and dispatch idempotency are explicit", "Lease fencing and heartbeat expiry are explicit", "Callback authentication/replay handling is explicit", "Cancellation/retry/UNKNOWN semantics preserve history", "Independent verification gates Work completion", "No implementation or registry delta is introduced"],
+  "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", "proposal scope and required-section review"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000105-multi-agent-work-graph-proposal.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000105",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "82ee6e5",
+  "risk_tier": "E",
+  "intent": "Prepare the proposed ADR-0021 Multi-Agent Work Graph boundary for review without implementing a scheduler, graph schema, workers or production changes.",
+  "requirement_ids": ["WP-400", "DAG revision and budgets", "Fan-out/fan-in conflict and independent verification"],
+  "allowed_change_scope": {"modules": ["work-graph-governance"], "paths": ["docs/proposals/ADR-0021-multi-agent-work-graph-v1.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000105-multi-agent-work-graph-proposal.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "contracts/**", "database/**", "migrations/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", "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": ["ADR-0017 delegation ownership", "Proposed ADR-0020 Agent Execution Plane", "Proposed ADR-0019 Truth V1 provenance", "Core Work/Capability/Artifact/Continuity ownership"], "may_change": ["Proposed ADR-0021 only; no accepted contract changes"]},
+  "semantic_owner": "work-graph-proposal-only",
+  "canonical_state": [],
+  "state_transitions": ["graph draft -> admitted -> running -> verifying -> completed/partial/failed", "node prerequisite blocked -> ready -> leased/running -> result or recovery", "candidate disagreement -> conflict set -> verified synthesis or unresolved conflict"],
+  "side_effects_and_privileges": ["No runtime side effects, external mutation, connector access, credential access or authority expansion"],
+  "persistence_and_migrations": ["No graph schema, scheduler, queue, lease or migration implementation changes"],
+  "failure_retry_restart": ["Graph revisions are immutable; restart/replay uses durable history; unknown outcomes block unsafe replay"],
+  "assumptions": ["Work remains canonical graph owner", "Roles are capability profiles without authority", "Independent verification is required before Work completion"],
+  "acceptance_scenarios": ["Cycles are rejected before admission", "Budgets cover graph/user/resource concurrency and attempts", "Fan-out/fan-in and partial failure preserve attribution", "Cancellation/pause/resume/restart semantics are explicit", "Conflicts retain dissent and verifier identity is distinct", "No implementation or registry delta is introduced"],
+  "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", "proposal scope and required-section review"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000106-governed-self-development-proposal.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000106",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "08deab8",
+  "risk_tier": "E",
+  "intent": "Prepare the proposed ADR-0022 Governed Self-Development boundary for review without implementing proposal generation, factories, candidate activation or production changes.",
+  "requirement_ids": ["WP-600", "Governed development control plane", "Candidate canary promotion rollback emergency stop"],
+  "allowed_change_scope": {"modules": ["governed-development-proposal"], "paths": ["docs/proposals/ADR-0022-governed-self-development-v1.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000106-governed-self-development-proposal.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "contracts/**", "database/**", "migrations/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", "deploy/**", ".gitea/**", "skills/**"]},
+  "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-0016 Experience/Reflection/Skill Evolution", "Proposed ADR-0019 Truth V1 evidence", "Proposed ADR-0020 Agent Execution Plane", "Proposed ADR-0021 Work Graph", "existing Authority/Commit/Artifact boundaries"], "may_change": ["Proposed ADR-0022 only; no accepted contract changes"]},
+  "semantic_owner": "governed-development-proposal-only",
+  "canonical_state": [],
+  "state_transitions": ["evidence -> proposal -> sandbox -> evaluation -> canary -> promotion/rollback/retirement", "failed/conflicted/incomplete evaluation -> blocked"],
+  "side_effects_and_privileges": ["No runtime side effects, source mutation, deployment, external mutation, credential access or authority expansion"],
+  "persistence_and_migrations": ["No proposal store, candidate artifact store, schema, migration or telemetry implementation changes"],
+  "failure_retry_restart": ["Candidate evidence and lineage survive rejection/rollback; emergency stop disables candidate selection without deleting history"],
+  "assumptions": ["Human governance remains promotion authority", "Protected paths and secret policies cannot be modified by the control plane", "New code/model/skill never receives authority automatically"],
+  "acceptance_scenarios": ["One failure cannot create a proposal", "Candidate lineage and isolated scope are mandatory", "Independent evaluation and verifier are explicit", "Canary and rollback preserve previous implementation and evidence", "Emergency stop blocks candidate traffic", "No implementation or registry delta is introduced"],
+  "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", "proposal scope and required-section review"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000107-context-compiler-v1.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000107",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "3e0be62",
+  "risk_tier": "E",
+  "intent": "Implement a typed context compiler for relevance, sensitivity, provenance and byte budgets at the cognitive contract boundary.",
+  "requirement_ids": ["WP-101", "Typed context bundle", "Sensitivity/egress filtering and budget"],
+  "allowed_change_scope": {"modules": ["cognitive-contracts"], "paths": ["contracts/cognitive/**", "tests/context_compiler/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000107-context-compiler-v1.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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 ContextExcerpt and Gateway request boundary", "Capability DataPolicy values"], "may_change": ["Cognitive context bundle/compiler contract"]},
+  "semantic_owner": "cognitive-context-contract",
+  "canonical_state": [],
+  "state_transitions": ["candidate excerpts -> selected typed context bundle", "budget/sensitivity decision -> included or omitted with reason"],
+  "side_effects_and_privileges": ["Pure deterministic compilation; no provider call, persistence, external mutation or credential access"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Compilation is deterministic and repeatable; empty permitted context remains a valid bundle"],
+  "assumptions": ["Gateway remains responsible for provider selection", "Secret and unknown excerpts are never emitted", "Provider identity remains invocation provenance"],
+  "acceptance_scenarios": ["Relevant excerpts are selected deterministically", "Duplicate and low-value excerpts do not consume budget", "Secret/unknown data is omitted", "External minimized policy excludes private data", "UTF-8 byte budget is respected", "Provider identity is not represented as persona"],
+  "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", "context compiler tests"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000108-context-compiler-gateway-integration.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000108",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "879de3b",
+  "risk_tier": "E",
+  "intent": "Use the typed context compiler for local chat cognition with the canonical active-project focus, keeping external advisory context empty unless explicitly supplied by a future policy-aware path.",
+  "requirement_ids": ["WP-101", "Follow-up context", "Active project isolation"],
+  "allowed_change_scope": {"modules": ["creator-gateway", "cognitive-contracts"], "paths": ["cmd/creator-web/**", "contracts/cognitive/**", "tests/context_compiler/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000108-context-compiler-gateway-integration.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "runtime/**", "adapters/**", ".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": ["ContextBundle compiler from DEV-000107", "Core ChatMessageResponse active project fields", "Existing local cognitive gateway request"], "may_change": ["Creator gateway context assembly"]},
+  "semantic_owner": "creator-gateway-context-projection",
+  "canonical_state": [],
+  "state_transitions": ["canonical active project -> local context candidate -> compiled gateway context", "missing active project -> empty context"],
+  "side_effects_and_privileges": ["Context assembly is read-only; no persistence, provider selection, credential access or external mutation"],
+  "persistence_and_migrations": ["No database schema or migration changes"],
+  "failure_retry_restart": ["Compiler failure or absent focus yields empty context and preserves the existing chat fallback"],
+  "assumptions": ["External advisory remains message-only until a separate policy-aware context path exists", "Active project name is already canonicalized by Core", "Current project context is not reused for unrelated requests"],
+  "acceptance_scenarios": ["Local cognitive request receives the active project as provenance-bearing context", "No active project yields empty context", "External advisory receives no implicit private context", "Project context does not leak into a different saved response", "Existing creator gateway and full tests remain green"],
+  "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", "context compiler gateway integration tests"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000109-research-citation-contracts.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000109",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "e3b55c9",
+  "risk_tier": "E",
+  "intent": "Add typed read-only research and citation evidence contracts for plans, source snapshots, excerpts and freshness/conflict state without connecting external sources.",
+  "requirement_ids": ["WP-102", "Source snapshot and citation resolver", "UNKNOWN/ASSUMPTION freshness conflict"],
+  "allowed_change_scope": {"modules": ["epistemics-research-contracts"], "paths": ["contracts/epistemics/**", "tests/research_contracts/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000109-research-citation-contracts.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["Proposed ADR-0019 Truth V1 evidence/provenance", "Existing Epistemics owner", "Existing Artifact typed reference boundary"], "may_change": ["Epistemics research/citation contract"]},
+  "semantic_owner": "epistemics-research-contract",
+  "canonical_state": [],
+  "state_transitions": ["research plan -> source snapshot -> excerpt -> citation", "source conflict/freshness result -> explicit claim status"],
+  "side_effects_and_privileges": ["Typed value validation only; no connector calls, external mutation, credentials or persistence"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Unknown source/retrieval state is retained as UNKNOWN and cannot become a citation silently"],
+  "assumptions": ["Connectors and durable storage arrive in later tasks", "Citation references an exact excerpt identity and snapshot", "Research output is read-only evidence"],
+  "acceptance_scenarios": ["Plan identifies question, source classes and freshness policy", "Snapshot has content digest and retrieval timestamp", "Citation requires exact excerpt and source snapshot", "stale/conflicted/unknown states remain explicit", "assumption is distinguishable from observed evidence"],
+  "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", "research contract tests"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000110-citation-resolver.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000110",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "dc7f7b3",
+  "risk_tier": "E",
+  "intent": "Add a deterministic citation resolver that requires a matching source, immutable snapshot and exact excerpt before producing citation evidence.",
+  "requirement_ids": ["WP-102", "Citation resolver", "No fabricated excerpts"],
+  "allowed_change_scope": {"modules": ["epistemics-research-contracts"], "paths": ["contracts/epistemics/**", "tests/research_contracts/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000110-citation-resolver.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["DEV-000109 research/citation contracts", "Epistemics source snapshot and excerpt types"], "may_change": ["Citation resolution helper"]},
+  "semantic_owner": "epistemics-research-contract",
+  "canonical_state": [],
+  "state_transitions": ["source/snapshot/excerpt evidence -> resolved citation", "mismatched evidence -> resolution error"],
+  "side_effects_and_privileges": ["Pure deterministic validation; no connector calls, persistence, external mutation or credential access"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Resolution is repeatable; failed resolution produces no citation"],
+  "assumptions": ["Source snapshots are immutable identifiers", "Exact excerpt offsets and text are supplied by a connector later", "Unknown/stale/conflicted evidence stays visible"],
+  "acceptance_scenarios": ["Matching source chain resolves", "Wrong source/snapshot/excerpt is rejected", "Invalid offsets are rejected", "Citation preserves stale/conflict/assumed state", "No fabricated excerpt can resolve"],
+  "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", "citation resolver tests"],
+  "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000111-hardware-model-inventory-evidence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000111",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "aec63de",
+  "risk_tier": "E",
+  "intent": "Record read-only production hardware and model inventory evidence for WP-200 without changing model bindings or deployment.",
+  "requirement_ids": ["WP-200", "Hardware/model inventory", "GPU/VRAM and protected runtime evidence"],
+  "allowed_change_scope": {"modules": ["model-qualification-evidence"], "paths": ["docs/evidence/WP-200-HARDWARE-MODEL-INVENTORY-2026-08-22.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000111-hardware-model-inventory-evidence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["WP-200 audit requirements", "Production docker-prod read-only inventory"], "may_change": []},
+  "semantic_owner": "model-qualification-evidence",
+  "canonical_state": [],
+  "state_transitions": ["unqualified inventory -> evidence recorded -> qualification decision pending"],
+  "side_effects_and_privileges": ["Read-only SSH/docker inspection only; no model activation, deployment, credential access or production mutation"],
+  "persistence_and_migrations": ["Evidence document only; no database changes"],
+  "failure_retry_restart": ["Missing GPU/model evidence remains UNKNOWN and blocks heavy qualification"],
+  "assumptions": ["docker-prod/docker.cin.su is the only production target", "GPU absence on this host does not prove absence on every external host", "Model qualification requires separate holdout/latency/license evidence"],
+  "acceptance_scenarios": ["CPU/RAM/storage/network inventory recorded", "GPU/VRAM/runtime evidence recorded", "Healthy cognitive/lifeboat containers identified without secret output", "Heavy model remains unqualified until GPU/license evidence exists"],
+  "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", "production read-only inventory commands"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000112-model-qualification-manifest.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000112",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "93bc4a0",
+  "risk_tier": "E",
+  "intent": "Add an immutable model qualification manifest contract and validation for holdout, latency, resource, license and restart evidence without activating a model.",
+  "requirement_ids": ["WP-201", "Qualification evidence manifest", "No activation from model name alone"],
+  "allowed_change_scope": {"modules": ["capability-model-qualification"], "paths": ["contracts/capability/**", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000112-model-qualification-manifest.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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 Capability model descriptor/evaluation types", "WP-201 audit acceptance"], "may_change": ["Capability qualification evidence manifest contract"]},
+  "semantic_owner": "capability-model-qualification",
+  "canonical_state": [],
+  "state_transitions": ["candidate model -> measured -> evidence complete/incomplete -> qualification decision pending"],
+  "side_effects_and_privileges": ["Pure validation; no provider call, model activation, deployment, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Incomplete or stale manifest remains unqualified; rerun creates a new manifest revision"],
+  "assumptions": ["A model digest and provider revision identify the tested artifact", "License/data policy evidence is explicit", "Qualification is separate from activation"],
+  "acceptance_scenarios": ["Manifest binds model revision and digest", "Holdout corpus and all required dimensions are recorded", "Latency/concurrency/resource/restart evidence is present", "License and data policy are present", "Incomplete manifest cannot claim validated"],
+  "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", "model qualification manifest tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000113-model-qualification-gate.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000113",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "1f01b70",
+  "risk_tier": "E",
+  "intent": "Add a deterministic qualification gate that maps complete supported evidence to VALIDATED and incomplete/unsupported evidence to REJECTED without changing activation.",
+  "requirement_ids": ["WP-201", "Qualification decision", "GPU/resource evidence cannot be inferred"],
+  "allowed_change_scope": {"modules": ["capability-model-qualification"], "paths": ["contracts/capability/**", "tests/model_qualification/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000113-model-qualification-gate.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "modules/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["QualificationManifest from DEV-000112", "Existing QualificationState and EvaluationResult values"], "may_change": ["Qualification gate projection"]},
+  "semantic_owner": "capability-model-qualification",
+  "canonical_state": [],
+  "state_transitions": ["complete supported manifest -> VALIDATED", "incomplete/unsupported/unknown manifest -> REJECTED"],
+  "side_effects_and_privileges": ["Pure validation; no binding activation, provider call, deployment, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Gate is deterministic; a new manifest revision is required after new measurements"],
+  "assumptions": ["Qualification and activation remain separate lifecycle decisions", "All required dimensions are mandatory", "Model names never substitute for evidence"],
+  "acceptance_scenarios": ["All supported measurements produce VALIDATED", "Unsupported resource/restart result produces REJECTED", "Unknown measurement produces REJECTED", "Gate does not mutate binding activation"],
+  "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", "qualification gate tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000114-run-liveness-assessment.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000114",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "a65ee37",
+  "risk_tier": "E",
+  "intent": "Add deterministic AgentRun liveness assessment for stale-run recovery without requeueing or mutating production records.",
+  "requirement_ids": ["WP-302", "Heartbeat timeout", "Typed stale evidence"],
+  "allowed_change_scope": {"modules": ["work-recovery"], "paths": ["modules/work/domain/**", "contracts/work/**", "tests/work_recovery/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000114-run-liveness-assessment.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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 Work AgentRun lifecycle", "ADR-0017 delegation ownership"], "may_change": ["Work recovery liveness projection"]},
+  "semantic_owner": "work-recovery",
+  "canonical_state": [],
+  "state_transitions": ["run timestamp evidence -> LIVE/STALE/INVALID", "stale evidence -> recovery decision pending"],
+  "side_effects_and_privileges": ["Pure assessment; no requeue, resume, cancellation, persistence or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Clock/invalid timestamps produce INVALID rather than stale or healthy"],
+  "assumptions": ["UpdatedAt is the latest durable heartbeat/checkpoint projection available", "Recovery policy chooses the next action separately", "RUNNING alone is not proof of liveness"],
+  "acceptance_scenarios": ["Recent run is LIVE", "Old running run is STALE with age", "Completed/blocked run is not stale", "Invalid clock/timestamp is INVALID", "No production state changes"],
+  "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", "run liveness tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000115-cognitive-admission-control.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000115",
+  "task_revision": 6,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "9b26260",
+  "risk_tier": "E",
+  "intent": "Run bounded cognitive admission as a durable capability-owner lease with restart recovery, while preserving provider routing and explicit fallback.",
+  "requirement_ids": ["WP-203", "Bounded concurrency/rate limits", "Durable admission lease", "Explainable admission decision"],
+  "allowed_change_scope": {"modules": ["cognitive-admission", "core-runtime", "cognitive-worker", "deployment"], "paths": ["contracts/capability/**", "adapters/postgres/capability_repository.go", "database/migrations/033_cognitive_admission_leases.sql", "cmd/core-runtime/main.go", "cmd/cognitive-worker/**", "deploy/docker-compose.prod.yml", "deploy/apply-migrations.sh", "tests/cognitive_admission/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000115-cognitive-admission-control.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "modules/authority/**", "modules/work/**", ".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": 1},
+  "contracts": {"consume": ["Existing cognitive capability registry and LimitPolicyRef", "ADR-0006 bounded advisory boundary", "capability-owned PostgreSQL schema"], "may_change": ["Typed admission request/policy/decision and lease contract"]},
+  "semantic_owner": "capability-cognitive-admission",
+  "canonical_state": ["capability.cognitive_admission_counters", "capability.cognitive_admission_leases"],
+  "state_transitions": ["request + policy + durable counters -> admitted lease or typed rejection", "active lease -> released/expired"],
+  "side_effects_and_privileges": ["Capability database role only; internal core endpoint; provider calls remain behind cognitive gateway"],
+  "persistence_and_migrations": ["database/migrations/033_cognitive_admission_leases.sql", "deploy/apply-migrations.sh records applied migration IDs and is idempotent"],
+  "failure_retry_restart": ["Expired leases are recovered on next admission transaction; duplicate request IDs are idempotent; rejected requests fall back locally"],
+  "assumptions": ["Core Runtime remains the capability-owner admission boundary", "Policy does not choose or activate providers", "Deadline and budgets are request requirements"],
+  "acceptance_scenarios": ["Concurrency limit rejects excess request", "Accepted/hour limit rejects excess request", "Deadline and byte budget reject invalid request", "Admitted decision exposes reason and policy reference", "expired lease does not permanently block after restart", "cognitive worker uses admission before provider and releases lease"],
+  "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", "compose config", "admission policy and HTTP boundary tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000116-agent-lease-fencing.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000116",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "cb92f95",
+  "risk_tier": "E",
+  "intent": "Add typed durable-agent lease and fencing-token transitions for worker start/heartbeat without implementing a dispatcher or persistence adapter.",
+  "requirement_ids": ["WP-301", "Worker lease confirms actual start", "Heartbeat fencing"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["contracts/work/**", "modules/work/domain/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000116-agent-lease-fencing.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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-0017 delegation/run ownership", "Proposed ADR-0020 Agent Execution Plane", "Existing Work AgentRun identity"], "may_change": ["Work agent lease/fencing contract"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": [],
+  "state_transitions": ["dispatch -> lease acquired -> heartbeat renewed", "wrong worker/token/expired lease -> rejected callback"],
+  "side_effects_and_privileges": ["Pure transition helper; no queue, persistence, worker process, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Fencing token changes on a new lease; late old-token heartbeat is rejected"],
+  "assumptions": ["A durable repository will persist the lease atomically later", "Lease acquisition is separate from process-local execution", "Worker identity is authenticated by a later adapter boundary"],
+  "acceptance_scenarios": ["Valid worker acquires lease", "Matching worker renews before expiry", "Wrong worker/token rejected", "Expired lease cannot renew", "New token fences old run"],
+  "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", "agent lease tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000117-agent-callback-envelope.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000117",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "9766e53",
+  "risk_tier": "E",
+  "intent": "Add typed callback envelope validation for authenticated worker identity, fencing token, monotonic sequence and lease freshness.",
+  "requirement_ids": ["WP-301", "Callback auth binding", "Forged/out-of-order result rejection"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["contracts/work/**", "modules/work/domain/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000117-agent-callback-envelope.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["AgentLease/fencing contract from DEV-000116", "ADR-0020 callback ordering boundary"], "may_change": ["Agent callback envelope contract"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": [],
+  "state_transitions": ["lease + callback envelope -> accepted callback", "wrong identity/token/sequence/expiry -> rejected callback"],
+  "side_effects_and_privileges": ["Pure validation; no transport, persistence, result mutation or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Duplicate and late callbacks are rejected by sequence/fencing; accepted sequence is persisted later by adapter"],
+  "assumptions": ["Transport authenticates worker identity before this validation", "Sequence is monotonic within a run and lease token", "Result verification remains a separate step"],
+  "acceptance_scenarios": ["Matching heartbeat accepted", "Wrong worker/token rejected", "Duplicate/out-of-order sequence rejected", "Expired lease rejected", "Callback run mismatch rejected"],
+  "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", "agent callback tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000118-agent-artifact-attestation.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000118",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "a6eb4ab",
+  "risk_tier": "E",
+  "intent": "Add typed artifact attestation for agent-produced evidence with digest, source/worktree, producer run and test provenance.",
+  "requirement_ids": ["WP-301", "Artifact attestation", "Independent evidence refs"],
+  "allowed_change_scope": {"modules": ["artifact-agent-evidence"], "paths": ["contracts/artifact/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000118-agent-artifact-attestation.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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-0017 Artifact ownership", "ADR-0020 agent evidence attestation", "Existing AgentRun identity"], "may_change": ["Artifact agent attestation contract"]},
+  "semantic_owner": "artifact-agent-evidence",
+  "canonical_state": [],
+  "state_transitions": ["agent output -> attested artifact evidence", "missing provenance -> non-attested result"],
+  "side_effects_and_privileges": ["Pure validation; no filesystem access, merge, deployment, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Attestation is immutable; changed digest/source requires a new attestation"],
+  "assumptions": ["Artifact storage computes or verifies digest later", "Producer run and source revision are durable refs", "Verifier remains distinct from producer"],
+  "acceptance_scenarios": ["Complete attestation validates", "Missing digest/source/worktree/test evidence rejects", "Attestation binds to one producer run", "Changed artifact requires a new attestation"],
+  "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", "artifact attestation tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000119-independent-verification-contract.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000119",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "02b472b",
+  "risk_tier": "E",
+  "intent": "Add independent verification contract requiring a distinct verifier identity/run and attested artifact evidence before Work completion.",
+  "requirement_ids": ["WP-301", "Independent verifier", "Work completion gate"],
+  "allowed_change_scope": {"modules": ["work-agent-verification"], "paths": ["contracts/work/**", "modules/work/domain/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000119-independent-verification-contract.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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-0017 verification separation", "ADR-0020 independent verifier", "Agent artifact attestation from DEV-000118"], "may_change": ["Work independent verification contract"]},
+  "semantic_owner": "work-agent-verification",
+  "canonical_state": [],
+  "state_transitions": ["producer result + attestation -> verifier assessment -> verified/rejected"],
+  "side_effects_and_privileges": ["Pure validation; no merge, deployment, binding activation, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Rejected verification preserves producer evidence; a new verifier run is required"],
+  "assumptions": ["Verifier identity and run are authenticated later", "Producer and verifier cannot be the same run", "Artifact evidence is immutable"],
+  "acceptance_scenarios": ["Distinct verifier validates attested artifact", "Same run is rejected", "Missing artifact/test evidence is rejected", "Rejected verification does not erase producer result"],
+  "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", "independent verification tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000120-agent-dispatch-intent.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000120",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "04dad79",
+  "risk_tier": "E",
+  "intent": "Add typed durable dispatch intent and idempotency contract for agent runs without implementing a dispatcher, queue or worker process.",
+  "requirement_ids": ["WP-301", "Durable dispatch", "Duplicate dispatch prevention"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["contracts/work/**", "modules/work/domain/**", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000120-agent-dispatch-intent.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "database/**", "migrations/**", "deploy/**", "security/**", "cmd/**", "runtime/**", "adapters/**", ".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-0017 delegation/run ownership", "ADR-0020 dispatch idempotency", "Existing Capability implementation identity"], "may_change": ["Work dispatch intent contract"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": [],
+  "state_transitions": ["dispatch intent -> accepted once by idempotency key -> lease acquisition", "same idempotency key -> same dispatch identity"],
+  "side_effects_and_privileges": ["Pure validation; no queue, process start, persistence adapter, credential access or external mutation"],
+  "persistence_and_migrations": ["No schema or migration changes"],
+  "failure_retry_restart": ["Retry reuses intent identity only when the durable store confirms the same payload; changed payload requires a new key"],
+  "assumptions": ["Dispatcher persists intent atomically later", "Exact source/worktree is resolved before worker start", "Verification plan is part of dispatch provenance"],
+  "acceptance_scenarios": ["Complete dispatch validates", "Missing idempotency/source/worktree/verification plan rejects", "Payload identity is explicit", "Worker implementation is typed and not inferred from free text"],
+  "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", "dispatch intent tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000121-agent-execution-persistence.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000121",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "f792d20",
+  "risk_tier": "E",
+  "intent": "Add work-owned durable persistence schema for dispatch intents, leases and callback sequence heads, with repository write boundaries.",
+  "requirement_ids": ["WP-301", "Durable dispatch persistence", "Atomic lease/fencing state"],
+  "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage"], "paths": ["database/migrations/029_work_agent_execution_persistence.sql", "adapters/postgres/work_repository.go", "tests/agent_execution/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000121-agent-execution-persistence.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/continuity*", "adapters/capability*", ".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": ["DEV-000120 dispatch intent", "DEV-000116 lease/fencing", "DEV-000117 callback sequence"], "may_change": ["Work-owned persistence schema and repository methods"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.agent_dispatch_intents", "work.agent_leases", "work.agent_callback_heads"],
+  "state_transitions": ["dispatch intent persisted idempotently", "lease acquired/renewed with fencing token", "callback sequence advanced atomically"],
+  "side_effects_and_privileges": ["Work schema writes only through Work repository; no cross-owner SQL"],
+  "persistence_and_migrations": ["Append-only migration 029; work_role only"],
+  "failure_retry_restart": ["Duplicate idempotency key is reconciled; lease conflict is rejected; callback sequence uses row lock/conditional update"],
+  "assumptions": ["Migration is reviewed and applied before runtime enablement", "Production deployment is a later canary task", "No secrets are stored in dispatch payload"],
+  "acceptance_scenarios": ["Duplicate dispatch cannot create a second intent", "Expired/wrong lease cannot advance", "Out-of-order callback sequence is rejected", "Work owner boundaries remain intact"],
+  "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", "migration/repository tests"],
+  "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000122-agent-dry-run-dispatch.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000122",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "8081b4d",
+  "risk_tier": "E",
+  "intent": "Implement an opt-in deterministic dry-run dispatcher and fake worker cycle over the Agent Execution Plane contracts.",
+  "requirement_ids": ["WP-301", "Dry-run dispatcher", "Deterministic fake worker"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["contracts/work/dry_run_dispatch.go", "modules/work/domain/dry_run_dispatch.go", "tests/agent_execution/dry_run_dispatch_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000122-agent-dry-run-dispatch.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/**", "database/**", ".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": ["DEV-000120 dispatch intent", "DEV-000116 lease/fencing", "DEV-000117 callback sequence"], "may_change": ["Dry-run dispatch result value" ]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["DryRunDispatch value; no production state"],
+  "state_transitions": ["validated intent -> deterministic lease -> heartbeat callback -> result callback"],
+  "side_effects_and_privileges": ["Pure domain construction only; no external mutation"],
+  "persistence_and_migrations": ["Uses DEV-000121 persistence contract but does not apply migration"],
+  "failure_retry_restart": ["Invalid intent, worker, token, time or TTL is rejected"],
+  "assumptions": ["Runtime dispatcher and production worker remain separate follow-up work"],
+  "acceptance_scenarios": ["Same input produces byte-for-byte equivalent typed output", "Invalid intent is rejected", "Callbacks are ordered and inside lease window"],
+  "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"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000123-agent-dry-run-orchestration.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000123",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "fa62322",
+  "risk_tier": "E",
+  "intent": "Connect the opt-in deterministic dry-run dispatcher to a narrow Work-owned execution persistence port and application coordinator.",
+  "requirement_ids": ["WP-301", "Work execution port", "Dry-run orchestration"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["modules/work/ports/execution.go", "modules/work/application/dry_run_dispatch.go", "tests/agent_execution/dry_run_orchestration_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000123-agent-dry-run-orchestration.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/**", "database/**", ".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": ["DEV-000121 persistence methods", "DEV-000122 dry-run dispatch"], "may_change": ["Work execution port and application coordinator"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["Persistence remains owned by Work repository"],
+  "state_transitions": ["dispatch intent -> lease -> ordered callbacks"],
+  "side_effects_and_privileges": ["Explicit Work-owned port only; no runtime entrypoint or production enablement"],
+  "persistence_and_migrations": ["Reuses DEV-000121 schema; no migration"],
+  "failure_retry_restart": ["Idempotent repository methods make retries safe; partial failure is returned to caller"],
+  "assumptions": ["Production dispatcher remains disabled until a separate runtime canary task"],
+  "acceptance_scenarios": ["All persistence operations are invoked in deterministic order", "Invalid dispatch never reaches the store"],
+  "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"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000124-agent-canary-gate.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000124",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "7f82240",
+  "risk_tier": "E",
+  "intent": "Add an explicit opt-in canary gate for the dry-run agent dispatcher with implementation allowlist and bounded dispatch count.",
+  "requirement_ids": ["WP-301", "Opt-in canary", "Bounded dispatch"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["modules/work/application/canary.go", "tests/agent_execution/canary_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000124-agent-canary-gate.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/**", "database/**", ".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": ["DEV-000123 dry-run orchestration"], "may_change": ["Canary configuration and gate errors"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["Canary configuration is caller-owned; dispatch state remains Work-owned"],
+  "state_transitions": ["disabled/unauthorized/limited -> rejected; enabled and allowed -> dry-run orchestration"],
+  "side_effects_and_privileges": ["No side effect before all canary gates pass"],
+  "persistence_and_migrations": ["Reuses existing persistence; no migration"],
+  "failure_retry_restart": ["Caller receives typed gate failure; retries remain bounded by used dispatch count"],
+  "assumptions": ["Runtime wiring and production configuration are separate follow-up work"],
+  "acceptance_scenarios": ["Disabled canary writes nothing", "Wrong implementation writes nothing", "Limit is enforced", "Allowed canary persists four 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"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000125-agent-canary-cli.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000125",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "d2338b1",
+  "risk_tier": "E",
+  "intent": "Add a manually invoked CLI harness for the opt-in deterministic agent canary using an in-memory store.",
+  "requirement_ids": ["WP-301", "Manual canary entrypoint", "Dry-run verification"],
+  "allowed_change_scope": {"modules": ["work-agent-execution"], "paths": ["cmd/agent-canary/main.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000125-agent-canary-cli.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "runtime/**", "adapters/**", "database/**", ".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": ["DEV-000124 canary gate"], "may_change": ["Manual CLI entrypoint"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["No durable state; in-memory canary evidence only"],
+  "state_transitions": ["CLI flags -> canary gate -> deterministic callbacks -> JSON summary"],
+  "side_effects_and_privileges": ["No network, database, deployment or production mutation"],
+  "persistence_and_migrations": ["Explicitly does not use production repository"],
+  "failure_retry_restart": ["Disabled or unauthorized invocation exits nonzero without writes"],
+  "assumptions": ["Real WorkRepository wiring requires a separate approved runtime task"],
+  "acceptance_scenarios": ["Default invocation is rejected", "Explicit enablement produces JSON summary", "No secrets or external connections are required"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/agent-canary", "go run ./cmd/agent-canary -enable-canary", "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"],
+  "terminal_gap_states": ["BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000126-agent-canary-repository.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000126",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "c30e0c7",
+  "risk_tier": "E",
+  "intent": "Wire the manual agent canary CLI to the existing Work PostgreSQL repository behind an explicit flag while preserving in-memory default behavior.",
+  "requirement_ids": ["WP-301", "Repository canary wiring", "Credential-safe adapter use"],
+  "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage"], "paths": ["cmd/agent-canary/main.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000126-agent-canary-repository.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "runtime/**", "database/**", ".gitea/**"]},
+  "allowed_architecture_delta": {"new_cross_module_dependencies": 1, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_database_owner_roles": 0},
+  "contracts": {"consume": ["DEV-000125 manual canary CLI", "DEV-000121 WorkRepository methods"], "may_change": ["Manual CLI storage selection"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["WorkRepository remains canonical for postgres mode"],
+  "state_transitions": ["CLI -postgres -> OpenWork -> canary coordinator -> repository writes"],
+  "side_effects_and_privileges": ["Only explicit -postgres mode connects; credentials come from existing environment variables and are never printed"],
+  "persistence_and_migrations": ["Requires migration 029 to be applied separately; this task does not apply migrations"],
+  "failure_retry_restart": ["Connection or missing migration errors are returned; no automatic retry or deployment"],
+  "assumptions": ["Default mode remains in-memory and production entrypoints are unchanged"],
+  "acceptance_scenarios": ["Default mode remains deterministic", "Postgres mode uses Work repository through ExecutionStore", "No secret values appear in output"],
+  "required_tests": ["go test ./...", "go vet ./...", "go run ./cmd/agent-canary", "go run ./cmd/agent-canary -enable-canary", "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"],
+  "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000127-apply-agent-execution-migration.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000127",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "8e26826",
+  "risk_tier": "E",
+  "intent": "Apply the already reviewed additive Work migration 029 on the canonical docker-prod PostgreSQL instance for controlled canary preparation.",
+  "requirement_ids": ["WP-301", "Migration canary", "Durable execution readiness"],
+  "allowed_change_scope": {"modules": ["work-storage"], "paths": ["dev/ACTIVE_TASK.json", "dev/tasks/DEV-000127-apply-agent-execution-migration.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", "adapters/**", ".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": ["DEV-000121 migration 029", "DEV-000126 repository wiring"], "may_change": ["Canonical production Work schema state"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["docker-prod assistant PostgreSQL work schema"],
+  "state_transitions": ["tables absent -> tables present and verified"],
+  "side_effects_and_privileges": ["One additive transactional migration through existing bootstrap/superuser path; no secrets printed"],
+  "persistence_and_migrations": ["Apply database/migrations/029_work_agent_execution_persistence.sql exactly once"],
+  "failure_retry_restart": ["ON CONFLICT-safe DDL; ON_ERROR_STOP; verify before any retry"],
+  "assumptions": ["docker-prod is the canonical target", "migration file is already committed and reviewed", "runtime remains disabled until a later canary"],
+  "acceptance_scenarios": ["All three Work tables exist after apply", "No non-Work schema changes", "Existing production containers remain running"],
+  "required_tests": ["go test ./...", "go vet ./...", "preflight", "check-diff", "check-architecture", "independent", "pre-apply table absence evidence", "migration apply exit 0", "post-apply table existence verification", "docker-prod container health read-only check", "git diff --check"],
+  "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000128-agent-canary-compose-profile.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000128",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "790fd7e",
+  "risk_tier": "E",
+  "intent": "Add an explicitly profiled production compose service for the manual agent canary container.",
+  "requirement_ids": ["WP-301", "Canary container profile", "Disabled-by-default runtime"],
+  "allowed_change_scope": {"modules": ["work-agent-execution", "production-compose"], "paths": ["deploy/docker-compose.prod.yml", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000128-agent-canary-compose-profile.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "database/**", "runtime/**", "adapters/**", ".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": ["DEV-000126 agent-canary postgres mode", "DEV-000127 migration 029"], "may_change": ["Production compose canary profile"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["No new state; uses Work schema"],
+  "state_transitions": ["profile absent -> explicit profile service available; default stack unchanged"],
+  "side_effects_and_privileges": ["Credential environment is injected by deployment system; service is disabled unless profile is explicitly selected"],
+  "persistence_and_migrations": ["Requires migration 029 already present; no migration in this task"],
+  "failure_retry_restart": ["restart=no; one bounded canary invocation"],
+  "assumptions": ["Deployment of this profile is a separate approved canary action", "No normal service depends on agent-canary"],
+  "acceptance_scenarios": ["Compose validates", "Default config does not start agent-canary", "Profile builds target cmd/agent-canary", "No secret literal is added"],
+  "required_tests": ["go test ./...", "go vet ./...", "docker compose -f deploy/docker-compose.prod.yml config --quiet", "preflight", "check-diff", "check-architecture", "independent", "git diff --check"],
+  "terminal_gap_states": ["BLOCKED_BY_DEPLOYMENT_DECISION", "BLOCKED_BY_CONFLICT"]
+}

dev/tasks/DEV-000129-agent-dispatch-queue.json

@@ -0,0 +1,23 @@
+{
+  "task_id": "DEV-000129",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0018",
+  "base_repo_revision": "bab96b7",
+  "risk_tier": "E",
+  "intent": "Add durable Work-owned dispatch queue with atomic claim, retry attempt count and terminal state transitions as the first real dispatcher runtime foundation.",
+  "requirement_ids": ["WP-301", "Durable dispatcher queue", "Atomic claim"],
+  "allowed_change_scope": {"modules": ["work-agent-execution", "work-storage"], "paths": ["database/migrations/030_work_agent_dispatch_queue.sql", "contracts/work/dispatch_queue.go", "adapters/postgres/work_repository.go", "tests/agent_execution/dispatch_queue_sql_test.go", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000129-agent-dispatch-queue.json"]},
+  "forbidden_change_scope": {"paths": ["architecture/**", "security/**", "deploy/**", "cmd/**", "runtime/**", ".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": ["DEV-000121 durable persistence", "DEV-000120 dispatch intent"], "may_change": ["Work dispatch queue contract and repository methods"]},
+  "semantic_owner": "work-agent-execution",
+  "canonical_state": ["work.agent_dispatch_queue"],
+  "state_transitions": ["QUEUED -> CLAIMED -> COMPLETED/FAILED"],
+  "side_effects_and_privileges": ["Work schema only; no cross-owner SQL; no runtime entrypoint"],
+  "persistence_and_migrations": ["Append-only migration 030; work_role only; production apply is a later canary step"],
+  "failure_retry_restart": ["SKIP LOCKED prevents duplicate claim; attempts are durable; terminal transition is worker-fenced"],
+  "assumptions": ["A later worker task will enqueue intents and execute claimed work"],
+  "acceptance_scenarios": ["Queue schema is durable", "Concurrent claim uses row lock and SKIP LOCKED", "Wrong worker cannot complete another claim"],
+  "required_tests": ["go test ./...", "go vet ./...", "preflight", "check-diff", "check-architecture", "independent", "git diff --check"],
+  "terminal_gap_states": ["BLOCKED_BY_MIGRATION_DECISION", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_CONFLICT"]
+}