DEV-000069 record live delegation checkpoint

Merge DEV-000068 final status

adapters/postgres/authority_repository.go

@@ -11,7 +11,7 @@ import (
 type AuthorityRepository struct{ pool *pgxpool.Pool }
 
 func OpenAuthority(ctx context.Context, c ContinuityConfig) (*AuthorityRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	if e != nil {
 		return nil, e
 	}

adapters/postgres/capability_repository.go

@@ -19,8 +19,7 @@ var ErrCapabilityImplementationNotFound = errors.New("capability implementation
 type CapabilityRepository struct{ pool *pgxpool.Pool }
 
 func OpenCapability(ctx context.Context, config ContinuityConfig) (*CapabilityRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
-	pool, err := pgxpool.New(ctx, dsn)
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}
@@ -246,6 +245,53 @@ func (r *CapabilityRepository) SaveSkillProfile(ctx context.Context, value capab
 	return tx.Commit(ctx)
 }
 
+func (r *CapabilityRepository) LoadSkillProfile(ctx context.Context, id capability.SkillProfileID) (capability.SkillProfile, error) {
+	var value capability.SkillProfile
+	err := r.pool.QueryRow(ctx, `SELECT
+		p.skill_profile_id,p.revision,p.name,p.description,p.applicable_context,p.implementation_ref,p.implementation_version,p.status,
+		p.supporting_experience_refs,p.known_failure_experience_refs,p.confidence_millis,p.last_validated_unix_millis,
+		p.observed_failure_count,p.observed_correction_count,p.recorded_at_unix_millis
+		FROM capability.skill_profile_heads h
+		JOIN capability.skill_profiles p ON p.skill_profile_id=h.skill_profile_id AND p.revision=h.revision
+		WHERE p.skill_profile_id=$1`, id).Scan(&value.ID, &value.Revision, &value.Name, &value.Description, &value.ApplicableContext,
+		&value.ImplementationRef, &value.ImplementationVersion, &value.Status, &value.SupportingExperienceRefs,
+		&value.KnownFailureExperienceRefs, &value.ConfidenceMillis, &value.LastValidatedUnixMillis,
+		&value.ObservedFailureCount, &value.ObservedCorrectionCount, &value.RecordedAtUnixMillis)
+	if err != nil {
+		return capability.SkillProfile{}, fmt.Errorf("load skill profile: %w", err)
+	}
+	return value, nil
+}
+
+func (r *CapabilityRepository) RecentSkillProfiles(ctx context.Context, limit int) ([]capability.SkillProfile, error) {
+	if limit < 1 || limit > 100 {
+		return nil, fmt.Errorf("invalid skill profile limit")
+	}
+	rows, err := r.pool.Query(ctx, `SELECT
+		p.skill_profile_id,p.revision,p.name,p.description,p.applicable_context,p.implementation_ref,p.implementation_version,p.status,
+		p.supporting_experience_refs,p.known_failure_experience_refs,p.confidence_millis,p.last_validated_unix_millis,
+		p.observed_failure_count,p.observed_correction_count,p.recorded_at_unix_millis
+		FROM capability.skill_profile_heads h
+		JOIN capability.skill_profiles p ON p.skill_profile_id=h.skill_profile_id AND p.revision=h.revision
+		ORDER BY h.updated_at DESC, p.skill_profile_id LIMIT $1`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []capability.SkillProfile
+	for rows.Next() {
+		var value capability.SkillProfile
+		if err := rows.Scan(&value.ID, &value.Revision, &value.Name, &value.Description, &value.ApplicableContext,
+			&value.ImplementationRef, &value.ImplementationVersion, &value.Status, &value.SupportingExperienceRefs,
+			&value.KnownFailureExperienceRefs, &value.ConfidenceMillis, &value.LastValidatedUnixMillis,
+			&value.ObservedFailureCount, &value.ObservedCorrectionCount, &value.RecordedAtUnixMillis); err != nil {
+			return nil, err
+		}
+		result = append(result, value)
+	}
+	return result, rows.Err()
+}
+
 func (r *CapabilityRepository) LoadBinding(ctx context.Context, id capability.CapabilityBindingID, revision int64) (capability.Binding, error) {
 	var binding capability.Binding
 	err := r.pool.QueryRow(ctx, `SELECT binding_id,capability_id,owner_principal_id,revision,state,https_origin,delivery_path,receipt_path,

adapters/postgres/commit_repository.go

@@ -23,7 +23,7 @@ var (
 type CommitRepository struct{ pool *pgxpool.Pool }
 
 func OpenCommit(ctx context.Context, c ContinuityConfig) (*CommitRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	if e != nil {
 		return nil, e
 	}

adapters/postgres/continuity_repository.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"git.cin.su/m/Assistant/contracts/authority"
 	"git.cin.su/m/Assistant/contracts/continuity"
@@ -29,9 +30,25 @@ var (
 type ContinuityConfig struct{ Host, Port, Database, User, Password string }
 type ContinuityRepository struct{ pool *pgxpool.Pool }
 
+func openPool(ctx context.Context, config ContinuityConfig) (*pgxpool.Pool, error) {
+	poolConfig, err := pgxpool.ParseConfig("")
+	if err != nil {
+		return nil, err
+	}
+	port, err := strconv.ParseUint(config.Port, 10, 16)
+	if err != nil {
+		return nil, fmt.Errorf("invalid postgres port: %w", err)
+	}
+	poolConfig.ConnConfig.Host = config.Host
+	poolConfig.ConnConfig.Port = uint16(port)
+	poolConfig.ConnConfig.Database = config.Database
+	poolConfig.ConnConfig.User = config.User
+	poolConfig.ConnConfig.Password = config.Password
+	return pgxpool.NewWithConfig(ctx, poolConfig)
+}
+
 func OpenContinuity(ctx context.Context, config ContinuityConfig) (*ContinuityRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
-	pool, err := pgxpool.New(ctx, dsn)
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}
@@ -145,10 +162,10 @@ func (r *ContinuityRepository) ClaimDueReminder(ctx context.Context, id continui
 		return continuity.ProspectiveItem{}, continuity.AttentionItem{}, err
 	}
 	err = tx.QueryRow(ctx, `INSERT INTO continuity.attention_items (
-		attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,
+		attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,
 		due_at_unix_millis,created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,
 		action_attempt_id,delivery_outcome,response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision)
-		VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,0,'','','','','','','','',0,1)
+		VALUES ($1,$2,$3,$4,$5,'',$6,$7,$8,$9,$10,0,'','','','','','','','',0,1)
 		ON CONFLICT (source_kind, source_prospective_item_id) DO UPDATE SET
 			state=EXCLUDED.state,
 			due_at_unix_millis=EXCLUDED.due_at_unix_millis,
@@ -164,12 +181,12 @@ func (r *ContinuityRepository) ClaimDueReminder(ctx context.Context, id continui
 			response_outcome='',
 			responded_at_unix_millis=0,
 			revision=continuity.attention_items.revision+1
-		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,due_at_unix_millis,
+		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,due_at_unix_millis,
 			created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 			response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision`,
 		attention.ID, attention.OwnerPrincipalID, attention.ScopeID, attention.SourceKind, attention.SourceProspectiveID,
 		attention.Level, attention.State, attention.Summary, attention.DueAtUnixMillis, attention.CreatedAtUnixMillis).Scan(
-		&attention.ID, &attention.OwnerPrincipalID, &attention.ScopeID, &attention.SourceKind, &attention.SourceProspectiveID,
+		&attention.ID, &attention.OwnerPrincipalID, &attention.ScopeID, &attention.SourceKind, &attention.SourceProspectiveID, &attention.SourceExternalRef,
 		&attention.Level, &attention.State, &attention.Summary, &attention.DueAtUnixMillis, &attention.CreatedAtUnixMillis,
 		&attention.DeliveredAtUnixMillis, &attention.ActionIntentID, &attention.AuthorizedActionID, &attention.ActionAttemptID,
 		&attention.DeliveryOutcome, &attention.ResponseID, &attention.ResponseUtteranceID, &attention.ResponseOperation,
@@ -187,7 +204,7 @@ func (r *ContinuityRepository) PendingAttention(ctx context.Context, limit int)
 	if limit < 1 || limit > 100 {
 		return nil, fmt.Errorf("invalid attention limit")
 	}
-	rows, err := r.pool.Query(ctx, `SELECT attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,
+	rows, err := r.pool.Query(ctx, `SELECT attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,
 		due_at_unix_millis,created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 		response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision
 		FROM continuity.attention_items WHERE state=$1 ORDER BY due_at_unix_millis, attention_item_id LIMIT $2`, continuity.AttentionPending, limit)
@@ -202,7 +219,7 @@ func (r *ContinuityRepository) AttentionByOwner(ctx context.Context, owner ident
 	if owner == "" || limit < 1 || limit > 100 {
 		return nil, fmt.Errorf("invalid attention owner query")
 	}
-	rows, err := r.pool.Query(ctx, `SELECT attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,
+	rows, err := r.pool.Query(ctx, `SELECT attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,
 		due_at_unix_millis,created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 		response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision
 		FROM continuity.attention_items WHERE owner_principal_id=$1 ORDER BY due_at_unix_millis DESC, attention_item_id DESC LIMIT $2`, owner, limit)
@@ -217,8 +234,37 @@ func (r *ContinuityRepository) ResponseCandidates(ctx context.Context, owner ide
 	if owner == "" || limit < 1 || limit > 50 {
 		return nil, fmt.Errorf("invalid response candidate query")
 	}
+	candidates := make([]continuitydomain.ResponseCandidate, 0, limit)
+	attentionRows, err := r.pool.Query(ctx, `SELECT
+		attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,
+		due_at_unix_millis,created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
+		response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision
+		FROM continuity.attention_items
+		WHERE owner_principal_id=$1
+		  AND source_kind=$2
+		  AND state IN ($3,$4,$5)
+		ORDER BY created_at_unix_millis DESC, attention_item_id DESC
+		LIMIT $6`,
+		owner, continuity.AttentionSourceAgentDelegation, continuity.AttentionPending, continuity.AttentionDelivered, continuity.AttentionFailed, limit)
+	if err != nil {
+		return nil, fmt.Errorf("list delegation response candidates: %w", err)
+	}
+	defer attentionRows.Close()
+	for attentionRows.Next() {
+		item, err := scanAttentionItem(attentionRows)
+		if err != nil {
+			return nil, fmt.Errorf("scan delegation response candidate: %w", err)
+		}
+		candidates = append(candidates, continuitydomain.ResponseCandidate{Attention: item})
+	}
+	if err := attentionRows.Err(); err != nil {
+		return nil, fmt.Errorf("list delegation response candidates: %w", err)
+	}
+	if len(candidates) >= limit {
+		return candidates[:limit], nil
+	}
 	rows, err := r.pool.Query(ctx, `SELECT
-		COALESCE(a.attention_item_id,''),COALESCE(a.owner_principal_id,''),COALESCE(a.scope_id,''),COALESCE(a.source_kind,''),COALESCE(a.source_prospective_item_id,''),COALESCE(a.level,''),COALESCE(a.state,''),COALESCE(a.summary,''),
+		COALESCE(a.attention_item_id,''),COALESCE(a.owner_principal_id,''),COALESCE(a.scope_id,''),COALESCE(a.source_kind,''),COALESCE(a.source_prospective_item_id,''),COALESCE(a.source_external_ref,''),COALESCE(a.level,''),COALESCE(a.state,''),COALESCE(a.summary,''),
 		COALESCE(a.due_at_unix_millis,0),COALESCE(a.created_at_unix_millis,0),COALESCE(a.delivered_at_unix_millis,0),COALESCE(a.action_intent_id,''),COALESCE(a.authorized_action_id,''),COALESCE(a.action_attempt_id,''),COALESCE(a.delivery_outcome,''),
 		COALESCE(a.response_id,''),COALESCE(a.response_utterance_id,''),COALESCE(a.response_operation,''),COALESCE(a.response_outcome,''),COALESCE(a.responded_at_unix_millis,0),COALESCE(a.revision,0),
 		p.prospective_item_id,p.commitment_id,p.owner_principal_id,p.scope_id,p.goal_id,p.source_intent_id,p.source_utterance_id,p.summary,p.trigger_at_unix_millis,p.state,p.revision
@@ -230,20 +276,19 @@ func (r *ContinuityRepository) ResponseCandidates(ctx context.Context, owner ide
 		ORDER BY p.recorded_at DESC, COALESCE(a.delivered_at_unix_millis,0) DESC, p.prospective_item_id DESC
 		LIMIT $8`,
 		owner, continuity.AttentionSourceProspectiveReminder, continuity.AttentionDelivered, continuity.AttentionPending,
-		continuity.AttentionFailed, continuity.ProspectiveDelivered, continuity.ProspectiveArmed, limit)
+		continuity.AttentionFailed, continuity.ProspectiveDelivered, continuity.ProspectiveArmed, limit-len(candidates))
 	if err != nil {
 		return nil, fmt.Errorf("list human response candidates: %w", err)
 	}
 	defer rows.Close()
-	var candidates []continuitydomain.ResponseCandidate
 	for rows.Next() {
 		var candidate continuitydomain.ResponseCandidate
-		var attentionID, attentionOwner, attentionScope, sourceKind, sourceProspective, level, attentionState, attentionSummary string
+		var attentionID, attentionOwner, attentionScope, sourceKind, sourceProspective, sourceExternalRef, level, attentionState, attentionSummary string
 		var actionIntent, authorizedAction, actionAttempt, deliveryOutcome, responseID, responseUtterance, responseOperation, responseOutcome string
 		var dueAt, createdAt, deliveredAt, respondedAt int64
 		var attentionRevision uint64
 		if err := rows.Scan(
-			&attentionID, &attentionOwner, &attentionScope, &sourceKind, &sourceProspective, &level, &attentionState, &attentionSummary,
+			&attentionID, &attentionOwner, &attentionScope, &sourceKind, &sourceProspective, &sourceExternalRef, &level, &attentionState, &attentionSummary,
 			&dueAt, &createdAt, &deliveredAt, &actionIntent, &authorizedAction, &actionAttempt, &deliveryOutcome,
 			&responseID, &responseUtterance, &responseOperation, &responseOutcome, &respondedAt, &attentionRevision,
 			&candidate.Prospective.ID, &candidate.Prospective.CommitmentID, &candidate.Prospective.OwnerPrincipalID,
@@ -259,6 +304,7 @@ func (r *ContinuityRepository) ResponseCandidates(ctx context.Context, owner ide
 				ScopeID:               authority.ScopeID(attentionScope),
 				SourceKind:            continuity.AttentionSourceKind(sourceKind),
 				SourceProspectiveID:   continuity.ProspectiveItemID(sourceProspective),
+				SourceExternalRef:     sourceExternalRef,
 				Level:                 continuity.AttentionLevel(level),
 				State:                 continuity.AttentionState(attentionState),
 				Summary:               attentionSummary,
@@ -285,6 +331,47 @@ func (r *ContinuityRepository) ResponseCandidates(ctx context.Context, owner ide
 	return candidates, nil
 }
 
+func scanAttentionItem(scanner interface {
+	Scan(...any) error
+}) (continuity.AttentionItem, error) {
+	var item continuity.AttentionItem
+	var attentionID, attentionOwner, attentionScope, sourceKind, sourceProspective, sourceExternalRef, level, attentionState, attentionSummary string
+	var actionIntent, authorizedAction, actionAttempt, deliveryOutcome, responseID, responseUtterance, responseOperation, responseOutcome string
+	var dueAt, createdAt, deliveredAt, respondedAt int64
+	var attentionRevision uint64
+	if err := scanner.Scan(
+		&attentionID, &attentionOwner, &attentionScope, &sourceKind, &sourceProspective, &sourceExternalRef, &level, &attentionState, &attentionSummary,
+		&dueAt, &createdAt, &deliveredAt, &actionIntent, &authorizedAction, &actionAttempt, &deliveryOutcome,
+		&responseID, &responseUtterance, &responseOperation, &responseOutcome, &respondedAt, &attentionRevision); err != nil {
+		return continuity.AttentionItem{}, err
+	}
+	item = continuity.AttentionItem{
+		ID:                    continuity.AttentionItemID(attentionID),
+		OwnerPrincipalID:      identity.PrincipalID(attentionOwner),
+		ScopeID:               authority.ScopeID(attentionScope),
+		SourceKind:            continuity.AttentionSourceKind(sourceKind),
+		SourceProspectiveID:   continuity.ProspectiveItemID(sourceProspective),
+		SourceExternalRef:     sourceExternalRef,
+		Level:                 continuity.AttentionLevel(level),
+		State:                 continuity.AttentionState(attentionState),
+		Summary:               attentionSummary,
+		DueAtUnixMillis:       dueAt,
+		CreatedAtUnixMillis:   createdAt,
+		DeliveredAtUnixMillis: deliveredAt,
+		ActionIntentID:        continuity.CommittedActionIntentID(actionIntent),
+		AuthorizedActionID:    continuity.CommittedAuthorizedActionID(authorizedAction),
+		ActionAttemptID:       continuity.CommittedActionAttemptID(actionAttempt),
+		DeliveryOutcome:       deliveryOutcome,
+		ResponseID:            continuity.HumanResponseID(responseID),
+		ResponseUtteranceID:   responseUtterance,
+		ResponseOperation:     continuity.HumanResponseOperation(responseOperation),
+		ResponseOutcome:       continuity.ResponseOutcome(responseOutcome),
+		RespondedAtUnixMillis: respondedAt,
+		Revision:              continuity.AttentionRevision(attentionRevision),
+	}
+	return item, nil
+}
+
 func (r *ContinuityRepository) ApplyHumanResponse(ctx context.Context, response continuity.HumanResponse) error {
 	tx, err := r.pool.Begin(ctx)
 	if err != nil {
@@ -317,11 +404,10 @@ func (r *ContinuityRepository) ApplyHumanResponse(ctx context.Context, response
 		if tag.RowsAffected() != 1 {
 			return ErrProspectiveStateConflict
 		}
-		if response.TargetAttentionID == "" {
-			return ErrAttentionNotFound
-		}
-		if err = markAttentionResponded(ctx, tx, response, continuity.AttentionResolved); err != nil {
-			return err
+		if response.TargetAttentionID != "" {
+			if err = markAttentionResponded(ctx, tx, response, continuity.AttentionResolved); err != nil {
+				return err
+			}
 		}
 	case continuity.ResponseSnooze:
 		tag, err := tx.Exec(ctx, `UPDATE continuity.prospective_items SET state=$1, trigger_at_unix_millis=$2, revision=revision+1
@@ -362,19 +448,66 @@ func (r *ContinuityRepository) ApplyHumanResponse(ctx context.Context, response
 		if err = markAttentionResponded(ctx, tx, response, continuity.AttentionResolved); err != nil {
 			return err
 		}
+	case continuity.ResponseContinue, continuity.ResponseReject:
+		if response.TargetAttentionID == "" {
+			return ErrAttentionNotFound
+		}
+		if err = markAttentionResponded(ctx, tx, response, continuity.AttentionResolved); err != nil {
+			return err
+		}
 	}
 	return tx.Commit(ctx)
 }
 
+func (r *ContinuityRepository) CreateAttentionItem(ctx context.Context, item continuity.AttentionItem) (continuity.AttentionItem, error) {
+	err := r.pool.QueryRow(ctx, `INSERT INTO continuity.attention_items(
+		attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,
+		due_at_unix_millis,created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
+		response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22)
+		ON CONFLICT (source_kind, source_external_ref) WHERE source_external_ref <> '' DO UPDATE SET
+			level=EXCLUDED.level,
+			state=EXCLUDED.state,
+			summary=EXCLUDED.summary,
+			due_at_unix_millis=EXCLUDED.due_at_unix_millis,
+			created_at_unix_millis=EXCLUDED.created_at_unix_millis,
+			delivered_at_unix_millis=0,
+			action_intent_id='',
+			authorized_action_id='',
+			action_attempt_id='',
+			delivery_outcome='',
+			response_id='',
+			response_utterance_id='',
+			response_operation='',
+			response_outcome='',
+			responded_at_unix_millis=0,
+			revision=continuity.attention_items.revision+1
+		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,due_at_unix_millis,
+			created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
+			response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision`,
+		item.ID, item.OwnerPrincipalID, item.ScopeID, item.SourceKind, item.SourceProspectiveID, item.SourceExternalRef, item.Level, item.State,
+		item.Summary, item.DueAtUnixMillis, item.CreatedAtUnixMillis, item.DeliveredAtUnixMillis, item.ActionIntentID, item.AuthorizedActionID,
+		item.ActionAttemptID, item.DeliveryOutcome, item.ResponseID, item.ResponseUtteranceID, item.ResponseOperation, item.ResponseOutcome,
+		item.RespondedAtUnixMillis, item.Revision).Scan(
+		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.SourceExternalRef, &item.Level, &item.State,
+		&item.Summary, &item.DueAtUnixMillis, &item.CreatedAtUnixMillis, &item.DeliveredAtUnixMillis, &item.ActionIntentID, &item.AuthorizedActionID,
+		&item.ActionAttemptID, &item.DeliveryOutcome, &item.ResponseID, &item.ResponseUtteranceID, &item.ResponseOperation, &item.ResponseOutcome,
+		&item.RespondedAtUnixMillis, &item.Revision)
+	if err != nil {
+		return continuity.AttentionItem{}, fmt.Errorf("create attention item: %w", err)
+	}
+	return item, nil
+}
+
 func (r *ContinuityRepository) MarkAttentionDelivering(ctx context.Context, id continuity.AttentionItemID, revision continuity.AttentionRevision) (continuity.AttentionItem, error) {
 	var item continuity.AttentionItem
 	err := r.pool.QueryRow(ctx, `UPDATE continuity.attention_items SET state=$1, revision=revision+1
 		WHERE attention_item_id=$2 AND state=$3 AND revision=$4
-		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,due_at_unix_millis,
+		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,due_at_unix_millis,
 			created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 			response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision`,
 		continuity.AttentionDelivering, id, continuity.AttentionPending, revision).Scan(
-		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.Level, &item.State,
+		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.SourceExternalRef, &item.Level, &item.State,
 		&item.Summary, &item.DueAtUnixMillis, &item.CreatedAtUnixMillis, &item.DeliveredAtUnixMillis, &item.ActionIntentID,
 		&item.AuthorizedActionID, &item.ActionAttemptID, &item.DeliveryOutcome, &item.ResponseID, &item.ResponseUtteranceID,
 		&item.ResponseOperation, &item.ResponseOutcome, &item.RespondedAtUnixMillis, &item.Revision)
@@ -390,12 +523,12 @@ func (r *ContinuityRepository) MarkAttentionDelivered(ctx context.Context, id co
 		SET state=$1, revision=revision+1, delivered_at_unix_millis=$2, action_intent_id=$3, authorized_action_id=$4,
 			action_attempt_id=$5, delivery_outcome=$6
 		WHERE attention_item_id=$7 AND state=$8 AND revision=$9
-		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,due_at_unix_millis,
+		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,due_at_unix_millis,
 			created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 			response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision`,
 		continuity.AttentionDelivered, deliveredAtUnixMillis, intentID, authorizedID, attemptID, outcome,
 		id, continuity.AttentionDelivering, revision).Scan(
-		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.Level, &item.State,
+		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.SourceExternalRef, &item.Level, &item.State,
 		&item.Summary, &item.DueAtUnixMillis, &item.CreatedAtUnixMillis, &item.DeliveredAtUnixMillis, &item.ActionIntentID,
 		&item.AuthorizedActionID, &item.ActionAttemptID, &item.DeliveryOutcome, &item.ResponseID, &item.ResponseUtteranceID,
 		&item.ResponseOperation, &item.ResponseOutcome, &item.RespondedAtUnixMillis, &item.Revision)
@@ -411,12 +544,12 @@ func (r *ContinuityRepository) MarkAttentionFailed(ctx context.Context, id conti
 		SET state=$1, revision=revision+1, action_intent_id=$2, authorized_action_id=$3,
 			action_attempt_id=$4, delivery_outcome=$5
 		WHERE attention_item_id=$6 AND state=$7 AND revision=$8
-		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,level,state,summary,due_at_unix_millis,
+		RETURNING attention_item_id,owner_principal_id,scope_id,source_kind,source_prospective_item_id,source_external_ref,level,state,summary,due_at_unix_millis,
 			created_at_unix_millis,delivered_at_unix_millis,action_intent_id,authorized_action_id,action_attempt_id,delivery_outcome,
 			response_id,response_utterance_id,response_operation,response_outcome,responded_at_unix_millis,revision`,
 		continuity.AttentionFailed, intentID, authorizedID, attemptID, outcome,
 		id, continuity.AttentionDelivering, revision).Scan(
-		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.Level, &item.State,
+		&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.SourceExternalRef, &item.Level, &item.State,
 		&item.Summary, &item.DueAtUnixMillis, &item.CreatedAtUnixMillis, &item.DeliveredAtUnixMillis, &item.ActionIntentID,
 		&item.AuthorizedActionID, &item.ActionAttemptID, &item.DeliveryOutcome, &item.ResponseID, &item.ResponseUtteranceID,
 		&item.ResponseOperation, &item.ResponseOutcome, &item.RespondedAtUnixMillis, &item.Revision)
@@ -525,7 +658,7 @@ func scanAttentionRows(rows continuityRows) ([]continuity.AttentionItem, error)
 	items := make([]continuity.AttentionItem, 0)
 	for rows.Next() {
 		var item continuity.AttentionItem
-		if err := rows.Scan(&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID,
+		if err := rows.Scan(&item.ID, &item.OwnerPrincipalID, &item.ScopeID, &item.SourceKind, &item.SourceProspectiveID, &item.SourceExternalRef,
 			&item.Level, &item.State, &item.Summary, &item.DueAtUnixMillis, &item.CreatedAtUnixMillis,
 			&item.DeliveredAtUnixMillis, &item.ActionIntentID, &item.AuthorizedActionID, &item.ActionAttemptID,
 			&item.DeliveryOutcome, &item.ResponseID, &item.ResponseUtteranceID, &item.ResponseOperation,

adapters/postgres/epistemics_repository.go

@@ -11,8 +11,7 @@ import (
 type EpistemicsRepository struct{ pool *pgxpool.Pool }
 
 func OpenEpistemics(ctx context.Context, config ContinuityConfig) (*EpistemicsRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
-	pool, err := pgxpool.New(ctx, dsn)
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}
@@ -31,6 +30,58 @@ func (r *EpistemicsRepository) SaveSystemExpectation(ctx context.Context, value
 	return err
 }
 
+func (r *EpistemicsRepository) RecentExperienceRecords(ctx context.Context, limit int) ([]epistemics.ExperienceRecord, error) {
+	if limit < 1 || limit > 100 {
+		return nil, fmt.Errorf("invalid experience limit")
+	}
+	rows, err := r.pool.Query(ctx, `SELECT
+		experience_id,source_kind,original_intent_id,source_utterance_id,context_refs,help_method,help_method_ref,
+		capability_implementation_ref,capability_usage_observation_ref,capability_gap_ref,skill_ref,expectation_id,
+		expected_outcome,actual_outcome,outcome_ref,outcome_detail,human_response_ref,correction_utterance_id,
+		verification_evidence,confidence_millis,recorded_at_unix_millis
+		FROM epistemics.experience_records ORDER BY recorded_at_unix_millis DESC, experience_id DESC LIMIT $1`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []epistemics.ExperienceRecord
+	for rows.Next() {
+		var value epistemics.ExperienceRecord
+		if err := rows.Scan(&value.ID, &value.SourceKind, &value.OriginalIntentID, &value.SourceUtteranceID, &value.ContextRefs, &value.HelpMethod, &value.HelpMethodRef,
+			&value.CapabilityImplementationRef, &value.CapabilityUsageObservationRef, &value.CapabilityGapRef, &value.SkillRef, &value.ExpectationID,
+			&value.ExpectedOutcome, &value.ActualOutcome, &value.OutcomeRef, &value.OutcomeDetail, &value.HumanResponseRef, &value.CorrectionUtteranceID,
+			&value.VerificationEvidence, &value.ConfidenceMillis, &value.RecordedAtUnixMillis); err != nil {
+			return nil, err
+		}
+		result = append(result, value)
+	}
+	return result, rows.Err()
+}
+
+func (r *EpistemicsRepository) RecentReflectionCandidates(ctx context.Context, limit int) ([]epistemics.ReflectionCandidate, error) {
+	if limit < 1 || limit > 100 {
+		return nil, fmt.Errorf("invalid reflection limit")
+	}
+	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
+		FROM epistemics.reflection_candidates ORDER BY recorded_at_unix_millis DESC, reflection_candidate_id DESC LIMIT $1`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []epistemics.ReflectionCandidate
+	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 {
+			return nil, err
+		}
+		result = append(result, value)
+	}
+	return result, rows.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,

adapters/postgres/identity_repository.go

@@ -11,7 +11,7 @@ import (
 type IdentityRepository struct{ pool *pgxpool.Pool }
 
 func OpenIdentity(ctx context.Context, config ContinuityConfig) (*IdentityRepository, error) {
-	pool, err := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password))
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/interaction_repository.go

@@ -2,7 +2,6 @@ package postgres
 
 import (
 	"context"
-	"fmt"
 
 	"git.cin.su/m/Assistant/contracts/interaction"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -11,7 +10,7 @@ import (
 type InteractionRepository struct{ pool *pgxpool.Pool }
 
 func OpenInteraction(ctx context.Context, c ContinuityConfig) (*InteractionRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	return &InteractionRepository{p}, e
 }
 func (r *InteractionRepository) Close() { r.pool.Close() }

adapters/postgres/situation_repository.go

@@ -2,7 +2,6 @@ package postgres
 
 import (
 	"context"
-	"fmt"
 	"strings"
 
 	"git.cin.su/m/Assistant/contracts/identity"
@@ -13,8 +12,7 @@ import (
 type SituationRepository struct{ pool *pgxpool.Pool }
 
 func OpenSituation(ctx context.Context, config ContinuityConfig) (*SituationRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
-	pool, err := pgxpool.New(ctx, dsn)
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/work_repository.go

@@ -11,8 +11,7 @@ import (
 type WorkRepository struct{ pool *pgxpool.Pool }
 
 func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
-	pool, err := pgxpool.New(ctx, dsn)
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}
@@ -75,3 +74,221 @@ func (r *WorkRepository) SavePlanningResult(ctx context.Context, result work.Pla
 	}
 	return tx.Commit(ctx)
 }
+
+func (r *WorkRepository) SaveDelegationBundle(ctx context.Context, delegation work.Delegation, run work.AgentRun) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err = tx.Exec(ctx, `INSERT INTO work.delegations(
+		delegation_id,goal_id,work_plan_id,plan_candidate_id,capability_requirement_id,capability_kind,
+		selected_implementation_id,selected_implementation_revision,selected_implementation_kind,protocol,
+		source_intent_id,source_utterance_id,conversation_id,project_id,project_display_name,desired_outcome,
+		constraint_summary,verification_summary,context_summary,context_refs,state,latest_run_id,latest_result_id,
+		created_at_unix_millis,updated_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)
+		ON CONFLICT(delegation_id) DO NOTHING`,
+		delegation.ID, delegation.GoalID, delegation.PlanID, delegation.PlanCandidateID, delegation.CapabilityRequirementID,
+		delegation.CapabilityKind, delegation.SelectedImplementationID, delegation.SelectedImplementationRev,
+		delegation.SelectedImplementationKind, delegation.Protocol, delegation.SourceIntentID, delegation.SourceUtteranceID,
+		delegation.ConversationID, delegation.ProjectID, delegation.ProjectDisplayName, delegation.DesiredOutcome,
+		delegation.ConstraintSummary, delegation.VerificationSummary, delegation.ContextSummary, delegation.ContextRefs,
+		delegation.State, delegation.LatestRunID, delegation.LatestResultID, delegation.CreatedAtUnixMillis, delegation.UpdatedAtUnixMillis); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO work.agent_runs(
+		run_id,delegation_id,implementation_id,implementation_revision,protocol,state,derived_instruction_summary,
+		started_at_unix_millis,updated_at_unix_millis,completed_at_unix_millis)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(run_id) DO NOTHING`,
+		run.ID, run.DelegationID, run.ImplementationID, run.ImplementationRevision, run.Protocol, run.State,
+		run.DerivedInstructionSummary, run.StartedAtUnixMillis, run.UpdatedAtUnixMillis, run.CompletedAtUnixMillis); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) SaveAgentCheckpoint(ctx context.Context, run work.AgentRun, checkpoint work.AgentCheckpoint) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err = tx.Exec(ctx, `UPDATE work.agent_runs
+		SET state=$2,updated_at_unix_millis=$3,completed_at_unix_millis=$4
+		WHERE run_id=$1`, run.ID, run.State, run.UpdatedAtUnixMillis, run.CompletedAtUnixMillis); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `UPDATE work.delegations
+		SET state=$2,updated_at_unix_millis=$3,latest_run_id=$4
+		WHERE delegation_id=$1`, checkpoint.DelegationID, delegationStateForRun(run.State), checkpoint.RecordedAtUnixMillis, run.ID); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO work.agent_checkpoints(
+		checkpoint_id,delegation_id,run_id,state,blocker_class,completed_summary,remaining_summary,test_summary,
+		branch_name,commit_hash,next_step,artifact_refs,recorded_at_unix_millis)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) ON CONFLICT(checkpoint_id) DO NOTHING`,
+		checkpoint.ID, checkpoint.DelegationID, checkpoint.RunID, checkpoint.State, checkpoint.BlockerClass,
+		checkpoint.CompletedSummary, checkpoint.RemainingSummary, checkpoint.TestSummary, checkpoint.BranchName,
+		checkpoint.CommitHash, checkpoint.NextStep, checkpoint.ArtifactRefs, checkpoint.RecordedAtUnixMillis); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) SaveAgentResult(ctx context.Context, run work.AgentRun, result work.AgentResult) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err = tx.Exec(ctx, `UPDATE work.agent_runs
+		SET state=$2,updated_at_unix_millis=$3,completed_at_unix_millis=$4
+		WHERE run_id=$1`, run.ID, run.State, run.UpdatedAtUnixMillis, run.CompletedAtUnixMillis); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `UPDATE work.delegations
+		SET state=$2,updated_at_unix_millis=$3,latest_run_id=$4,latest_result_id=$5
+		WHERE delegation_id=$1`, result.DelegationID, work.DelegationVerifying, result.RecordedAtUnixMillis, run.ID, result.ID); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO work.agent_results(
+		result_id,delegation_id,run_id,state,summary,outcome_ref,verification_required,verification_summary,artifact_refs,recorded_at_unix_millis)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(result_id) DO NOTHING`,
+		result.ID, result.DelegationID, result.RunID, result.State, result.Summary, result.OutcomeRef, result.VerificationRequired,
+		result.VerificationSummary, result.ArtifactRefs, result.RecordedAtUnixMillis); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) SaveResumedRun(ctx context.Context, delegation work.Delegation, run work.AgentRun) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err = tx.Exec(ctx, `UPDATE work.delegations
+		SET state=$2,updated_at_unix_millis=$3,latest_run_id=$4
+		WHERE delegation_id=$1`, delegation.ID, delegation.State, delegation.UpdatedAtUnixMillis, delegation.LatestRunID); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO work.agent_runs(
+		run_id,delegation_id,implementation_id,implementation_revision,protocol,state,derived_instruction_summary,
+		started_at_unix_millis,updated_at_unix_millis,completed_at_unix_millis)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) ON CONFLICT(run_id) DO NOTHING`,
+		run.ID, run.DelegationID, run.ImplementationID, run.ImplementationRevision, run.Protocol, run.State,
+		run.DerivedInstructionSummary, run.StartedAtUnixMillis, run.UpdatedAtUnixMillis, run.CompletedAtUnixMillis); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) SaveDelegationVerification(ctx context.Context, delegation work.Delegation, verification work.DelegationVerification) error {
+	tx, err := r.pool.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	if _, err = tx.Exec(ctx, `UPDATE work.delegations
+		SET state=$2,updated_at_unix_millis=$3
+		WHERE delegation_id=$1`, delegation.ID, delegation.State, delegation.UpdatedAtUnixMillis); err != nil {
+		return err
+	}
+	if _, err = tx.Exec(ctx, `INSERT INTO work.delegation_verifications(
+		verification_id,delegation_id,run_id,result_id,verified,summary,evidence_refs,recorded_at_unix_millis)
+		VALUES($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT(verification_id) DO NOTHING`,
+		verification.ID, verification.DelegationID, verification.RunID, verification.ResultID, verification.Verified,
+		verification.Summary, verification.EvidenceRefs, verification.RecordedAtUnixMillis); err != nil {
+		return err
+	}
+	return tx.Commit(ctx)
+}
+
+func (r *WorkRepository) LatestAgentResult(ctx context.Context, delegationID work.DelegationID) (work.AgentResult, error) {
+	var value work.AgentResult
+	err := r.pool.QueryRow(ctx, `SELECT result_id,delegation_id,run_id,state,summary,outcome_ref,verification_required,verification_summary,artifact_refs,recorded_at_unix_millis
+		FROM work.agent_results WHERE delegation_id=$1 ORDER BY recorded_at_unix_millis DESC, result_id DESC LIMIT 1`, delegationID).
+		Scan(&value.ID, &value.DelegationID, &value.RunID, &value.State, &value.Summary, &value.OutcomeRef, &value.VerificationRequired, &value.VerificationSummary, &value.ArtifactRefs, &value.RecordedAtUnixMillis)
+	if err != nil {
+		return work.AgentResult{}, fmt.Errorf("load latest agent result: %w", err)
+	}
+	return value, nil
+}
+
+func (r *WorkRepository) CountAgentRuns(ctx context.Context, delegationID work.DelegationID) (int, error) {
+	var count int
+	err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM work.agent_runs WHERE delegation_id=$1`, delegationID).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("count agent runs: %w", err)
+	}
+	return count, nil
+}
+
+func (r *WorkRepository) LatestAgentCheckpoint(ctx context.Context, delegationID work.DelegationID) (work.AgentCheckpoint, error) {
+	var value work.AgentCheckpoint
+	err := r.pool.QueryRow(ctx, `SELECT checkpoint_id,delegation_id,run_id,state,blocker_class,completed_summary,remaining_summary,test_summary,branch_name,commit_hash,next_step,artifact_refs,recorded_at_unix_millis
+		FROM work.agent_checkpoints WHERE delegation_id=$1 ORDER BY recorded_at_unix_millis DESC, checkpoint_id DESC LIMIT 1`, delegationID).
+		Scan(&value.ID, &value.DelegationID, &value.RunID, &value.State, &value.BlockerClass, &value.CompletedSummary, &value.RemainingSummary,
+			&value.TestSummary, &value.BranchName, &value.CommitHash, &value.NextStep, &value.ArtifactRefs, &value.RecordedAtUnixMillis)
+	if err != nil {
+		return work.AgentCheckpoint{}, err
+	}
+	return value, nil
+}
+
+func (r *WorkRepository) LoadDelegation(ctx context.Context, id work.DelegationID) (work.Delegation, error) {
+	var value work.Delegation
+	err := r.pool.QueryRow(ctx, `SELECT delegation_id,goal_id,work_plan_id,plan_candidate_id,capability_requirement_id,capability_kind,
+		selected_implementation_id,selected_implementation_revision,selected_implementation_kind,protocol,
+		source_intent_id,source_utterance_id,conversation_id,project_id,project_display_name,desired_outcome,constraint_summary,
+		verification_summary,context_summary,context_refs,state,latest_run_id,latest_result_id,created_at_unix_millis,updated_at_unix_millis
+		FROM work.delegations WHERE delegation_id=$1`, id).
+		Scan(&value.ID, &value.GoalID, &value.PlanID, &value.PlanCandidateID, &value.CapabilityRequirementID, &value.CapabilityKind,
+			&value.SelectedImplementationID, &value.SelectedImplementationRev, &value.SelectedImplementationKind, &value.Protocol,
+			&value.SourceIntentID, &value.SourceUtteranceID, &value.ConversationID, &value.ProjectID, &value.ProjectDisplayName,
+			&value.DesiredOutcome, &value.ConstraintSummary, &value.VerificationSummary, &value.ContextSummary, &value.ContextRefs,
+			&value.State, &value.LatestRunID, &value.LatestResultID, &value.CreatedAtUnixMillis, &value.UpdatedAtUnixMillis)
+	if err != nil {
+		return work.Delegation{}, fmt.Errorf("load delegation: %w", err)
+	}
+	return value, nil
+}
+
+func (r *WorkRepository) LoadAgentRun(ctx context.Context, id work.AgentRunID) (work.AgentRun, error) {
+	var value work.AgentRun
+	err := r.pool.QueryRow(ctx, `SELECT run_id,delegation_id,implementation_id,implementation_revision,protocol,state,derived_instruction_summary,started_at_unix_millis,updated_at_unix_millis,completed_at_unix_millis
+		FROM work.agent_runs WHERE run_id=$1`, id).
+		Scan(&value.ID, &value.DelegationID, &value.ImplementationID, &value.ImplementationRevision, &value.Protocol, &value.State, &value.DerivedInstructionSummary,
+			&value.StartedAtUnixMillis, &value.UpdatedAtUnixMillis, &value.CompletedAtUnixMillis)
+	if err != nil {
+		return work.AgentRun{}, fmt.Errorf("load agent run: %w", err)
+	}
+	return value, nil
+}
+
+func delegationStateForRun(state work.AgentRunState) work.DelegationState {
+	switch state {
+	case work.AgentRunStarted, work.AgentRunRunning:
+		return work.DelegationRunning
+	case work.AgentRunWaiting, work.AgentRunCheckpointed, work.AgentRunExecutionWindowExhausted:
+		return work.DelegationWaiting
+	case work.AgentRunBlocked:
+		return work.DelegationBlocked
+	case work.AgentRunCompleted:
+		return work.DelegationVerifying
+	case work.AgentRunCancelled:
+		return work.DelegationCancelled
+	case work.AgentRunFailed:
+		return work.DelegationFailed
+	default:
+		return work.DelegationPending
+	}
+}
+
+func latestRowErr(err error) error {
+	if err == nil {
+		return nil
+	}
+	return err
+}

architecture/adrs/ADR-0017-general-agent-delegation-codex-bridge.md

@@ -0,0 +1,54 @@
+# ADR-0017 — General Agent Delegation and Codex Bridge V1
+
+Status: Accepted
+
+Task: DEV-000069
+
+## Context
+
+Domovoy already has Human Interaction, Situation/context, optional durable Work/Plan, Capability registry/resolution, Continuity/Attention, HumanResponse, Experience/Reflection, Skill evolution, Secret Resolver and Cognitive Gateway/Router. The next step is not "make Codex the center", but to let Domovoy delegate suitable work to a general external intelligent agent while preserving canonical human intent, work semantics, authority boundaries and future portability to non-Codex agents.
+
+The first real implementation is Codex for software-engineering work. However, a model is not an external agent. Cognitive models provide advice/candidates, while an external agent may inspect state, use tools, modify files, run tests, maintain a long-running task, checkpoint, resume and return evidence-bearing results.
+
+## Decision
+
+1. Do not create a new canonical owner for DEV-000069.
+2. `capability` remains the canonical owner for agent implementation registration by reusing `CapabilityImplementation` with `Kind=AGENT`. A Codex bridge is one concrete implementation, not a new canonical capability identity.
+3. `work` remains the canonical owner for durable delegation lifecycle. DEV-000069 extends Work semantics from planning-only `DelegationCandidate` to real delegation execution state such as `Delegation`, `AgentRun`, `AgentCheckpoint` and `AgentResult`.
+4. `continuity` remains the canonical owner for human waiting/attention semantics. Human-dependent blockers or completed long-running delegations surface through Attention rather than a Codex-specific notification path.
+5. `epistemics` remains the canonical owner for delegation outcome evidence through `ExperienceRecord` and later reflection, using typed refs to Work, Capability, Artifact and Interaction state.
+6. `artifact` remains the place for durable artifact metadata/refs when an agent run produces file, diff, test, log, PR or deployment evidence. Work stores typed refs, not payload copies.
+7. `OriginalHumanIntent`, `Goal`, `Work`, `CapabilityRequirement` and `Delegation` must remain canonical semantic records. Agent-specific instruction or prompt text is only a derived adapter artifact with provenance that distinguishes:
+   - what the human asked;
+   - what Domovoy inferred;
+   - what project/runtime context was added;
+   - how completion will be verified.
+8. Execution-window exhaustion is a run lifecycle state, not automatic task failure. The same higher-level delegation may continue through later runs while preserving checkpoint/history.
+9. Codex transport/UI wording is adapter-local. Canonical state must stay valid if the coding agent is replaced by another future agent.
+
+## Ownership
+
+- `interaction` owns the append-only human request/correction history and original intent traceability.
+- `situation` resolves project/repository context and active focus used for delegation context compilation.
+- `work` owns durable delegation requests, selected implementation refs, run lifecycle, checkpoint/result refs and verification gating before Work completion.
+- `capability` owns executor-neutral capability identity and concrete eligible implementations, including `AGENT` implementations such as Codex.
+- `continuity` owns waiting/attention/human-response continuation for delegation progress and genuine human blockers.
+- `epistemics` owns experience/reflection evidence derived from delegation outcomes.
+- `artifact` owns durable metadata for diffs/logs/checkpoints/results when they must survive outside a transient adapter response.
+
+## Boundaries
+
+- `SOFTWARE_ENGINEERING`, `MODIFY_CODE`, `INSPECT_REPOSITORY` and `RUN_TESTS` remain executor-neutral capability semantics.
+- `MODIFY_CODE != CODEX`.
+- Canonical Work/Delegation does not become a Codex prompt.
+- Secret access remains least-privilege through CredentialRef/Secret Resolver. Agent capability availability does not imply credential access or authority.
+- A completed agent run does not automatically mark higher-level Work complete. Verification must inspect available evidence.
+- Technical failures, execution-window exhaustion and human-dependent blockers are distinct lifecycle states.
+- `LLM-free` startup must continue to pass when Codex is unavailable.
+
+## Consequences
+
+- Domovoy can delegate suitable software-engineering work without forcing the human to author a giant Codex prompt.
+- The first production bridge can target Codex while leaving canonical semantics portable to future scientific, accounting, research or alternate coding agents.
+- Long-running agent work can checkpoint and continue across bounded execution windows.
+- Human chat remains simple, while operator/debug tooling can inspect the durable delegation/run/checkpoint/result state.

cmd/continuity-runtime/attention.go

@@ -12,6 +12,7 @@ import (
 
 type attentionRepository interface {
 	AttentionByOwner(context.Context, identity.PrincipalID, int) ([]continuity.AttentionItem, error)
+	CreateAttentionItem(context.Context, continuity.AttentionItem) (continuity.AttentionItem, error)
 }
 
 func registerCreatorAttentionRoutes(mux *http.ServeMux, identityClient creatorIdentityClient, repository attentionRepository) {
@@ -61,6 +62,53 @@ func registerCreatorAttentionRoutes(mux *http.ServeMux, identityClient creatorId
 		w.Header().Set("Cache-Control", "no-store")
 		_ = json.NewEncoder(w).Encode(result)
 	})
+	mux.HandleFunc("POST /v1/creator/attention", func(w http.ResponseWriter, r *http.Request) {
+		session, ok := creatorSessionForAttention(w, r, identityClient)
+		if !ok {
+			return
+		}
+		var request continuity.CreateAttentionRequest
+		decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&request); err != nil {
+			http.Error(w, "invalid attention request", http.StatusBadRequest)
+			return
+		}
+		if request.OwnerPrincipalID == "" {
+			request.OwnerPrincipalID = session.PrincipalID
+		}
+		if request.OwnerPrincipalID != session.PrincipalID || request.ScopeID == "" || request.SourceKind == "" || request.Level == "" || request.Summary == "" || request.CreatedAtUnixMillis < 1 || request.DueAtUnixMillis < 1 {
+			http.Error(w, "invalid attention request", http.StatusBadRequest)
+			return
+		}
+		if request.SourceKind == continuity.AttentionSourceAgentDelegation && request.SourceExternalRef == "" {
+			http.Error(w, "delegation attention requires source external ref", http.StatusBadRequest)
+			return
+		}
+		item := continuity.AttentionItem{
+			ID:                  continuity.AttentionItemID(request.SourceExternalRef),
+			OwnerPrincipalID:    request.OwnerPrincipalID,
+			ScopeID:             request.ScopeID,
+			SourceKind:          request.SourceKind,
+			SourceProspectiveID: request.SourceProspectiveID,
+			SourceExternalRef:   request.SourceExternalRef,
+			Level:               request.Level,
+			State:               continuity.AttentionPending,
+			Summary:             request.Summary,
+			DueAtUnixMillis:     request.DueAtUnixMillis,
+			CreatedAtUnixMillis: request.CreatedAtUnixMillis,
+			Revision:            1,
+		}
+		saved, err := repository.CreateAttentionItem(r.Context(), item)
+		if err != nil {
+			http.Error(w, "attention unavailable", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(saved)
+	})
 }
 
 func creatorSessionForAttention(w http.ResponseWriter, r *http.Request, identityClient creatorIdentityClient) (identity.CreatorSession, bool) {
@@ -98,6 +146,15 @@ func humanAttentionState(state continuity.AttentionState) string {
 }
 
 func humanResponseHint(item continuity.AttentionItem) string {
+	if item.SourceKind == continuity.AttentionSourceAgentDelegation {
+		if item.State == continuity.AttentionDelivered || item.State == continuity.AttentionPending || item.State == continuity.AttentionFailed {
+			return "Можно ответить: «Продолжай» или «Нет, нужен другой вариант»."
+		}
+		if item.ResponseOutcome != "" {
+			return "Ответ записан: " + string(item.ResponseOutcome)
+		}
+		return ""
+	}
 	if item.State == continuity.AttentionDelivered || item.State == continuity.AttentionPending || item.State == continuity.AttentionFailed {
 		return "Можно ответить: «Готово», «Отложи на 10 минут» или «Отмени»."
 	}
@@ -121,5 +178,8 @@ func humanAttentionSource(kind continuity.AttentionSourceKind) string {
 	if kind == continuity.AttentionSourceProspectiveReminder {
 		return "напоминание"
 	}
+	if kind == continuity.AttentionSourceAgentDelegation {
+		return "задача coding-agent"
+	}
 	return "событие Домового"
 }

cmd/continuity-runtime/human_response_test.go

@@ -65,6 +65,39 @@ func TestCreatorResponseEndpointRecordsAmbiguousWithoutSilentTargetMutation(t *t
 	}
 }
 
+func TestCreatorResponseEndpointContinuesDelegationAttentionViaNaturalMessage(t *testing.T) {
+	core := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_ = json.NewEncoder(w).Encode(identity.CreatorSession{ActorID: "actor-1", PrincipalID: "principal-1"})
+	}))
+	defer core.Close()
+	identityClient, err := newCreatorIdentityClient(core.URL, core.Client())
+	if err != nil {
+		t.Fatal(err)
+	}
+	repository := &fakeResponseRepository{candidates: []continuitydomain.ResponseCandidate{
+		{Attention: continuity.AttentionItem{
+			ID:                "work:delegation:delegation-1",
+			OwnerPrincipalID:  "principal-1",
+			ScopeID:           "scope-1",
+			SourceKind:        continuity.AttentionSourceAgentDelegation,
+			SourceExternalRef: "work:delegation:delegation-1",
+			State:             continuity.AttentionPending,
+			Summary:           "Нужен твой выбор по задаче coding-agent: docs/PROJECT_STATUS.md",
+			Revision:          1,
+		}},
+		{Attention: continuity.AttentionItem{ID: "attention-1", SourceProspectiveID: "prospective-1", State: continuity.AttentionDelivered, Summary: "старое напоминание"}},
+	}}
+	mux := http.NewServeMux()
+	registerCreatorResponseRoute(mux, identityClient, repository, func() time.Time { return time.Unix(100, 0) })
+	request := httptest.NewRequest(http.MethodPost, "/v1/creator/responses", strings.NewReader(`{"SourceUtteranceID":"utterance-1","SourceIntentID":"intent-1","Message":"Продолжай задачу coding-agent по docs/PROJECT_STATUS.md","RequestedAtUnixMillis":100000}`))
+	request.Header.Set("Authorization", "Bearer ok")
+	recorder := httptest.NewRecorder()
+	mux.ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusCreated || repository.applied.Operation != continuity.ResponseContinue || repository.applied.TargetExternalRef != "work:delegation:delegation-1" || repository.applied.Outcome != continuity.ResponseOutcomeContinued {
+		t.Fatalf("status=%d applied=%#v body=%s", recorder.Code, repository.applied, recorder.Body.String())
+	}
+}
+
 type fakeResponseRepository struct {
 	candidates []continuitydomain.ResponseCandidate
 	applied    continuity.HumanResponse

cmd/core-runtime/capability_chat.go

@@ -19,7 +19,9 @@ import (
 	"git.cin.su/m/Assistant/contracts/continuity"
 	"git.cin.su/m/Assistant/contracts/identity"
 	"git.cin.su/m/Assistant/contracts/interaction"
+	"git.cin.su/m/Assistant/contracts/work"
 	capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+	workdomain "git.cin.su/m/Assistant/modules/work/domain"
 	"git.cin.su/m/Assistant/platform/ids"
 )
 
@@ -33,6 +35,11 @@ type continuityResponseClient struct {
 	client  *http.Client
 }
 
+type continuityAttentionClient struct {
+	baseURL *url.URL
+	client  *http.Client
+}
+
 func newContinuityReminderClient(rawURL string, client *http.Client) (continuityReminderClient, error) {
 	base, err := url.Parse(rawURL)
 	if err != nil || base.Scheme == "" || base.Host == "" {
@@ -55,6 +62,17 @@ func newContinuityResponseClient(rawURL string, client *http.Client) (continuity
 	return continuityResponseClient{baseURL: base, client: client}, nil
 }
 
+func newContinuityAttentionClient(rawURL string, client *http.Client) (continuityAttentionClient, error) {
+	base, err := url.Parse(rawURL)
+	if err != nil || base.Scheme == "" || base.Host == "" {
+		return continuityAttentionClient{}, fmt.Errorf("invalid Continuity Runtime URL")
+	}
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return continuityAttentionClient{baseURL: base, client: client}, nil
+}
+
 func (c continuityReminderClient) Schedule(ctx context.Context, authorization string, request continuity.ScheduleReminderRequest) (continuity.ScheduleReminderResult, error) {
 	target := *c.baseURL
 	target.Path = "/v1/creator/reminders"
@@ -114,6 +132,37 @@ func (c continuityResponseClient) Respond(ctx context.Context, authorization str
 	return result, nil
 }
 
+func (c continuityAttentionClient) Create(ctx context.Context, authorization string, request continuity.CreateAttentionRequest) (continuity.AttentionItem, error) {
+	target := *c.baseURL
+	target.Path = "/v1/creator/attention"
+	payload, err := json.Marshal(request)
+	if err != nil {
+		return continuity.AttentionItem{}, err
+	}
+	upstream, err := http.NewRequestWithContext(ctx, http.MethodPost, target.String(), bytes.NewReader(payload))
+	if err != nil {
+		return continuity.AttentionItem{}, err
+	}
+	upstream.Header.Set("Content-Type", "application/json")
+	upstream.Header.Set("Authorization", authorization)
+	response, err := c.client.Do(upstream)
+	if err != nil {
+		return continuity.AttentionItem{}, err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusCreated {
+		return continuity.AttentionItem{}, fmt.Errorf("continuity attention status %d", response.StatusCode)
+	}
+	var result continuity.AttentionItem
+	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
+		return continuity.AttentionItem{}, err
+	}
+	if result.ID == "" || result.SourceKind == "" {
+		return continuity.AttentionItem{}, fmt.Errorf("invalid attention result")
+	}
+	return result, nil
+}
+
 func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityRepository, kind capability.CapabilityKind, session identity.CreatorSession, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance, now time.Time) (capability.CapabilityResolution, error) {
 	requirementID, err := ids.New()
 	if err != nil {
@@ -127,6 +176,7 @@ func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityR
 		OriginalIntentID:     capability.OriginalIntentRef(intent.ID),
 		SourceUtteranceID:    capability.SourceUtteranceRef(utterance.ID),
 		RequiredConstraints:  []capability.DataConstraint{capability.DataConstraintLocalOnly},
+		AllowCanary:          allowCanaryForChatCapability(kind),
 		AuthorityContextRef:  capability.AuthorityPolicyCreatorDirectiveV1,
 		ObservedAtUnixMillis: now.UnixMilli(),
 	}
@@ -144,10 +194,86 @@ func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityR
 	return resolution, err
 }
 
-func observeCapabilityUsage(ctx context.Context, repository *postgres.CapabilityRepository, selected capability.ResolvedCapabilityImplementation, requirement capability.CapabilityResolutionRequirement, outcome capability.UsageOutcomeClass, outcomeRef string, started time.Time, now time.Time) {
+func allowCanaryForChatCapability(kind capability.CapabilityKind) bool {
+	switch kind {
+	case capability.CapabilityKindModifyCode, capability.CapabilityKindRunTests, capability.CapabilityKindInspectProject:
+		return true
+	default:
+		return false
+	}
+}
+
+type createdDelegation struct {
+	Delegation work.Delegation
+	Run        work.AgentRun
+}
+
+func maybeCreateAgentDelegation(ctx context.Context, workRepository *postgres.WorkRepository, capabilityRepository *postgres.CapabilityRepository, session identity.CreatorSession, conversation interaction.Conversation, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance, planning work.PlanningResult, now time.Time) (*createdDelegation, capability.CapabilityResolution, error) {
+	requirement, ok := primarySoftwareRequirement(planning.Candidate.Requirements)
+	if !ok {
+		return nil, capability.CapabilityResolution{}, nil
+	}
+	resolution, err := resolveChatCapability(ctx, capabilityRepository, requirement.CapabilityKind, session, intent, utterance, now)
+	if err != nil {
+		return nil, resolution, err
+	}
+	if len(resolution.Eligible) == 0 || resolution.Eligible[0].Implementation.Kind != capability.ImplementationAgent {
+		return nil, resolution, capabilitydomain.ErrNoCapabilityImplementation
+	}
+	started, err := workdomain.StartDelegation(workdomain.DelegationRequest{
+		Goal:                planning.Goal,
+		Plan:                planning.Plan,
+		Candidate:           planning.Candidate,
+		Requirement:         requirement,
+		Implementation:      resolution.Eligible[0].Implementation,
+		ConversationID:      work.ConversationRef(conversation.ID),
+		OriginalIntentText:  intent.Text,
+		ContextSummary:      planning.Candidate.Summary,
+		ContextRefs:         []string{"interaction:intent:" + string(intent.ID), "interaction:utterance:" + string(utterance.ID), "work:plan:" + string(planning.Plan.ID)},
+		VerificationSummary: "verify through changed files, relevant tests, and explicit run evidence before work completion",
+		DerivedInstruction:  buildSoftwareAgentInstruction(planning, intent, utterance),
+		StartedAt:           now,
+	})
+	if err != nil {
+		return nil, capability.CapabilityResolution{}, err
+	}
+	if err := workRepository.SaveDelegationBundle(ctx, started.Delegation, started.Run); err != nil {
+		return nil, capability.CapabilityResolution{}, err
+	}
+	return &createdDelegation{Delegation: started.Delegation, Run: started.Run}, resolution, nil
+}
+
+func primarySoftwareRequirement(values []work.CapabilityRequirement) (work.CapabilityRequirement, bool) {
+	for _, requirement := range values {
+		switch requirement.CapabilityKind {
+		case capability.CapabilityKindModifyCode, capability.CapabilityKindRunTests, capability.CapabilityKindInspectProject:
+			return requirement, true
+		}
+	}
+	return work.CapabilityRequirement{}, false
+}
+
+func buildSoftwareAgentInstruction(planning work.PlanningResult, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance) string {
+	steps := make([]string, 0, len(planning.Candidate.Steps))
+	for _, step := range planning.Candidate.Steps {
+		if step.Description != "" {
+			steps = append(steps, step.Description)
+		}
+	}
+	return strings.TrimSpace(strings.Join([]string{
+		"Human asked: " + strings.TrimSpace(intent.Text),
+		"Original utterance: " + strings.TrimSpace(utterance.Content),
+		"Desired outcome: " + planning.Goal.DesiredOutcome,
+		"Plan summary: " + planning.Candidate.Summary,
+		"Verification: run relevant tests and keep explicit evidence before claiming completion.",
+		"Steps: " + strings.Join(steps, " | "),
+	}, "\n"))
+}
+
+func observeCapabilityUsage(ctx context.Context, repository *postgres.CapabilityRepository, selected capability.ResolvedCapabilityImplementation, requirement capability.CapabilityResolutionRequirement, outcome capability.UsageOutcomeClass, outcomeRef string, started time.Time, now time.Time) (capability.CapabilityUsageObservationID, error) {
 	id, err := ids.New()
 	if err != nil {
-		return
+		return "", err
 	}
 	latency := now.Sub(started).Milliseconds()
 	observation := capability.CapabilityUsageObservation{
@@ -164,7 +290,10 @@ func observeCapabilityUsage(ctx context.Context, repository *postgres.Capability
 		LatencyMillis:          &latency,
 		ObservedAtUnixMillis:   now.UnixMilli(),
 	}
-	_ = repository.SaveCapabilityUsageObservation(ctx, observation)
+	if err := repository.SaveCapabilityUsageObservation(ctx, observation); err != nil {
+		return "", err
+	}
+	return observation.ID, nil
 }
 
 func buildReminderRequest(message string, session identity.CreatorSession, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance, now time.Time) (continuity.ScheduleReminderRequest, error) {

cmd/core-runtime/capability_chat_test.go

@@ -9,9 +9,11 @@ import (
 	"testing"
 	"time"
 
+	"git.cin.su/m/Assistant/contracts/capability"
 	"git.cin.su/m/Assistant/contracts/continuity"
 	"git.cin.su/m/Assistant/contracts/identity"
 	"git.cin.su/m/Assistant/contracts/interaction"
+	"git.cin.su/m/Assistant/contracts/work"
 )
 
 func TestBuildReminderRequestParsesTomorrowAtTen(t *testing.T) {
@@ -72,3 +74,29 @@ func TestReminderSummaryRemovesSchedulingWords(t *testing.T) {
 		t.Fatalf("summary = %q", summary)
 	}
 }
+
+func TestBuildSoftwareAgentInstructionKeepsHumanIntentSeparateFromDerivedContext(t *testing.T) {
+	instruction := buildSoftwareAgentInstruction(
+		work.PlanningResult{
+			Goal:      work.Goal{DesiredOutcome: "fix chat wording"},
+			Candidate: work.PlanCandidate{Summary: "accepted deterministic software change plan", Steps: []work.PlanStep{{Description: "Inspect chat surface"}, {Description: "Change copy"}, {Description: "Run tests"}}},
+		},
+		interaction.OriginalHumanIntent{ID: "intent-1", Text: "Исправь текст в чате Assistant."},
+		interaction.HumanUtterance{ID: "utterance-1", Content: "Исправь текст в чате Assistant."},
+	)
+	if !strings.Contains(instruction, "Human asked: Исправь текст в чате Assistant.") {
+		t.Fatalf("instruction must preserve human intent: %q", instruction)
+	}
+	if !strings.Contains(instruction, "Verification: run relevant tests") || !strings.Contains(instruction, "Plan summary: accepted deterministic software change plan") {
+		t.Fatalf("instruction must include derived execution context: %q", instruction)
+	}
+}
+
+func TestAllowCanaryForChatCapabilityIsLimitedToSoftwareEngineeringPath(t *testing.T) {
+	if !allowCanaryForChatCapability(capability.CapabilityKindModifyCode) || !allowCanaryForChatCapability(capability.CapabilityKindRunTests) || !allowCanaryForChatCapability(capability.CapabilityKindInspectProject) {
+		t.Fatal("software-engineering capabilities must allow canary implementations")
+	}
+	if allowCanaryForChatCapability(capability.CapabilityKindScheduleReminder) {
+		t.Fatal("non software-engineering capability must not implicitly allow canary")
+	}
+}

cmd/core-runtime/learning.go

@@ -0,0 +1,380 @@
+package main
+
+import (
+	"context"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/continuity"
+	"git.cin.su/m/Assistant/contracts/epistemics"
+	"git.cin.su/m/Assistant/contracts/interaction"
+	capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+	epistemicsdomain "git.cin.su/m/Assistant/modules/epistemics/domain"
+)
+
+const reminderResponseSkillID = capability.SkillProfileID("skill-obvious-reminder-response-v1")
+
+type learningEpistemicsStore interface {
+	SaveSystemExpectation(context.Context, epistemics.SystemExpectation) error
+	SaveExperienceRecord(context.Context, epistemics.ExperienceRecord) error
+	SaveReflectionCandidate(context.Context, epistemics.ReflectionCandidate) error
+}
+
+type learningCapabilityStore interface {
+	LoadSkillProfile(context.Context, capability.SkillProfileID) (capability.SkillProfile, error)
+	SaveSkillProfile(context.Context, capability.SkillProfile) error
+}
+
+type learningRecorder struct {
+	epistemics learningEpistemicsStore
+	capability capabilityLearningStore
+}
+
+type capabilityLearningStore interface {
+	learningCapabilityStore
+}
+
+type reminderResponseLearningInput struct {
+	Utterance interaction.HumanUtterance
+	Intent    interaction.OriginalHumanIntent
+	Result    continuity.HumanResponseResult
+	At        time.Time
+}
+
+type correctionLearningInput struct {
+	Utterance interaction.HumanUtterance
+	Intent    interaction.OriginalHumanIntent
+	At        time.Time
+}
+
+type fastPathDeclineLearningInput struct {
+	Utterance interaction.HumanUtterance
+	Intent    interaction.OriginalHumanIntent
+	Result    continuity.HumanResponseResult
+	Reason    capability.FastPathDeclineReason
+	At        time.Time
+}
+
+type capabilityLearningInput struct {
+	Utterance        interaction.HumanUtterance
+	Intent           interaction.OriginalHumanIntent
+	ImplementationID capability.CapabilityImplementationID
+	UsageObservation capability.CapabilityUsageObservationID
+	GapID            capability.CapabilityGapID
+	Outcome          capability.UsageOutcomeClass
+	OutcomeRef       string
+	At               time.Time
+}
+
+type delegationLearningInput struct {
+	Intent           interaction.OriginalHumanIntent
+	Utterance        interaction.HumanUtterance
+	DelegationID     string
+	RunID            string
+	ImplementationID capability.CapabilityImplementationID
+	OutcomeRef       string
+	VerificationRefs []epistemics.EvidenceRef
+	Verified         bool
+	ExecutionWindows int
+	HumanBlocked     bool
+	At               time.Time
+}
+
+func (r learningRecorder) recordReminderResponse(ctx context.Context, input reminderResponseLearningInput) {
+	if r.epistemics == nil || r.capability == nil || input.Intent.ID == "" || input.Utterance.ID == "" || input.Result.Response.ID == "" {
+		return
+	}
+	expectedEffect := "resolve obvious reminder continuation using deterministic target resolver"
+	if input.Result.Response.TargetProspectiveID != "" {
+		expectedEffect += " for prospective item " + string(input.Result.Response.TargetProspectiveID)
+	}
+	expectation := epistemics.SystemExpectation{
+		OriginalIntentID:     epistemics.OriginalIntentRef(input.Intent.ID),
+		SourceUtteranceID:    epistemics.SourceUtteranceRef(input.Utterance.ID),
+		ExpectedOutcome:      epistemics.OutcomeSuccess,
+		ExpectedEffect:       expectedEffect,
+		ConfidenceMillis:     850,
+		EvidenceBasis:        []epistemics.EvidenceRef{"continuity:response-target-resolution"},
+		RecordedAtUnixMillis: input.At.UnixMilli(),
+	}
+	expectation, err := epistemicsdomain.NewSystemExpectation(expectation)
+	if err != nil {
+		log.Printf("learning reminder expectation invalid: %v", err)
+		return
+	}
+	if err := r.epistemics.SaveSystemExpectation(ctx, expectation); err != nil {
+		log.Printf("learning reminder expectation unavailable: %v", err)
+		return
+	}
+	actual, confidence := outcomeForHumanResponse(input.Result.Response)
+	experience := epistemics.ExperienceRecord{
+		SourceKind:        epistemics.ExperienceSourceContinuity,
+		OriginalIntentID:  epistemics.OriginalIntentRef(input.Intent.ID),
+		SourceUtteranceID: epistemics.SourceUtteranceRef(input.Utterance.ID),
+		ContextRefs: contextRefs(
+			"continuity:human-response:"+string(input.Result.Response.ID),
+			"continuity:prospective:"+string(input.Result.Response.TargetProspectiveID),
+			"continuity:attention:"+string(input.Result.Response.TargetAttentionID),
+		),
+		HelpMethod:           epistemics.HelpMethodDeterministicFastPath,
+		HelpMethodRef:        "continuity:human-response-target-resolver-v1",
+		SkillRef:             epistemics.SkillRef(reminderResponseSkillID),
+		ExpectationID:        expectation.ID,
+		ExpectedOutcome:      expectation.ExpectedOutcome,
+		ActualOutcome:        actual,
+		OutcomeRef:           "continuity:human-response:" + string(input.Result.Response.ID),
+		OutcomeDetail:        string(input.Result.Response.Operation) + " -> " + string(input.Result.Response.Outcome),
+		HumanResponseRef:     epistemics.HumanResponseRef(input.Result.Response.ID),
+		VerificationEvidence: []epistemics.EvidenceRef{epistemics.EvidenceRef("human-response:" + string(input.Result.Response.Outcome))},
+		ConfidenceMillis:     confidence,
+		RecordedAtUnixMillis: input.At.UnixMilli(),
+	}
+	r.saveExperienceAndReflection(ctx, experience)
+	r.updateReminderSkill(ctx, experience, skillOutcomeForExperience(experience), false)
+}
+
+func (r learningRecorder) recordCorrection(ctx context.Context, input correctionLearningInput) {
+	if r.epistemics == nil || input.Intent.ID == "" || input.Utterance.ID == "" {
+		return
+	}
+	experience := epistemics.ExperienceRecord{
+		SourceKind:            epistemics.ExperienceSourceInteraction,
+		OriginalIntentID:      epistemics.OriginalIntentRef(input.Intent.ID),
+		SourceUtteranceID:     epistemics.SourceUtteranceRef(input.Utterance.ID),
+		HelpMethod:            epistemics.HelpMethodClarification,
+		SkillRef:              epistemics.SkillRef(reminderResponseSkillID),
+		ExpectedOutcome:       epistemics.OutcomeSuccess,
+		ActualOutcome:         epistemics.OutcomeUserCorrected,
+		OutcomeDetail:         "human correction indicates prior interpretation or target resolution may be wrong",
+		CorrectionUtteranceID: epistemics.SourceUtteranceRef(input.Utterance.ID),
+		VerificationEvidence:  []epistemics.EvidenceRef{"interaction:human-correction"},
+		ConfidenceMillis:      1000,
+		RecordedAtUnixMillis:  input.At.UnixMilli(),
+	}
+	saved, ok := r.saveExperienceAndReflection(ctx, experience)
+	if ok {
+		r.updateReminderSkill(ctx, saved, capability.UsageFailed, true)
+	}
+}
+
+func (r learningRecorder) recordFastPathDecline(ctx context.Context, input fastPathDeclineLearningInput) {
+	if r.epistemics == nil || input.Intent.ID == "" || input.Utterance.ID == "" {
+		return
+	}
+	experience, err := epistemicsdomain.FastPathDeclineExperience(
+		epistemics.OriginalIntentRef(input.Intent.ID),
+		epistemics.SourceUtteranceRef(input.Utterance.ID),
+		epistemics.SkillRef(reminderResponseSkillID),
+		string(outcomeForDecline(input.Reason)),
+		input.At.UnixMilli(),
+	)
+	if err != nil {
+		return
+	}
+	if input.Result.Response.ID != "" {
+		experience.ContextRefs = contextRefs("continuity:response-candidate:" + string(input.Result.Response.Operation))
+	}
+	saved, ok := r.saveExperienceAndReflection(ctx, experience)
+	if ok {
+		r.updateReminderSkill(ctx, saved, capability.UsageSkipped, false)
+	}
+}
+
+func (r learningRecorder) recordCapabilityUse(ctx context.Context, input capabilityLearningInput) {
+	if r.epistemics == nil || input.Intent.ID == "" || input.Utterance.ID == "" {
+		return
+	}
+	actual := epistemics.OutcomeSuccess
+	switch input.Outcome {
+	case capability.UsageFailed:
+		actual = epistemics.OutcomeFailed
+	case capability.UsageSkipped:
+		actual = epistemics.OutcomeNotApplicable
+	case capability.UsageUnknown:
+		actual = epistemics.OutcomeUnknown
+	}
+	experience := epistemics.ExperienceRecord{
+		SourceKind:                    epistemics.ExperienceSourceCapability,
+		OriginalIntentID:              epistemics.OriginalIntentRef(input.Intent.ID),
+		SourceUtteranceID:             epistemics.SourceUtteranceRef(input.Utterance.ID),
+		HelpMethod:                    epistemics.HelpMethodCapabilityExecution,
+		CapabilityImplementationRef:   epistemics.CapabilityImplementationRef(input.ImplementationID),
+		CapabilityUsageObservationRef: epistemics.CapabilityUsageObservationRef(input.UsageObservation),
+		CapabilityGapRef:              epistemics.CapabilityGapRef(input.GapID),
+		ExpectedOutcome:               epistemics.OutcomeSuccess,
+		ActualOutcome:                 actual,
+		OutcomeRef:                    input.OutcomeRef,
+		OutcomeDetail:                 "capability outcome " + string(input.Outcome),
+		VerificationEvidence:          []epistemics.EvidenceRef{"capability:usage-observation"},
+		ConfidenceMillis:              900,
+		RecordedAtUnixMillis:          input.At.UnixMilli(),
+	}
+	r.saveExperienceAndReflection(ctx, experience)
+}
+
+func (r learningRecorder) recordDelegationOutcome(ctx context.Context, input delegationLearningInput) {
+	if r.epistemics == nil || input.Intent.ID == "" || input.Utterance.ID == "" || input.ImplementationID == "" {
+		return
+	}
+	actual := epistemics.OutcomeSuccess
+	confidence := int64(950)
+	if !input.Verified {
+		actual = epistemics.OutcomeFailed
+		confidence = 850
+	}
+	detailParts := []string{"delegation outcome recorded"}
+	if input.ExecutionWindows > 1 {
+		detailParts = append(detailParts, "execution-window-continuations="+strconv.Itoa(input.ExecutionWindows-1))
+	}
+	if input.HumanBlocked {
+		detailParts = append(detailParts, "human-blocker-occurred")
+	}
+	experience := epistemics.ExperienceRecord{
+		SourceKind:                  epistemics.ExperienceSourceCapability,
+		OriginalIntentID:            epistemics.OriginalIntentRef(input.Intent.ID),
+		SourceUtteranceID:           epistemics.SourceUtteranceRef(input.Utterance.ID),
+		ContextRefs:                 contextRefs("work:delegation:"+input.DelegationID, "work:run:"+input.RunID),
+		HelpMethod:                  epistemics.HelpMethodCapabilityExecution,
+		HelpMethodRef:               "work:agent-delegation-v1",
+		CapabilityImplementationRef: epistemics.CapabilityImplementationRef(input.ImplementationID),
+		ExpectedOutcome:             epistemics.OutcomeSuccess,
+		ActualOutcome:               actual,
+		OutcomeRef:                  input.OutcomeRef,
+		OutcomeDetail:               strings.Join(detailParts, "; "),
+		VerificationEvidence:        input.VerificationRefs,
+		ConfidenceMillis:            confidence,
+		RecordedAtUnixMillis:        input.At.UnixMilli(),
+	}
+	r.saveExperienceAndReflection(ctx, experience)
+}
+
+func (r learningRecorder) saveExperienceAndReflection(ctx context.Context, value epistemics.ExperienceRecord) (epistemics.ExperienceRecord, bool) {
+	value, err := epistemicsdomain.NewExperienceRecord(value)
+	if err != nil {
+		log.Printf("learning experience invalid: %v", err)
+		return epistemics.ExperienceRecord{}, false
+	}
+	if err := r.epistemics.SaveExperienceRecord(ctx, value); err != nil {
+		log.Printf("learning experience unavailable: %v", err)
+		return epistemics.ExperienceRecord{}, false
+	}
+	if candidate, ok, err := epistemicsdomain.ReflectionForExperience(value); err == nil && ok {
+		if err := r.epistemics.SaveReflectionCandidate(ctx, candidate); err != nil {
+			log.Printf("learning reflection unavailable: %v", err)
+		}
+	} else if err != nil {
+		log.Printf("learning reflection invalid: %v", err)
+	}
+	return value, true
+}
+
+func (r learningRecorder) updateReminderSkill(ctx context.Context, experience epistemics.ExperienceRecord, outcome capability.UsageOutcomeClass, corrected bool) {
+	if r.capability == nil || experience.ID == "" {
+		return
+	}
+	profile, err := r.capability.LoadSkillProfile(ctx, reminderResponseSkillID)
+	if err != nil {
+		log.Printf("learning skill profile unavailable: %v", err)
+		return
+	}
+	next, err := capabilitydomain.ObserveSkillOutcome(profile, capability.SkillOutcomeObservation{
+		ExperienceRef:        capability.SkillEvidenceRef("epistemics:experience:" + string(experience.ID)),
+		Outcome:              outcome,
+		UserCorrected:        corrected,
+		ObservedAtUnixMillis: experience.RecordedAtUnixMillis,
+	})
+	if err != nil {
+		log.Printf("learning skill observation invalid: %v", err)
+		return
+	}
+	if err := r.capability.SaveSkillProfile(ctx, next); err != nil {
+		log.Printf("learning skill profile save unavailable: %v", err)
+		return
+	}
+}
+
+func outcomeForHumanResponse(response continuity.HumanResponse) (epistemics.OutcomeClass, int64) {
+	if response.ResolutionState != continuity.ResponseResolved {
+		switch response.ResolutionState {
+		case continuity.ResponseAmbiguous:
+			return epistemics.OutcomeConflict, 850
+		case continuity.ResponseNoTarget:
+			return epistemics.OutcomeOutOfDistribution, 850
+		default:
+			return epistemics.OutcomeUnexpected, 700
+		}
+	}
+	switch response.Outcome {
+	case continuity.ResponseOutcomeUserReportedComplete, continuity.ResponseOutcomeSnoozed, continuity.ResponseOutcomeCancelled, continuity.ResponseOutcomeDismissed:
+		return epistemics.OutcomeSuccess, 950
+	case continuity.ResponseOutcomeClarificationNeeded:
+		return epistemics.OutcomeConflict, 850
+	default:
+		return epistemics.OutcomeUnknown, 500
+	}
+}
+
+func skillOutcomeForExperience(experience epistemics.ExperienceRecord) capability.UsageOutcomeClass {
+	switch experience.ActualOutcome {
+	case epistemics.OutcomeSuccess, epistemics.OutcomePartialSuccess:
+		return capability.UsageSucceeded
+	case epistemics.OutcomeFailed, epistemics.OutcomeUnexpected, epistemics.OutcomeUserCorrected:
+		return capability.UsageFailed
+	case epistemics.OutcomeUnknown:
+		return capability.UsageUnknown
+	default:
+		return capability.UsageSkipped
+	}
+}
+
+func outcomeForDecline(reason capability.FastPathDeclineReason) epistemics.OutcomeClass {
+	switch reason {
+	case capability.FastPathLowConfidence:
+		return epistemics.OutcomeLowConfidence
+	case capability.FastPathOutOfDistribution:
+		return epistemics.OutcomeOutOfDistribution
+	case capability.FastPathConflict:
+		return epistemics.OutcomeConflict
+	case capability.FastPathStale:
+		return epistemics.OutcomeStale
+	default:
+		return epistemics.OutcomeNotApplicable
+	}
+}
+
+func contextRefs(values ...string) []epistemics.ContextRef {
+	refs := make([]epistemics.ContextRef, 0, len(values))
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value == "" || strings.HasSuffix(value, ":") {
+			continue
+		}
+		refs = append(refs, epistemics.ContextRef(value))
+	}
+	return refs
+}
+
+func looksLikeUnsupportedContinuation(message string, result continuity.HumanResponseResult) bool {
+	lower := strings.ToLower(strings.TrimSpace(message))
+	if result.Handled {
+		return false
+	}
+	if result.Response.Operation == continuity.ResponseContinue || result.Response.Operation == continuity.ResponseReject {
+		return true
+	}
+	return strings.Contains(lower, "это") && (strings.Contains(lower, "напомин") || strings.Contains(lower, "перенеси") || strings.Contains(lower, "закрой") || strings.Contains(lower, "передвинь"))
+}
+
+func declineReasonForResponse(result continuity.HumanResponseResult) capability.FastPathDeclineReason {
+	switch result.Response.Operation {
+	case continuity.ResponseReject:
+		return capability.FastPathConflict
+	case continuity.ResponseContinue:
+		return capability.FastPathNotApplicable
+	default:
+		return capability.FastPathOutOfDistribution
+	}
+}

cmd/core-runtime/main.go

@@ -68,6 +68,19 @@ func main() {
 		log.Fatal(err)
 	}
 	defer capabilityRepository.Close()
+	epistemicsPassword, err := readCredentialRefSecret("EPISTEMICS_POSTGRES_PASSWORD", "EPISTEMICS_POSTGRES_CREDENTIAL_REF")
+	if err != nil {
+		log.Fatal(err)
+	}
+	epistemicsUser := os.Getenv("EPISTEMICS_POSTGRES_USER")
+	if epistemicsUser == "" {
+		epistemicsUser = "epistemics_role"
+	}
+	epistemicsRepository, err := postgres.OpenEpistemics(context.Background(), postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: epistemicsUser, Password: epistemicsPassword})
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer epistemicsRepository.Close()
 	identityRepository, err := postgres.OpenIdentity(context.Background(), postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: os.Getenv("IDENTITY_POSTGRES_USER"), Password: os.Getenv("IDENTITY_POSTGRES_PASSWORD")})
 	if err != nil {
 		log.Fatal(err)
@@ -94,6 +107,11 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	attentionClient, err := newContinuityAttentionClient(envOr("CONTINUITY_RUNTIME_URL", "http://continuity-runtime:8081"), &http.Client{Timeout: 5 * time.Second})
+	if err != nil {
+		log.Fatal(err)
+	}
+	learning := learningRecorder{epistemics: epistemicsRepository, capability: capabilityRepository}
 	mux := http.NewServeMux()
 	authenticateCreator := func(w http.ResponseWriter, r *http.Request) (identity.CreatorSession, bool) {
 		session, err := identitydomain.ValidateCreatorSession(sessionKey, bearerToken(r), time.Now())
@@ -172,6 +190,45 @@ func main() {
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(status)
 	})
+	mux.HandleFunc("GET /v1/creator/learning/recent", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		limit := 10
+		if raw := r.URL.Query().Get("limit"); raw != "" {
+			parsed, err := strconv.Atoi(raw)
+			if err != nil || parsed < 1 || parsed > 50 {
+				http.Error(w, "invalid learning limit", http.StatusBadRequest)
+				return
+			}
+			limit = parsed
+		}
+		experiences, err := epistemicsRepository.RecentExperienceRecords(r.Context(), limit)
+		if err != nil {
+			log.Printf("learning recent experiences unavailable: %v", err)
+			http.Error(w, "learning experience unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		reflections, err := epistemicsRepository.RecentReflectionCandidates(r.Context(), limit)
+		if err != nil {
+			log.Printf("learning recent reflections unavailable: %v", err)
+			http.Error(w, "learning reflection unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		skills, err := capabilityRepository.RecentSkillProfiles(r.Context(), limit)
+		if err != nil {
+			log.Printf("learning recent skills unavailable: %v", err)
+			http.Error(w, "learning skills unavailable", http.StatusServiceUnavailable)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Cache-Control", "no-store")
+		_ = json.NewEncoder(w).Encode(struct {
+			Experiences []epistemics.ExperienceRecord
+			Reflections []epistemics.ReflectionCandidate
+			Skills      []capability.SkillProfile
+		}{Experiences: experiences, Reflections: reflections, Skills: skills})
+	})
 	mux.HandleFunc("POST /v1/creator/chat/messages", func(w http.ResponseWriter, r *http.Request) {
 		session, ok := authenticateCreator(w, r)
 		if !ok {
@@ -245,6 +302,9 @@ func main() {
 			Message:               utterance.Content,
 			RequestedAtUnixMillis: now.UnixMilli(),
 		})
+		if semantic.Interpretation.SpeechAct == interaction.SpeechActCorrection {
+			learning.recordCorrection(r.Context(), correctionLearningInput{Utterance: utterance, Intent: intent, At: now})
+		}
 		activeFocusName := ""
 		activeFocusProvenance := situation.ProjectResolutionProvenance("")
 		if semantic.ActiveFocus != nil {
@@ -270,6 +330,12 @@ func main() {
 		if responseErr == nil && responseResult.Handled {
 			planningReply = responseResult.Reply
 			needsCognition = false
+			learning.recordReminderResponse(r.Context(), reminderResponseLearningInput{Utterance: utterance, Intent: intent, Result: responseResult, At: now})
+			if resumed, err := continueDelegationFromHumanResponse(r.Context(), workRepository, responseResult.Response, now); err == nil && resumed {
+				planningReply = "Принял. Продолжаю ту же задачу coding-agent без потери контекста."
+			}
+		} else if responseErr == nil && looksLikeUnsupportedContinuation(utterance.Content, responseResult) {
+			learning.recordFastPathDecline(r.Context(), fastPathDeclineLearningInput{Utterance: utterance, Intent: intent, Result: responseResult, Reason: declineReasonForResponse(responseResult), At: now})
 		}
 		planningInput := work.PlanningInput{
 			ConversationID:        work.ConversationRef(conversation.ID),
@@ -306,6 +372,8 @@ func main() {
 		var capabilityStatus capability.CapabilityResolutionStatus
 		var capabilityKind capability.CapabilityKind
 		var capabilityGapID capability.CapabilityGapID
+		var delegationID work.DelegationID
+		var delegationState work.DelegationState
 		var reminder *continuity.ProspectiveItem
 		if helpPath.Kind == work.HelpPathDirectCapability && len(helpPath.SuggestedCapabilityKinds) > 0 {
 			capabilityKind = helpPath.SuggestedCapabilityKinds[0]
@@ -320,10 +388,12 @@ func main() {
 					if scheduleErr == nil {
 						reminder = &result.Item
 						planningReply = fmt.Sprintf("Готово. Я создал напоминание: %s.", result.Item.Summary)
-						observeCapabilityUsage(r.Context(), capabilityRepository, resolution.Eligible[0], resolution.Requirement, capability.UsageSucceeded, string(result.Item.ID), started, finished)
+						usageID, _ := observeCapabilityUsage(r.Context(), capabilityRepository, resolution.Eligible[0], resolution.Requirement, capability.UsageSucceeded, string(result.Item.ID), started, finished)
+						learning.recordCapabilityUse(r.Context(), capabilityLearningInput{Utterance: utterance, Intent: intent, ImplementationID: resolution.Eligible[0].Implementation.ID, UsageObservation: usageID, Outcome: capability.UsageSucceeded, OutcomeRef: "continuity:prospective:" + string(result.Item.ID), At: finished})
 					} else {
 						planningReply = "Scheduling capability сейчас недоступна: напоминание не создано. Я не буду притворяться, что действие выполнено."
-						observeCapabilityUsage(r.Context(), capabilityRepository, resolution.Eligible[0], resolution.Requirement, capability.UsageFailed, "continuity-reminder-unavailable", started, finished)
+						usageID, _ := observeCapabilityUsage(r.Context(), capabilityRepository, resolution.Eligible[0], resolution.Requirement, capability.UsageFailed, "continuity-reminder-unavailable", started, finished)
+						learning.recordCapabilityUse(r.Context(), capabilityLearningInput{Utterance: utterance, Intent: intent, ImplementationID: resolution.Eligible[0].Implementation.ID, UsageObservation: usageID, Outcome: capability.UsageFailed, OutcomeRef: "continuity-reminder-unavailable", At: finished})
 					}
 				} else {
 					planningReply = "Мне нужно уточнить время напоминания. Например: «Напомни завтра в 10 позвонить врачу»."
@@ -332,6 +402,7 @@ func main() {
 			} else if resolution.Gap != nil {
 				capabilityGapID = resolution.Gap.ID
 				planningReply = "Сейчас scheduling capability недоступна, поэтому напоминание не создано. Я зафиксировал capability gap."
+				learning.recordCapabilityUse(r.Context(), capabilityLearningInput{Utterance: utterance, Intent: intent, GapID: resolution.Gap.ID, Outcome: capability.UsageSkipped, OutcomeRef: "capability:gap:" + string(resolution.Gap.ID), At: now})
 			}
 			needsCognition = false
 		}
@@ -344,6 +415,7 @@ func main() {
 			} else if resolution.Gap != nil {
 				capabilityGapID = resolution.Gap.ID
 				planningReply = "Сейчас у меня ещё не подключена возможность отправлять почту. Я зафиксировал capability gap, без ложного выполнения."
+				learning.recordCapabilityUse(r.Context(), capabilityLearningInput{Utterance: utterance, Intent: intent, GapID: resolution.Gap.ID, Outcome: capability.UsageSkipped, OutcomeRef: "capability:gap:" + string(resolution.Gap.ID), At: now})
 			}
 			needsCognition = false
 		}
@@ -360,6 +432,18 @@ func main() {
 			planningReply = planning.Reply
 			workPlanned = true
 			needsCognition = false
+			if created, resolution, createErr := maybeCreateAgentDelegation(r.Context(), workRepository, capabilityRepository, session, conversation, intent, utterance, planning, now); createErr == nil && created != nil {
+				delegationID = created.Delegation.ID
+				delegationState = created.Delegation.State
+				capabilityKind = created.Delegation.CapabilityKind
+				capabilityStatus = resolution.Status
+				planningReply = "Понял задачу. Я собрал work item, выбрал coding-agent в CANARY-режиме и создал delegation. Буду вести её как отдельный run с checkpoint/resume, без потери исходного human intent."
+			} else if resolution.Gap != nil {
+				capabilityKind = resolution.Requirement.CapabilityKind
+				capabilityStatus = resolution.Status
+				capabilityGapID = resolution.Gap.ID
+				planningReply = planningReply + " Для coding delegation подходящий agent implementation сейчас недоступен, поэтому я сохранил план без ложного запуска."
+			}
 		}
 		response := interaction.ChatMessageResponse{
 			ConversationID:      conversation.ID,
@@ -377,6 +461,8 @@ func main() {
 			CapabilityStatus:    capabilityStatus,
 			CapabilityKind:      capabilityKind,
 			CapabilityGapID:     capabilityGapID,
+			DelegationID:        string(delegationID),
+			DelegationState:     string(delegationState),
 			Reminder:            reminder,
 		}
 		w.Header().Set("Content-Type", "application/json")
@@ -384,6 +470,210 @@ func main() {
 		w.WriteHeader(http.StatusCreated)
 		_ = json.NewEncoder(w).Encode(response)
 	})
+	mux.HandleFunc("GET /v1/creator/delegations/{id}", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		value, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
+		if err != nil {
+			http.Error(w, "delegation not found", http.StatusNotFound)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(value)
+	})
+	mux.HandleFunc("GET /v1/creator/delegations/{id}/latest-checkpoint", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		value, err := workRepository.LatestAgentCheckpoint(r.Context(), work.DelegationID(r.PathValue("id")))
+		if err != nil {
+			http.Error(w, "checkpoint not found", http.StatusNotFound)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(value)
+	})
+	mux.HandleFunc("POST /v1/creator/delegations/{id}/runs/{run}/checkpoints", func(w http.ResponseWriter, r *http.Request) {
+		session, ok := authenticateCreator(w, r)
+		if !ok {
+			return
+		}
+		var request struct {
+			BlockerClass         work.AgentBlockerClass
+			CompletedSummary     string
+			RemainingSummary     string
+			TestSummary          string
+			BranchName           string
+			CommitHash           string
+			NextStep             string
+			ArtifactRefs         []work.EvidenceRef
+			RecordedAtUnixMillis int64
+		}
+		decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&request); err != nil {
+			http.Error(w, "invalid checkpoint", http.StatusBadRequest)
+			return
+		}
+		run, err := workRepository.LoadAgentRun(r.Context(), work.AgentRunID(r.PathValue("run")))
+		if err != nil || run.DelegationID != work.DelegationID(r.PathValue("id")) {
+			http.Error(w, "run not found", http.StatusNotFound)
+			return
+		}
+		updatedRun, checkpoint, err := workdomain.CheckpointRun(run, request.BlockerClass, request.CompletedSummary, request.RemainingSummary, request.TestSummary, request.BranchName, request.CommitHash, request.NextStep, request.ArtifactRefs, time.UnixMilli(request.RecordedAtUnixMillis))
+		if err != nil {
+			http.Error(w, "invalid checkpoint", http.StatusBadRequest)
+			return
+		}
+		if err := workRepository.SaveAgentCheckpoint(r.Context(), updatedRun, checkpoint); err != nil {
+			http.Error(w, "save checkpoint", http.StatusInternalServerError)
+			return
+		}
+		if request.BlockerClass == work.AgentBlockerHumanDecisionRequired {
+			delegation, err := workRepository.LoadDelegation(r.Context(), run.DelegationID)
+			if err == nil {
+				_, _ = attentionClient.Create(r.Context(), r.Header.Get("Authorization"), continuity.CreateAttentionRequest{
+					OwnerPrincipalID:    session.PrincipalID,
+					ScopeID:             authority.ScopeID("domovoy-global-scope"),
+					SourceKind:          continuity.AttentionSourceAgentDelegation,
+					SourceExternalRef:   delegationAttentionRef(delegation.ID),
+					Level:               continuity.AttentionActionRequired,
+					Summary:             "Нужен твой выбор по задаче coding-agent: " + firstNonEmpty(request.RemainingSummary, delegation.DesiredOutcome),
+					DueAtUnixMillis:     checkpoint.RecordedAtUnixMillis,
+					CreatedAtUnixMillis: checkpoint.RecordedAtUnixMillis,
+				})
+			}
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(checkpoint)
+	})
+	mux.HandleFunc("POST /v1/creator/delegations/{id}/runs/{run}/results", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		var request struct {
+			Summary              string
+			OutcomeRef           string
+			VerificationSummary  string
+			ArtifactRefs         []work.EvidenceRef
+			RecordedAtUnixMillis int64
+		}
+		decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&request); err != nil {
+			http.Error(w, "invalid result", http.StatusBadRequest)
+			return
+		}
+		run, err := workRepository.LoadAgentRun(r.Context(), work.AgentRunID(r.PathValue("run")))
+		if err != nil || run.DelegationID != work.DelegationID(r.PathValue("id")) {
+			http.Error(w, "run not found", http.StatusNotFound)
+			return
+		}
+		updatedRun, result, err := workdomain.CompleteRun(run, request.Summary, request.OutcomeRef, request.VerificationSummary, request.ArtifactRefs, time.UnixMilli(request.RecordedAtUnixMillis))
+		if err != nil {
+			http.Error(w, "invalid result", http.StatusBadRequest)
+			return
+		}
+		if err := workRepository.SaveAgentResult(r.Context(), updatedRun, result); err != nil {
+			http.Error(w, "save result", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(result)
+	})
+	mux.HandleFunc("POST /v1/creator/delegations/{id}/resume", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		delegation, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
+		if err != nil {
+			http.Error(w, "delegation not found", http.StatusNotFound)
+			return
+		}
+		run, err := workRepository.LoadAgentRun(r.Context(), delegation.LatestRunID)
+		if err != nil {
+			http.Error(w, "run not found", http.StatusNotFound)
+			return
+		}
+		checkpoint, err := workRepository.LatestAgentCheckpoint(r.Context(), delegation.ID)
+		if err != nil {
+			http.Error(w, "checkpoint not found", http.StatusNotFound)
+			return
+		}
+		updatedDelegation, resumedRun, err := workdomain.ResumeDelegationRun(delegation, run, checkpoint, time.Now())
+		if err != nil {
+			http.Error(w, "resume not allowed", http.StatusConflict)
+			return
+		}
+		if err := workRepository.SaveResumedRun(r.Context(), updatedDelegation, resumedRun); err != nil {
+			http.Error(w, "save resumed run", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(resumedRun)
+	})
+	mux.HandleFunc("POST /v1/creator/delegations/{id}/verify", func(w http.ResponseWriter, r *http.Request) {
+		if _, ok := authenticateCreator(w, r); !ok {
+			return
+		}
+		var request struct {
+			Verified             bool
+			Summary              string
+			EvidenceRefs         []work.EvidenceRef
+			RecordedAtUnixMillis int64
+		}
+		decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
+		decoder.DisallowUnknownFields()
+		if err := decoder.Decode(&request); err != nil || request.RecordedAtUnixMillis < 1 {
+			http.Error(w, "invalid verification", http.StatusBadRequest)
+			return
+		}
+		delegation, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
+		if err != nil {
+			http.Error(w, "delegation not found", http.StatusNotFound)
+			return
+		}
+		run, err := workRepository.LoadAgentRun(r.Context(), delegation.LatestRunID)
+		if err != nil {
+			http.Error(w, "run not found", http.StatusNotFound)
+			return
+		}
+		result, err := workRepository.LatestAgentResult(r.Context(), delegation.ID)
+		if err != nil {
+			http.Error(w, "result not found", http.StatusNotFound)
+			return
+		}
+		updatedDelegation, verification, err := workdomain.VerifyDelegationResult(delegation, run, result, request.Verified, request.Summary, request.EvidenceRefs, time.UnixMilli(request.RecordedAtUnixMillis))
+		if err != nil {
+			http.Error(w, "invalid verification", http.StatusBadRequest)
+			return
+		}
+		if err := workRepository.SaveDelegationVerification(r.Context(), updatedDelegation, verification); err != nil {
+			http.Error(w, "save verification", http.StatusInternalServerError)
+			return
+		}
+		runCount, _ := workRepository.CountAgentRuns(r.Context(), delegation.ID)
+		learning.recordDelegationOutcome(r.Context(), delegationLearningInput{
+			Intent:           interaction.OriginalHumanIntent{ID: interaction.OriginalHumanIntentID(delegation.SourceIntentID), Text: delegation.DesiredOutcome},
+			Utterance:        interaction.HumanUtterance{ID: interaction.HumanUtteranceID(delegation.SourceUtteranceID), Content: delegation.DesiredOutcome},
+			DelegationID:     string(delegation.ID),
+			RunID:            string(run.ID),
+			ImplementationID: run.ImplementationID,
+			OutcomeRef:       result.OutcomeRef,
+			VerificationRefs: evidenceRefsToEpistemics(request.EvidenceRefs),
+			Verified:         request.Verified,
+			ExecutionWindows: runCount,
+			HumanBlocked:     false,
+			At:               time.UnixMilli(request.RecordedAtUnixMillis),
+		})
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusCreated)
+		_ = json.NewEncoder(w).Encode(verification)
+	})
 	mux.HandleFunc("GET /v1/principal-bindings/{actor}/{principal}", func(w http.ResponseWriter, r *http.Request) {
 		binding, err := identityRepository.LoadBinding(r.Context(), identity.ActorID(r.PathValue("actor")), identity.PrincipalID(r.PathValue("principal")))
 		if err != nil {
@@ -796,3 +1086,54 @@ func humanCapabilityList(kinds []capability.CapabilityKind) string {
 	}
 	return strings.Join(labels, ", ")
 }
+
+func delegationAttentionRef(id work.DelegationID) string {
+	return "work:delegation:" + string(id)
+}
+
+func continueDelegationFromHumanResponse(ctx context.Context, repository *postgres.WorkRepository, response continuity.HumanResponse, now time.Time) (bool, error) {
+	if response.Operation != continuity.ResponseContinue || !strings.HasPrefix(response.TargetExternalRef, "work:delegation:") {
+		return false, nil
+	}
+	delegationID := work.DelegationID(strings.TrimPrefix(response.TargetExternalRef, "work:delegation:"))
+	delegation, err := repository.LoadDelegation(ctx, delegationID)
+	if err != nil {
+		return false, err
+	}
+	run, err := repository.LoadAgentRun(ctx, delegation.LatestRunID)
+	if err != nil {
+		return false, err
+	}
+	checkpoint, err := repository.LatestAgentCheckpoint(ctx, delegationID)
+	if err != nil {
+		return false, err
+	}
+	updatedDelegation, resumedRun, err := workdomain.ResumeDelegationRun(delegation, run, checkpoint, now)
+	if err != nil {
+		return false, err
+	}
+	if err := repository.SaveResumedRun(ctx, updatedDelegation, resumedRun); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
+func evidenceRefsToEpistemics(values []work.EvidenceRef) []epistemics.EvidenceRef {
+	result := make([]epistemics.EvidenceRef, 0, len(values))
+	for _, value := range values {
+		if strings.TrimSpace(string(value)) == "" {
+			continue
+		}
+		result = append(result, epistemics.EvidenceRef(value))
+	}
+	return result
+}

cmd/creator-web/server.go

@@ -154,6 +154,8 @@ type browserChatResponse struct {
 	WorkPlanned       bool   `json:"work_planned"`
 	CapabilityStatus  string `json:"capability_status"`
 	CapabilityKind    string `json:"capability_kind"`
+	DelegationID      string `json:"delegation_id"`
+	DelegationState   string `json:"delegation_state"`
 	ReminderScheduled bool   `json:"reminder_scheduled"`
 }
 
@@ -353,7 +355,22 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Cache-Control", "no-store")
-	_ = json.NewEncoder(w).Encode(browserChatResponse{ConversationID: string(saved.ConversationID), UtteranceID: string(saved.UtteranceID), SpeechAct: string(saved.SpeechAct), ReplyText: reply, Cognition: cognition, ActiveFocus: saved.ActiveProjectName, ProjectProvenance: string(saved.ProjectProvenance), Clarification: string(saved.Clarification), WorkPlanned: saved.WorkPlanned, CapabilityStatus: string(saved.CapabilityStatus), CapabilityKind: string(saved.CapabilityKind), ReminderScheduled: saved.Reminder != nil})
+	_ = json.NewEncoder(w).Encode(browserChatResponse{
+		ConversationID:    string(saved.ConversationID),
+		UtteranceID:       string(saved.UtteranceID),
+		SpeechAct:         string(saved.SpeechAct),
+		ReplyText:         reply,
+		Cognition:         cognition,
+		ActiveFocus:       saved.ActiveProjectName,
+		ProjectProvenance: string(saved.ProjectProvenance),
+		Clarification:     string(saved.Clarification),
+		WorkPlanned:       saved.WorkPlanned,
+		CapabilityStatus:  string(saved.CapabilityStatus),
+		CapabilityKind:    string(saved.CapabilityKind),
+		DelegationID:      saved.DelegationID,
+		DelegationState:   saved.DelegationState,
+		ReminderScheduled: saved.Reminder != nil,
+	})
 }
 
 func asksAttention(message string) bool {
@@ -536,6 +553,8 @@ func creatorRoute(method, path string) (routeTarget, string, bool) {
 		if validID(id) {
 			return targetCore, "/v1/creator/capabilities/" + id + "/health", true
 		}
+	case method == http.MethodGet && path == "/api/learning/recent":
+		return targetCore, "/v1/creator/learning/recent", true
 	case method == http.MethodGet && strings.HasPrefix(path, "/api/prospective-items/"):
 		id := strings.TrimPrefix(path, "/api/prospective-items/")
 		if validID(id) {

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

@@ -62,11 +62,31 @@ async function api(path, options = {}) {
 
 function humanMeta(result) {
   if (result.reminder_scheduled) return "Напоминание сохранено. Я вернусь к нему сам.";
+  if (result.delegation_id && result.delegation_state) return `Передал в coding-agent: ${humanDelegationState(result.delegation_state)}.`;
   if (result.capability_status && result.capability_status !== "AVAILABLE") return "Возможность пока не подключена.";
   if (result.work_planned) return "Я разложил это как работу.";
   return "";
 }
 
+function humanDelegationState(state) {
+  switch (state) {
+    case "RUNNING":
+      return "работа запущена";
+    case "WAITING":
+      return "ожидаю следующий шаг";
+    case "BLOCKED":
+      return "нужно решение человека";
+    case "VERIFYING":
+      return "результат проверяется";
+    case "COMPLETED":
+      return "работа завершена";
+    case "FAILED":
+      return "run завершился ошибкой";
+    default:
+      return state.toLowerCase();
+  }
+}
+
 function renderHistory() {
   if (!historyList) return;
   historyList.replaceChildren();

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

@@ -141,9 +141,11 @@ button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px
 .register-empty { margin: 0; padding: 22px 18px; color: var(--faint); font-size: 11px; }
 
 .activity-panel { margin-bottom: 18px; border: 1px solid var(--line); background: rgba(13, 20, 17, .9); }
+.learning-panel { margin-bottom: 18px; border: 1px solid rgba(120,198,163,.3); background: linear-gradient(135deg, rgba(22,31,27,.92), rgba(10,16,14,.94)); box-shadow: inset 3px 0 0 rgba(120,198,163,.38); }
 .activity-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); }
-.activity-panel header p { margin: 0 0 6px; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .13em; text-transform: uppercase; }
-.activity-panel h2 { margin: 0; font: 400 22px/1 var(--serif); }
+.learning-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); }
+.activity-panel header p, .learning-panel header p { margin: 0 0 6px; color: var(--faint); font: 9px/1 var(--mono); letter-spacing: .13em; text-transform: uppercase; }
+.activity-panel h2, .learning-panel h2 { margin: 0; font: 400 22px/1 var(--serif); }
 .activity-tools { display: flex; align-items: center; gap: 12px; color: var(--muted); font: 9px/1 var(--mono); letter-spacing: .1em; }
 .activity-tools .icon-button { color: var(--muted); font-size: 18px; }
 .activity-list { max-height: 300px; overflow: auto; scrollbar-color: var(--faint) transparent; }
@@ -167,6 +169,23 @@ button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px
 .activity-reconcile:disabled { opacity: .55; cursor: wait; }
 .activity-error { color: var(--bad); }
 
+.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; }
+.learning-grid h3 { margin: 0; padding: 13px 18px 10px; color: var(--signal); font: 600 10px/1 var(--mono); letter-spacing: .12em; text-transform: uppercase; border-bottom: 1px solid var(--line-soft); }
+.learning-list { max-height: 238px; overflow: auto; scrollbar-color: var(--faint) transparent; }
+.learning-list[aria-busy="true"] { opacity: .72; }
+.learning-row { min-height: 66px; padding: 12px 18px; display: grid; gap: 6px; border-bottom: 1px solid var(--line-soft); }
+.learning-row:last-child { border-bottom: 0; }
+.learning-row:hover { background: rgba(120,198,163,.05); }
+.learning-row strong { color: var(--ink); font: 600 10px/1.35 var(--mono); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.learning-row span { color: var(--muted); font: 10px/1.35 var(--mono); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.learning-row time { color: var(--faint); font: 9px/1.35 var(--mono); }
+.learning-state { width: fit-content; padding: 5px 8px; border: 1px solid currentColor; border-radius: 100px; color: var(--faint); font: 600 8px/1 var(--mono); letter-spacing: .06em; }
+.learning-state[data-state="SUCCESS"], .learning-state[data-state="VALIDATED"] { color: var(--good); }
+.learning-state[data-state="USER_CORRECTED"], .learning-state[data-state="FAILED"], .learning-state[data-state="DEGRADED"], .learning-state[data-state="SUSPENDED"] { color: var(--bad); }
+.learning-state[data-state="CONFLICT"], .learning-state[data-state="OUT_OF_DISTRIBUTION"], .learning-state[data-state="OPEN"], .learning-state[data-state="EVALUATING"] { color: var(--warn); }
+
 .data-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 18px; }
 .data-card { min-width: 0; padding: 24px; border: 1px solid var(--line); background: linear-gradient(145deg, rgba(22, 31, 27, .94), rgba(13, 20, 17, .98)); box-shadow: 0 10px 40px rgba(0,0,0,.12); animation: reveal .55s both; }
 .task-card { animation-delay: .08s; }
@@ -281,7 +300,11 @@ button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px
   .advisor-result { grid-template-columns: 1fr; gap: 10px; }
   .register-panel > header { align-items: start; }
 	.activity-panel > header { align-items: flex-start; }
+	.learning-panel > header { align-items: flex-start; }
 	.activity-tools { align-items: flex-end; flex-direction: column-reverse; }
+	.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; }
 	.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

@@ -84,7 +84,10 @@ async function showConsole() {
   await loadAdvisoryPolicy();
   const context = saveContext();
   if (context["session-id"] && context["workspace-id"]) loadDashboard();
-  else loadActionHistory();
+  else {
+    loadActionHistory();
+    loadLearning();
+  }
 }
 
 function endSession(message = "Сессия завершена.") {
@@ -147,6 +150,7 @@ contextForm.addEventListener("submit", (event) => {
 
 byId("refresh-all").addEventListener("click", loadDashboard);
 byId("refresh-actions").addEventListener("click", loadActionHistory);
+byId("refresh-learning").addEventListener("click", loadLearning);
 byId("logout").addEventListener("click", () => endSession());
 
 advisoryForm.addEventListener("submit", async (event) => {
@@ -234,6 +238,7 @@ async function loadDashboard() {
   }
   work.push(loadProspectiveRegister(context["prospective-id"]));
   work.push(loadActionHistory());
+  work.push(loadLearning());
   if (context["capability-id"]) work.push(loadCapability(context["capability-id"]));
   else setSignal("capability", "не выбрана", "idle");
 
@@ -241,6 +246,106 @@ async function loadDashboard() {
   setText("last-update", `Обновлено ${new Intl.DateTimeFormat("ru-RU", {hour: "2-digit", minute: "2-digit", second: "2-digit"}).format(new Date())}`);
 }
 
+async function loadLearning() {
+  const experienceList = byId("experience-list");
+  const reflectionList = byId("reflection-list");
+  const skillList = byId("skill-list");
+  [experienceList, reflectionList, skillList].forEach((list) => {
+    list.setAttribute("aria-busy", "true");
+    list.replaceChildren();
+    const loading = document.createElement("p");
+    loading.className = "register-empty";
+    loading.textContent = "Читаю learning evidence…";
+    list.append(loading);
+  });
+  try {
+    const result = await request("/api/learning/recent?limit=8");
+    const experiences = Array.isArray(result.Experiences) ? result.Experiences : [];
+    const reflections = Array.isArray(result.Reflections) ? result.Reflections : [];
+    const skills = Array.isArray(result.Skills) ? result.Skills : [];
+    setText("learning-count", `${experiences.length + reflections.length + skills.length} СИГНАЛОВ`);
+    renderLearningList(experienceList, experiences, createExperienceRow, "Experience пока не записан.");
+    renderLearningList(reflectionList, reflections, createReflectionRow, "ReflectionCandidate пока нет.");
+    renderLearningList(skillList, skills, createSkillRow, "SkillProfile пока не загружен.");
+  } catch (error) {
+    [experienceList, reflectionList, skillList].forEach((list) => {
+      list.replaceChildren();
+      const failed = document.createElement("p");
+      failed.className = "register-empty activity-error";
+      failed.textContent = error.message;
+      list.append(failed);
+    });
+    setText("learning-count", "ОШИБКА");
+  } finally {
+    [experienceList, reflectionList, skillList].forEach((list) => list.setAttribute("aria-busy", "false"));
+  }
+}
+
+function renderLearningList(list, items, rowFactory, emptyText) {
+  list.replaceChildren();
+  if (items.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "register-empty";
+    empty.textContent = emptyText;
+    list.append(empty);
+    return;
+  }
+  items.forEach((item) => list.append(rowFactory(item)));
+}
+
+function createExperienceRow(item) {
+  const row = document.createElement("article");
+  row.className = "learning-row";
+  const state = document.createElement("em");
+  state.className = "learning-state";
+  state.dataset.state = item.ActualOutcome || "UNKNOWN";
+  state.textContent = item.ActualOutcome || "UNKNOWN";
+  const title = document.createElement("strong");
+  title.textContent = item.HelpMethod || "help method";
+  const detail = document.createElement("span");
+  detail.textContent = item.OutcomeDetail || item.OutcomeRef || "evidence recorded";
+  const time = document.createElement("time");
+  time.textContent = item.RecordedAtUnixMillis ? new Date(item.RecordedAtUnixMillis).toLocaleString("ru-RU") : "время неизвестно";
+  row.append(state, title, detail, time);
+  return row;
+}
+
+function createReflectionRow(item) {
+  const row = document.createElement("article");
+  row.className = "learning-row";
+  const state = document.createElement("em");
+  state.className = "learning-state";
+  state.dataset.state = item.State || "OPEN";
+  state.textContent = item.Trigger || "REFLECTION";
+  const title = document.createElement("strong");
+  title.textContent = item.State || "OPEN";
+  const detail = document.createElement("span");
+  detail.textContent = item.Summary || "reflection candidate";
+  const time = document.createElement("time");
+  time.textContent = item.RecordedAtUnixMillis ? new Date(item.RecordedAtUnixMillis).toLocaleString("ru-RU") : "время неизвестно";
+  row.append(state, title, detail, time);
+  return row;
+}
+
+function createSkillRow(item) {
+  const row = document.createElement("article");
+  row.className = "learning-row";
+  const state = document.createElement("em");
+  state.className = "learning-state";
+  state.dataset.state = item.Status || "UNKNOWN";
+  state.textContent = item.Status || "UNKNOWN";
+  const title = document.createElement("strong");
+  title.textContent = item.Name || "skill profile";
+  const detail = document.createElement("span");
+  const support = Array.isArray(item.SupportingExperienceRefs) ? item.SupportingExperienceRefs.length : 0;
+  const failures = Array.isArray(item.KnownFailureExperienceRefs) ? item.KnownFailureExperienceRefs.length : 0;
+  detail.textContent = `confidence ${item.ConfidenceMillis ?? "—"} · +${support} / -${failures}`;
+  const time = document.createElement("time");
+  time.textContent = item.RecordedAtUnixMillis ? new Date(item.RecordedAtUnixMillis).toLocaleString("ru-RU") : "время неизвестно";
+  row.append(state, title, detail, time);
+  return row;
+}
+
 async function loadActionHistory() {
   const list = byId("action-history");
   list.setAttribute("aria-busy", "true");

cmd/creator-web/static/index.html

@@ -143,6 +143,30 @@
         </div>
       </section>
 
+      <section class="learning-panel" aria-labelledby="learning-title">
+        <header>
+          <div><p>Learning / evidence</p><h2 id="learning-title">Опыт и reflection</h2></div>
+          <div class="activity-tools">
+            <span id="learning-count">0 СИГНАЛОВ</span>
+            <button id="refresh-learning" class="icon-button" type="button" aria-label="Обновить опыт" title="Обновить опыт">↻</button>
+          </div>
+        </header>
+        <div class="learning-grid">
+          <article>
+            <h3>Experience</h3>
+            <div id="experience-list" class="learning-list" aria-live="polite" aria-busy="false"><p class="register-empty">Опыт ещё не загружен.</p></div>
+          </article>
+          <article>
+            <h3>Reflection</h3>
+            <div id="reflection-list" class="learning-list" aria-live="polite" aria-busy="false"><p class="register-empty">Reflection ещё не загружен.</p></div>
+          </article>
+          <article>
+            <h3>Skills</h3>
+            <div id="skill-list" class="learning-list" aria-live="polite" aria-busy="false"><p class="register-empty">Skill profile ещё не загружен.</p></div>
+          </article>
+        </div>
+      </section>
+
       <section class="data-grid">
         <article class="data-card focus-card">
           <header><span class="card-number">01</span><div><p>Situation</p><h2>Активный фокус</h2></div><span id="focus-badge" class="status-badge neutral">НЕ ЗАГРУЖЕН</span></header>

contracts/continuity/types.go

@@ -58,6 +58,7 @@ type AttentionSourceKind string
 
 const (
 	AttentionSourceProspectiveReminder AttentionSourceKind = "PROSPECTIVE_REMINDER"
+	AttentionSourceAgentDelegation     AttentionSourceKind = "AGENT_DELEGATION"
 )
 
 // ProspectiveItem is canonical future relevance. TriggerAtUnixMillis is an
@@ -99,6 +100,7 @@ type AttentionItem struct {
 	ScopeID               authority.ScopeID
 	SourceKind            AttentionSourceKind
 	SourceProspectiveID   ProspectiveItemID
+	SourceExternalRef     string
 	Level                 AttentionLevel
 	State                 AttentionState
 	Summary               string
@@ -177,6 +179,8 @@ const (
 	ResponseOutcomeCancelled            ResponseOutcome = "CANCELLED"
 	ResponseOutcomeDismissed            ResponseOutcome = "DISMISSED"
 	ResponseOutcomeClarificationNeeded  ResponseOutcome = "CLARIFICATION_NEEDED"
+	ResponseOutcomeContinued            ResponseOutcome = "CONTINUED"
+	ResponseOutcomeRejected             ResponseOutcome = "REJECTED"
 	ResponseOutcomeNoop                 ResponseOutcome = "NOOP"
 )
 
@@ -213,6 +217,18 @@ type HumanResponseResult struct {
 	Reply    string
 }
 
+type CreateAttentionRequest struct {
+	OwnerPrincipalID    identity.PrincipalID
+	ScopeID             authority.ScopeID
+	SourceKind          AttentionSourceKind
+	SourceProspectiveID ProspectiveItemID
+	SourceExternalRef   string
+	Level               AttentionLevel
+	Summary             string
+	DueAtUnixMillis     int64
+	CreatedAtUnixMillis int64
+}
+
 // SatisfyDeliveredSubject is the complete serializable operation subject. It
 // is distinct from a Work TaskTarget, which remains the live justification.
 type SatisfyDeliveredSubject struct {

contracts/interaction/types.go

@@ -136,5 +136,7 @@ type ChatMessageResponse struct {
 	CapabilityStatus    capability.CapabilityResolutionStatus
 	CapabilityKind      capability.CapabilityKind
 	CapabilityGapID     capability.CapabilityGapID
+	DelegationID        string
+	DelegationState     string
 	Reminder            *continuity.ProspectiveItem
 }

contracts/work/types.go

@@ -16,6 +16,11 @@ type WorkPlanID ids.ID
 type PlanStepID ids.ID
 type CapabilityRequirementID ids.ID
 type DelegationCandidateID ids.ID
+type DelegationID ids.ID
+type AgentRunID ids.ID
+type AgentCheckpointID ids.ID
+type AgentResultID ids.ID
+type DelegationVerificationID ids.ID
 type TaskRevision uint64
 type GoalRevision uint64
 type PlanRevision uint64
@@ -25,6 +30,11 @@ type PlanStepKind string
 type CapabilityRequirementState string
 type DelegationCandidateState string
 type DelegationKind string
+type DelegationState string
+type AgentRunState string
+type AgentBlockerClass string
+type AgentExecutionProtocol string
+type EvidenceRef string
 type SourceIntentRef string
 type SourceUtteranceRef string
 type ConversationRef string
@@ -78,6 +88,35 @@ const (
 	DelegationKindHuman       DelegationKind = "HUMAN"
 	DelegationKindUnavailable DelegationKind = "UNAVAILABLE"
 
+	DelegationPending   DelegationState = "PENDING"
+	DelegationRunning   DelegationState = "RUNNING"
+	DelegationWaiting   DelegationState = "WAITING"
+	DelegationBlocked   DelegationState = "BLOCKED"
+	DelegationVerifying DelegationState = "VERIFYING"
+	DelegationCompleted DelegationState = "COMPLETED"
+	DelegationFailed    DelegationState = "FAILED"
+	DelegationCancelled DelegationState = "CANCELLED"
+
+	AgentRunStarted                  AgentRunState = "STARTED"
+	AgentRunRunning                  AgentRunState = "RUNNING"
+	AgentRunWaiting                  AgentRunState = "WAITING"
+	AgentRunCheckpointed             AgentRunState = "CHECKPOINTED"
+	AgentRunExecutionWindowExhausted AgentRunState = "EXECUTION_WINDOW_EXHAUSTED"
+	AgentRunBlocked                  AgentRunState = "BLOCKED"
+	AgentRunFailed                   AgentRunState = "FAILED"
+	AgentRunCompleted                AgentRunState = "COMPLETED"
+	AgentRunCancelled                AgentRunState = "CANCELLED"
+
+	AgentBlockerNone                      AgentBlockerClass = "NONE"
+	AgentBlockerHumanDecisionRequired     AgentBlockerClass = "HUMAN_DECISION_REQUIRED"
+	AgentBlockerMissingExternalCredential AgentBlockerClass = "MISSING_EXTERNAL_CREDENTIAL"
+	AgentBlockerArchitectureDecision      AgentBlockerClass = "ARCHITECTURE_DECISION_REQUIRED"
+	AgentBlockerSecurityConflict          AgentBlockerClass = "SECURITY_CONFLICT"
+	AgentBlockerTechnicalFailure          AgentBlockerClass = "TECHNICAL_FAILURE"
+	AgentBlockerExecutionWindow           AgentBlockerClass = "EXECUTION_WINDOW_EXHAUSTED"
+
+	AgentProtocolCodexBridgeV1 AgentExecutionProtocol = "CODEX_BRIDGE_V1"
+
 	HelpPathAnswer           HelpPathKind = "ANSWER"
 	HelpPathCognition        HelpPathKind = "COGNITION"
 	HelpPathDirectCapability HelpPathKind = "DIRECT_CAPABILITY"
@@ -168,6 +207,87 @@ type WorkPlan struct {
 	RecordedAtUnixMillis int64
 }
 
+type Delegation struct {
+	ID                         DelegationID
+	GoalID                     GoalID
+	PlanID                     WorkPlanID
+	PlanCandidateID            PlanCandidateID
+	CapabilityRequirementID    CapabilityRequirementID
+	CapabilityKind             capability.CapabilityKind
+	SelectedImplementationID   capability.CapabilityImplementationID
+	SelectedImplementationRev  int64
+	SelectedImplementationKind capability.ImplementationKind
+	Protocol                   AgentExecutionProtocol
+	SourceIntentID             SourceIntentRef
+	SourceUtteranceID          SourceUtteranceRef
+	ConversationID             ConversationRef
+	ProjectID                  ProjectRef
+	ProjectDisplayName         string
+	DesiredOutcome             string
+	ConstraintSummary          string
+	VerificationSummary        string
+	ContextSummary             string
+	ContextRefs                []string
+	State                      DelegationState
+	LatestRunID                AgentRunID
+	LatestResultID             AgentResultID
+	CreatedAtUnixMillis        int64
+	UpdatedAtUnixMillis        int64
+}
+
+type AgentRun struct {
+	ID                        AgentRunID
+	DelegationID              DelegationID
+	ImplementationID          capability.CapabilityImplementationID
+	ImplementationRevision    int64
+	Protocol                  AgentExecutionProtocol
+	State                     AgentRunState
+	DerivedInstructionSummary string
+	StartedAtUnixMillis       int64
+	UpdatedAtUnixMillis       int64
+	CompletedAtUnixMillis     int64
+}
+
+type AgentCheckpoint struct {
+	ID                   AgentCheckpointID
+	DelegationID         DelegationID
+	RunID                AgentRunID
+	State                AgentRunState
+	BlockerClass         AgentBlockerClass
+	CompletedSummary     string
+	RemainingSummary     string
+	TestSummary          string
+	BranchName           string
+	CommitHash           string
+	NextStep             string
+	ArtifactRefs         []EvidenceRef
+	RecordedAtUnixMillis int64
+}
+
+type AgentResult struct {
+	ID                   AgentResultID
+	DelegationID         DelegationID
+	RunID                AgentRunID
+	State                AgentRunState
+	Summary              string
+	OutcomeRef           string
+	VerificationRequired bool
+	VerificationSummary  string
+	ArtifactRefs         []EvidenceRef
+	RecordedAtUnixMillis int64
+}
+
+type DelegationVerification struct {
+	ID                   DelegationVerificationID
+	DelegationID         DelegationID
+	RunID                AgentRunID
+	ResultID             AgentResultID
+	Verified             bool
+	Summary              string
+	EvidenceRefs         []EvidenceRef
+	RecordedAtUnixMillis int64
+}
+
 type PlanningInput struct {
 	ConversationID        ConversationRef
 	UtteranceID           SourceUtteranceRef

database/migrations/024_work_agent_delegation_foundation.sql

@@ -0,0 +1,145 @@
+BEGIN;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.delegations (
+  delegation_id TEXT PRIMARY KEY,
+  goal_id TEXT NOT NULL,
+  work_plan_id TEXT NOT NULL,
+  plan_candidate_id TEXT NOT NULL,
+  capability_requirement_id TEXT NOT NULL,
+  capability_kind TEXT NOT NULL,
+  selected_implementation_id TEXT NOT NULL,
+  selected_implementation_revision BIGINT NOT NULL,
+  selected_implementation_kind TEXT NOT NULL,
+  protocol TEXT NOT NULL,
+  source_intent_id TEXT NOT NULL,
+  source_utterance_id TEXT NOT NULL,
+  conversation_id TEXT NOT NULL DEFAULT '',
+  project_id TEXT NOT NULL DEFAULT '',
+  project_display_name TEXT NOT NULL DEFAULT '',
+  desired_outcome TEXT NOT NULL,
+  constraint_summary TEXT NOT NULL DEFAULT '',
+  verification_summary TEXT NOT NULL DEFAULT '',
+  context_summary TEXT NOT NULL DEFAULT '',
+  context_refs TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  state TEXT NOT NULL,
+  latest_run_id TEXT NOT NULL DEFAULT '',
+  latest_result_id TEXT NOT NULL DEFAULT '',
+  created_at_unix_millis BIGINT NOT NULL,
+  updated_at_unix_millis BIGINT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (delegation_id <> ''),
+  CHECK (goal_id <> ''),
+  CHECK (work_plan_id <> ''),
+  CHECK (plan_candidate_id <> ''),
+  CHECK (capability_requirement_id <> ''),
+  CHECK (capability_kind <> ''),
+  CHECK (selected_implementation_id <> ''),
+  CHECK (selected_implementation_revision > 0),
+  CHECK (selected_implementation_kind = 'AGENT'),
+  CHECK (protocol IN ('CODEX_BRIDGE_V1')),
+  CHECK (source_intent_id <> ''),
+  CHECK (source_utterance_id <> ''),
+  CHECK (desired_outcome <> ''),
+  CHECK (state IN ('PENDING','RUNNING','WAITING','BLOCKED','VERIFYING','COMPLETED','FAILED','CANCELLED')),
+  CHECK (created_at_unix_millis > 0),
+  CHECK (updated_at_unix_millis >= created_at_unix_millis)
+);
+
+CREATE TABLE IF NOT EXISTS work.agent_runs (
+  run_id TEXT PRIMARY KEY,
+  delegation_id TEXT NOT NULL,
+  implementation_id TEXT NOT NULL,
+  implementation_revision BIGINT NOT NULL,
+  protocol TEXT NOT NULL,
+  state TEXT NOT NULL,
+  derived_instruction_summary TEXT NOT NULL DEFAULT '',
+  started_at_unix_millis BIGINT NOT NULL,
+  updated_at_unix_millis BIGINT NOT NULL,
+  completed_at_unix_millis BIGINT NOT NULL DEFAULT 0,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (run_id <> ''),
+  CHECK (delegation_id <> ''),
+  CHECK (implementation_id <> ''),
+  CHECK (implementation_revision > 0),
+  CHECK (protocol IN ('CODEX_BRIDGE_V1')),
+  CHECK (state IN ('STARTED','RUNNING','WAITING','CHECKPOINTED','EXECUTION_WINDOW_EXHAUSTED','BLOCKED','FAILED','COMPLETED','CANCELLED')),
+  CHECK (started_at_unix_millis > 0),
+  CHECK (updated_at_unix_millis >= started_at_unix_millis),
+  CHECK (completed_at_unix_millis >= 0)
+);
+
+CREATE TABLE IF NOT EXISTS work.agent_checkpoints (
+  checkpoint_id TEXT PRIMARY KEY,
+  delegation_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  state TEXT NOT NULL,
+  blocker_class TEXT NOT NULL,
+  completed_summary TEXT NOT NULL DEFAULT '',
+  remaining_summary TEXT NOT NULL DEFAULT '',
+  test_summary TEXT NOT NULL DEFAULT '',
+  branch_name TEXT NOT NULL DEFAULT '',
+  commit_hash TEXT NOT NULL DEFAULT '',
+  next_step TEXT NOT NULL DEFAULT '',
+  artifact_refs TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  recorded_at_unix_millis BIGINT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (checkpoint_id <> ''),
+  CHECK (delegation_id <> ''),
+  CHECK (run_id <> ''),
+  CHECK (state IN ('STARTED','RUNNING','WAITING','CHECKPOINTED','EXECUTION_WINDOW_EXHAUSTED','BLOCKED','FAILED','COMPLETED','CANCELLED')),
+  CHECK (blocker_class IN ('NONE','HUMAN_DECISION_REQUIRED','MISSING_EXTERNAL_CREDENTIAL','ARCHITECTURE_DECISION_REQUIRED','SECURITY_CONFLICT','TECHNICAL_FAILURE','EXECUTION_WINDOW_EXHAUSTED')),
+  CHECK (recorded_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS work.agent_results (
+  result_id TEXT PRIMARY KEY,
+  delegation_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  state TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  outcome_ref TEXT NOT NULL DEFAULT '',
+  verification_required BOOLEAN NOT NULL,
+  verification_summary TEXT NOT NULL DEFAULT '',
+  artifact_refs TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  recorded_at_unix_millis BIGINT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (result_id <> ''),
+  CHECK (delegation_id <> ''),
+  CHECK (run_id <> ''),
+  CHECK (state IN ('STARTED','RUNNING','WAITING','CHECKPOINTED','EXECUTION_WINDOW_EXHAUSTED','BLOCKED','FAILED','COMPLETED','CANCELLED')),
+  CHECK (summary <> ''),
+  CHECK (recorded_at_unix_millis > 0)
+);
+
+RESET ROLE;
+
+SET ROLE capability_role;
+
+INSERT INTO capability.capability_descriptors(capability_id, capability_kind, display_name, description, revision, recorded_at_unix_millis)
+VALUES
+  ('modify-code', 'MODIFY_CODE', 'Code modification', 'Executor-neutral software engineering capability that changes repository code inside an authorized scope.', 1, 1),
+  ('run-tests', 'RUN_TESTS', 'Run tests', 'Executor-neutral software engineering capability that runs repository validation and test commands.', 1, 1),
+  ('inspect-project', 'INSPECT_PROJECT', 'Inspect project', 'Executor-neutral software engineering capability that inspects repository structure and relevant files.', 1, 1)
+ON CONFLICT (capability_id) DO NOTHING;
+
+INSERT INTO capability.capability_implementations(
+  implementation_id, capability_id, capability_kind, owner_principal_id, revision, implementation_kind, target_ref,
+  credential_ref, qualification, activation, health, authority_policy_ref, data_constraints,
+  cost_score_millis, latency_score_millis, reliability_millis, observed_at_unix_millis)
+VALUES
+  ('codex-agent-modify-code-v1', 'modify-code', 'MODIFY_CODE', 'domovoy-creator-principal', 1, 'AGENT', 'codex://assistant/modify-code', '', 'VALIDATED', 'CANARY', 'AVAILABLE', 'creator-directive-v1', ARRAY['LOCAL_ONLY','NO_CREDENTIAL_FORWARD'], 5, 80, 820, 1),
+  ('codex-agent-run-tests-v1', 'run-tests', 'RUN_TESTS', 'domovoy-creator-principal', 1, 'AGENT', 'codex://assistant/run-tests', '', 'VALIDATED', 'CANARY', 'AVAILABLE', 'creator-directive-v1', ARRAY['LOCAL_ONLY','NO_CREDENTIAL_FORWARD'], 5, 120, 860, 1),
+  ('codex-agent-inspect-project-v1', 'inspect-project', 'INSPECT_PROJECT', 'domovoy-creator-principal', 1, 'AGENT', 'codex://assistant/inspect-project', '', 'VALIDATED', 'CANARY', 'AVAILABLE', 'creator-directive-v1', ARRAY['LOCAL_ONLY','NO_CREDENTIAL_FORWARD'], 5, 40, 900, 1)
+ON CONFLICT DO NOTHING;
+
+INSERT INTO capability.capability_implementation_heads(implementation_id, revision, capability_kind, owner_principal_id)
+VALUES
+  ('codex-agent-modify-code-v1', 1, 'MODIFY_CODE', 'domovoy-creator-principal'),
+  ('codex-agent-run-tests-v1', 1, 'RUN_TESTS', 'domovoy-creator-principal'),
+  ('codex-agent-inspect-project-v1', 1, 'INSPECT_PROJECT', 'domovoy-creator-principal')
+ON CONFLICT (implementation_id) DO NOTHING;
+
+RESET ROLE;
+COMMIT;

database/migrations/025_delegation_attention_and_verification.sql

@@ -0,0 +1,60 @@
+BEGIN;
+
+SET ROLE continuity_role;
+
+ALTER TABLE continuity.attention_items
+  ADD COLUMN IF NOT EXISTS source_external_ref TEXT NOT NULL DEFAULT '';
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint
+    WHERE conname = 'attention_items_source_kind_check_v2'
+  ) THEN
+    ALTER TABLE continuity.attention_items DROP CONSTRAINT IF EXISTS attention_items_source_kind_check;
+    ALTER TABLE continuity.attention_items
+      ADD CONSTRAINT attention_items_source_kind_check_v2
+      CHECK (source_kind IN ('PROSPECTIVE_REMINDER','AGENT_DELEGATION'));
+  END IF;
+END $$;
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint
+    WHERE conname = 'human_responses_outcome_check_v2'
+  ) THEN
+    ALTER TABLE continuity.human_responses DROP CONSTRAINT IF EXISTS human_responses_outcome_check;
+    ALTER TABLE continuity.human_responses
+      ADD CONSTRAINT human_responses_outcome_check_v2
+      CHECK (outcome IN ('USER_REPORTED_COMPLETE','SNOOZED','CANCELLED','DISMISSED','CLARIFICATION_NEEDED','CONTINUED','REJECTED','NOOP'));
+  END IF;
+END $$;
+
+CREATE UNIQUE INDEX IF NOT EXISTS attention_items_source_external_ref_unique
+  ON continuity.attention_items(source_kind, source_external_ref)
+  WHERE source_external_ref <> '';
+
+RESET ROLE;
+
+SET ROLE work_role;
+
+CREATE TABLE IF NOT EXISTS work.delegation_verifications (
+  verification_id TEXT PRIMARY KEY,
+  delegation_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  result_id TEXT NOT NULL,
+  verified BOOLEAN NOT NULL,
+  summary TEXT NOT NULL,
+  evidence_refs TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+  recorded_at_unix_millis BIGINT NOT NULL,
+  recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CHECK (delegation_id <> ''),
+  CHECK (run_id <> ''),
+  CHECK (result_id <> ''),
+  CHECK (summary <> ''),
+  CHECK (recorded_at_unix_millis > 0)
+);
+
+RESET ROLE;
+COMMIT;

database/migrations/026_continuity_attention_response_outcomes.sql

@@ -0,0 +1,22 @@
+BEGIN;
+
+SET ROLE continuity_role;
+
+ALTER TABLE continuity.attention_items
+  DROP CONSTRAINT IF EXISTS attention_items_response_projection_check;
+
+ALTER TABLE continuity.attention_items
+  ADD CONSTRAINT attention_items_response_projection_check
+  CHECK (
+    state <> 'RESOLVED'
+    OR (
+      response_id <> ''
+      AND response_utterance_id <> ''
+      AND response_operation IN ('ACKNOWLEDGE','COMPLETE','SNOOZE','CANCEL','DISMISS','CONTINUE','REJECT')
+      AND response_outcome IN ('USER_REPORTED_COMPLETE','SNOOZED','CANCELLED','DISMISSED','CLARIFICATION_NEEDED','CONTINUED','REJECTED','NOOP')
+      AND responded_at_unix_millis > 0
+    )
+  );
+
+RESET ROLE;
+COMMIT;

deploy/docker-compose.dev.yml

@@ -12,6 +12,7 @@ services:
       SITUATION_DB_PASSWORD: ${SITUATION_DB_PASSWORD:-assistant_situation_dev_only}
       WORK_DB_PASSWORD: ${WORK_DB_PASSWORD:-assistant_work_dev_only}
       CAPABILITY_DB_PASSWORD: ${CAPABILITY_DB_PASSWORD:-assistant_capability_dev_only}
+      EPISTEMICS_DB_PASSWORD: ${EPISTEMICS_DB_PASSWORD:-assistant_epistemics_dev_only}
       COMMIT_DB_PASSWORD: ${COMMIT_DB_PASSWORD:-assistant_commit_dev_only}
     ports: ["15432:5432"]
     volumes:
@@ -50,6 +51,8 @@ services:
       WORK_POSTGRES_PASSWORD: ${WORK_DB_PASSWORD:-assistant_work_dev_only}
       CAPABILITY_POSTGRES_USER: capability_role
       CAPABILITY_POSTGRES_PASSWORD: ${CAPABILITY_DB_PASSWORD:-assistant_capability_dev_only}
+      EPISTEMICS_POSTGRES_USER: epistemics_role
+      EPISTEMICS_POSTGRES_PASSWORD: ${EPISTEMICS_DB_PASSWORD:-assistant_epistemics_dev_only}
     ports: ["19080:8080"]
     depends_on:
       postgres: { condition: service_healthy }

deploy/docker-compose.prod.yml

@@ -17,6 +17,7 @@ services:
       WORK_DB_PASSWORD: ${WORK_DB_PASSWORD}
       CAPABILITY_DB_PASSWORD: ${CAPABILITY_DB_PASSWORD}
       COMMIT_DB_PASSWORD: ${COMMIT_DB_PASSWORD}
+      EPISTEMICS_DB_PASSWORD_FILE: /run/secrets/epistemics_db_password
       INTERACTION_DB_PASSWORD_FILE: /run/secrets/interaction_db_password
     volumes:
       - assistant_pg:/var/lib/postgresql
@@ -72,6 +73,9 @@ services:
       WORK_POSTGRES_PASSWORD: ${WORK_DB_PASSWORD}
       CAPABILITY_POSTGRES_USER: capability_role
       CAPABILITY_POSTGRES_PASSWORD: ${CAPABILITY_DB_PASSWORD}
+      EPISTEMICS_POSTGRES_USER: epistemics_role
+      EPISTEMICS_POSTGRES_CREDENTIAL_REF: credential://domovoy/epistemics/db-password/v1
+      EPISTEMICS_POSTGRES_PASSWORD_FILE: /run/secrets/epistemics_db_password
       INTERACTION_POSTGRES_USER: interaction_role
       INTERACTION_POSTGRES_CREDENTIAL_REF: credential://domovoy/interaction/db-password/v1
       INTERACTION_POSTGRES_PASSWORD_FILE: /run/secrets/interaction_db_password

deploy/images/002_owner_passwords.sh

@@ -18,6 +18,13 @@ SQL
 psql --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -v ON_ERROR_STOP=1 -v capability_password="$CAPABILITY_DB_PASSWORD" <<'SQL'
 ALTER ROLE capability_role PASSWORD :'capability_password';
 SQL
+if [ "${EPISTEMICS_DB_PASSWORD_FILE:-}" != "" ]; then
+  EPISTEMICS_DB_PASSWORD="$(tr -d '\r\n' < "$EPISTEMICS_DB_PASSWORD_FILE")"
+fi
+: "${EPISTEMICS_DB_PASSWORD:?EPISTEMICS_DB_PASSWORD or EPISTEMICS_DB_PASSWORD_FILE is required}"
+psql --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -v ON_ERROR_STOP=1 -v epistemics_password="$EPISTEMICS_DB_PASSWORD" <<'SQL'
+ALTER ROLE epistemics_role PASSWORD :'epistemics_password';
+SQL
 psql --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" -v ON_ERROR_STOP=1 -v commit_password="$COMMIT_DB_PASSWORD" <<'SQL'
 ALTER ROLE commit_role PASSWORD :'commit_password';
 SQL

deploy/windows/Invoke-DomovoyNotificationReceiver.ps1

@@ -1,6 +1,6 @@
 [CmdletBinding()]
 param(
-    [string]$Endpoint = 'https://assistent.cin.su/delivery/v1/receipts?limit=100',
+    [string]$Endpoint = 'https://assistant.cin.su/delivery/v1/receipts?limit=100',
     [string]$KeyRecordPath = "$env:LOCALAPPDATA\Domovoy\notification-receiver-read-key.dpapi.json",
     [string]$StatePath = "$env:LOCALAPPDATA\Domovoy\notification-receiver-state.json",
     [ValidateRange(1, 5)]
@@ -24,7 +24,7 @@ function Write-AtomicJson {
 }
 
 $uri = [Uri]$Endpoint
-if ($uri.Scheme -ne 'https' -or $uri.Host -ne 'assistent.cin.su' -or $uri.AbsolutePath -ne '/delivery/v1/receipts') {
+if ($uri.Scheme -ne 'https' -or $uri.Host -ne 'assistant.cin.su' -or $uri.AbsolutePath -ne '/delivery/v1/receipts') {
     throw 'Notification receiver endpoint is outside the fixed HTTPS binding'
 }
 if (-not (Test-Path -LiteralPath $KeyRecordPath -PathType Leaf)) { throw "Notification receiver key not found: $KeyRecordPath" }

dev/ACTIVE_TASK.json

@@ -1,5 +1,5 @@
 {
-  "task_file": "dev/tasks/DEV-000067-experience-reflection-skill-evolution.json",
-  "task_id": "DEV-000067",
+  "task_file": "dev/tasks/DEV-000069-general-agent-delegation-codex-bridge.json",
+  "task_id": "DEV-000069",
   "task_revision": 1
 }

dev/tasks/DEV-000067-experience-reflection-skill-evolution.json

@@ -32,6 +32,7 @@
       "database/migrations/**",
       "cmd/core-runtime/**",
       "cmd/creator-web/**",
+      "deploy/windows/Invoke-DomovoyNotificationReceiver.ps1",
       "tests/owner_acl/**",
       "tests/cognitive_advisory/**",
       "docs/PROJECT_STATUS.md",
@@ -126,6 +127,8 @@
     "tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1",
     "tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1",
     "production /chat verification if runtime deployment is required"
+    ,
+    "notification receiver endpoint uses canonical assistant.cin.su spelling"
   ],
   "terminal_gap_states": [
     "BLOCKED_BY_ARCHITECTURE_GAP",

dev/tasks/DEV-000068-runtime-experience-reflection-loop.json

@@ -0,0 +1,139 @@
+{
+  "task_id": "DEV-000068",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0016",
+  "base_repo_revision": "67ff1f73cddfd94f9f5745acc87f997aed49630a",
+  "risk_tier": "E",
+  "intent": "Activate the first production runtime Experience and Reflection loop for meaningful /chat, HumanResponse, capability and fast-path outcomes without creating a LearningManager.",
+  "requirement_ids": [
+    "ADR-0016",
+    "INV-OWN-001",
+    "INV-EPI-001",
+    "Runtime Experience capture",
+    "Runtime ReflectionCandidate triggers",
+    "SkillEvidence from real reminder response outcomes",
+    "Fast-path decline returns to reasoning/clarification"
+  ],
+  "allowed_change_scope": {
+    "modules": [
+      "epistemics",
+      "capability",
+      "interaction",
+      "continuity"
+    ],
+    "paths": [
+      "contracts/epistemics/**",
+      "contracts/capability/**",
+      "modules/epistemics/**",
+      "modules/capability/**",
+      "adapters/postgres/**",
+      "database/migrations/**",
+      "cmd/core-runtime/**",
+      "cmd/creator-web/**",
+      "cmd/continuity-runtime/**",
+      "deploy/docker-compose.dev.yml",
+      "deploy/docker-compose.prod.yml",
+      "deploy/images/002_owner_passwords.sh",
+      "deploy/windows/**",
+      "tests/owner_acl/**",
+      "tests/cognitive_advisory/**",
+      "docs/PROJECT_STATUS.md",
+      "dev/ACTIVE_TASK.json",
+      "dev/tasks/DEV-000068-runtime-experience-reflection-loop.json"
+    ]
+  },
+  "forbidden_change_scope": {
+    "paths": [
+      "architecture/ARCHITECTURE_CONSTITUTION.md",
+      "modules/authority/**",
+      "modules/commit/**",
+      "cmd/commit-runtime/**",
+      "security/**",
+      "ci/**",
+      ".gitea/**"
+    ]
+  },
+  "allowed_architecture_delta": {
+    "new_cross_module_dependencies": 0,
+    "new_canonical_owners": 0,
+    "new_privileges": 0,
+    "new_third_party_dependencies": 0,
+    "new_provider_adapters": 0,
+    "new_runtime_secret_file_for_existing_owner": "epistemics_role database password for core-runtime"
+  },
+  "contracts": {
+    "consume": [
+      "Interaction HumanUtterance / OriginalHumanIntent / Correction refs",
+      "Continuity HumanResponse / Attention / ProspectiveItem refs",
+      "Capability CapabilityUsageObservation / CapabilityGap / SkillProfile",
+      "Epistemics SystemExpectation / ExperienceRecord / ReflectionCandidate"
+    ],
+    "may_change": [
+      "contracts/epistemics@v1",
+      "contracts/capability@v1"
+    ]
+  },
+  "semantic_owner": "epistemics",
+  "canonical_state": [
+    "SystemExpectation",
+    "ExperienceRecord",
+    "ReflectionCandidate",
+    "SkillProfile"
+  ],
+  "state_transitions": [
+    "meaningful chat help path -> SystemExpectation before outcome",
+    "HumanResponse resolved COMPLETE/SNOOZE/CANCEL -> positive ExperienceRecord and SkillProfile supporting evidence",
+    "Human correction -> USER_CORRECTED ExperienceRecord and ReflectionCandidate",
+    "ambiguous/no-target/unsupported fast path -> decline/clarification ExperienceRecord and ReflectionCandidate",
+    "repeated failure/correction evidence -> SkillProfile DEGRADED/SUSPENDED according to deterministic policy"
+  ],
+  "side_effects_and_privileges": [
+    "No external mutation is introduced",
+    "No model output can directly mutate canonical state, Authority, source code, deployment or skill lifecycle",
+    "Core runtime receives only the existing Epistemics owner database credential through secret-file/CredentialRef mechanism",
+    "Creator Web remains a proxy/UI and receives no direct database credential",
+    "Docker-test remains prohibited"
+  ],
+  "persistence_and_migrations": [
+    "no new canonical owner",
+    "no cross-owner FK",
+    "no cross-owner SQL join dependency",
+    "reuse DEV-000067 tables with optional indexes/projections only if needed"
+  ],
+  "failure_retry_restart": [
+    "Experience/reflection capture is append-only and idempotent by generated IDs",
+    "A failed learning write must not pretend success; production acceptance verifies rows",
+    "Fast-path decline is valid safety behavior and does not mutate target state"
+  ],
+  "assumptions": [
+    "DEV-000067 production foundation is active",
+    "ADR-0016 is sufficient; no new architecture owner is required",
+    "V1 uses deterministic reflection triggers; cognitive reflection remains optional candidate generation only"
+  ],
+  "acceptance_scenarios": [
+    "Create reminder then complete it -> positive ExperienceRecord and SkillProfile supporting evidence",
+    "Create ambiguous targets and correct Domovoy -> USER_CORRECTED ExperienceRecord and ReflectionCandidate",
+    "Unsupported/uncertain response phrasing -> fast path declines and asks clarification/falls back without guessed mutation",
+    "Operator can inspect recent ExperienceRecords, ReflectionCandidates and SkillProfile status",
+    "Human chat does not expose internal learning IDs",
+    "LLM-free operation passes"
+  ],
+  "required_tests": [
+    "go test ./...",
+    "go vet ./...",
+    "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json",
+    "go run ./cmd/devctl check-architecture",
+    "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json",
+    "tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1",
+    "tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1",
+    "production live learning acceptance A/B/C",
+    "production health",
+    "production /chat verification"
+  ],
+  "terminal_gap_states": [
+    "BLOCKED_BY_ARCHITECTURE_GAP",
+    "BLOCKED_BY_SPEC_GAP",
+    "BLOCKED_BY_MISSING_CAPABILITY",
+    "BLOCKED_BY_CONFLICT"
+  ]
+}

dev/tasks/DEV-000069-general-agent-delegation-codex-bridge.json

@@ -0,0 +1,163 @@
+{
+  "task_id": "DEV-000069",
+  "task_revision": 1,
+  "architecture_revision": "ADR-0017",
+  "base_repo_revision": "d870e1361d6dcef3866d7339495d83b9756949c4",
+  "risk_tier": "E",
+  "intent": "Introduce a provider-neutral external intelligent agent delegation foundation and the first Codex bridge implementation for software-engineering work without making Codex a canonical subsystem.",
+  "requirement_ids": [
+    "ADR-0017",
+    "ADR-0012",
+    "ADR-0013",
+    "ADR-0016",
+    "INV-OWN-001",
+    "INV-EPI-001",
+    "INV-TOPO-001",
+    "General external agent representation",
+    "Durable delegation and resumable runs",
+    "Codex bridge as first AGENT implementation",
+    "Execution-window continuation",
+    "Delegation experience evidence"
+  ],
+  "allowed_change_scope": {
+    "modules": [
+      "work",
+      "capability",
+      "continuity",
+      "epistemics",
+      "interaction",
+      "situation",
+      "artifact"
+    ],
+    "paths": [
+      "contracts/work/**",
+      "contracts/capability/**",
+      "contracts/artifact/**",
+      "contracts/epistemics/**",
+      "contracts/continuity/**",
+      "contracts/interaction/**",
+      "modules/work/**",
+      "modules/capability/**",
+      "modules/epistemics/**",
+      "modules/continuity/**",
+      "adapters/postgres/**",
+      "cmd/core-runtime/**",
+      "cmd/creator-web/**",
+      "cmd/continuity-runtime/**",
+      "database/migrations/**",
+      "deploy/docker-compose.dev.yml",
+      "deploy/docker-compose.prod.yml",
+      "deploy/windows/**",
+      "tests/**",
+      "docs/PROJECT_STATUS.md",
+      "architecture/adrs/ADR-0017-general-agent-delegation-codex-bridge.md",
+      "dev/ACTIVE_TASK.json",
+      "dev/tasks/DEV-000069-general-agent-delegation-codex-bridge.json"
+    ]
+  },
+  "forbidden_change_scope": {
+    "paths": [
+      "architecture/ARCHITECTURE_CONSTITUTION.md",
+      "architecture/architecture-registry.yaml",
+      "architecture/architecture-registry.json",
+      "modules/authority/**",
+      "modules/commit/**",
+      "cmd/commit-runtime/**",
+      "security/**",
+      "ci/**",
+      ".gitea/**"
+    ]
+  },
+  "allowed_architecture_delta": {
+    "new_cross_module_dependencies": 0,
+    "new_canonical_owners": 0,
+    "new_privileges": 0,
+    "new_third_party_dependencies": 0,
+    "new_provider_adapters": 0,
+    "new_runtime_secret_file_for_existing_owner": "only if an already-approved bridge/runtime prerequisite requires a least-privilege credential"
+  },
+  "contracts": {
+    "consume": [
+      "Interaction HumanUtterance / OriginalHumanIntent",
+      "Situation focus and project resolution",
+      "Work Goal / PlanCandidate / CapabilityRequirement / DelegationCandidate",
+      "Capability CapabilityImplementation / CapabilityResolution / CapabilityUsageObservation",
+      "Continuity Attention / HumanResponse",
+      "Epistemics ExperienceRecord / ReflectionCandidate",
+      "Artifact metadata refs"
+    ],
+    "may_change": [
+      "contracts/work@v1",
+      "contracts/capability@v1",
+      "contracts/artifact@v1",
+      "contracts/epistemics@v1"
+    ]
+  },
+  "semantic_owner": "work",
+  "canonical_state": [
+    "CapabilityImplementation(kind=AGENT)",
+    "Delegation",
+    "AgentRun",
+    "AgentCheckpoint",
+    "AgentResult"
+  ],
+  "state_transitions": [
+    "OriginalHumanIntent -> optional Goal/Plan -> CapabilityRequirement -> real Delegation",
+    "Delegation -> AgentRun STARTED -> RUNNING/WAITING/CHECKPOINTED/EXECUTION_WINDOW_EXHAUSTED/BLOCKED/FAILED/COMPLETED/CANCELLED",
+    "execution window exhaustion -> durable checkpoint -> resumed run on same higher-level Delegation",
+    "human-dependent blocker -> AttentionItem -> natural HumanResponse -> continue delegation/work",
+    "agent result evidence -> verification -> Work completion decision -> ExperienceRecord"
+  ],
+  "side_effects_and_privileges": [
+    "No new canonical owner and no Codex-specific canonical subsystem",
+    "No direct external mutation outside existing Authority/Commit boundaries",
+    "Agent-specific instruction is derived adapter context, not canonical human intent",
+    "Codex bridge may use only the least-privilege runtime/credential path required for bounded repository work",
+    "Docker-test remains prohibited"
+  ],
+  "persistence_and_migrations": [
+    "owner-local Work and Capability schema extensions only",
+    "no cross-owner FK",
+    "no cross-owner SQL join dependency",
+    "result evidence stored by typed refs/metadata rather than payload duplication where possible"
+  ],
+  "failure_retry_restart": [
+    "execution-window exhaustion is resumable and not automatic work failure",
+    "technical agent failure is distinct from human-dependent blocker",
+    "agent self-report is insufficient for Work completion without verification evidence",
+    "Codex unavailable must create capability unavailability/gap rather than startup failure"
+  ],
+  "assumptions": [
+    "DEV-000068 production foundation is active",
+    "CapabilityImplementation(kind=AGENT) is sufficient for a general agent descriptor V1",
+    "Work is the minimal correct owner for durable delegation lifecycle",
+    "Continuity attention/human-response foundations from DEV-000066 can be reused for delegation waiting/blockers"
+  ],
+  "acceptance_scenarios": [
+    "software-engineering requirement resolves through executor-neutral capability resolution",
+    "Codex is represented as an implementation, not canonical capability identity",
+    "delegation run checkpoints and resumes after execution-window exhaustion",
+    "human-dependent blocker surfaces through Attention while technical failure does not masquerade as human blocker",
+    "agent-specific execution instruction is derived from canonical context and OriginalHumanIntent remains unchanged",
+    "safe real self-development scenario creates delegation, run, checkpoint/result evidence and ExperienceRecord",
+    "LLM-free system starts when Codex bridge is unavailable"
+  ],
+  "required_tests": [
+    "go test ./...",
+    "go vet ./...",
+    "go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json",
+    "go run ./cmd/devctl check-architecture",
+    "go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json",
+    "tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1",
+    "tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1",
+    "delegation/resume/attention/provider-neutral contract tests",
+    "production health",
+    "safe live Codex delegation acceptance"
+  ],
+  "terminal_gap_states": [
+    "BLOCKED_BY_ARCHITECTURE_GAP",
+    "BLOCKED_BY_SPEC_GAP",
+    "BLOCKED_BY_MISSING_CAPABILITY",
+    "BLOCKED_BY_CONFLICT"
+  ]
+}

docs/PROJECT_STATUS.md

@@ -1,10 +1,29 @@
 # Assistant project status
 
-Audit date: 2026-08-17. Active implementation: DEV-000067 revision 1.
+Audit date: 2026-08-17. Active implementation: DEV-000069 revision 1.
+
+## DEV-000069 checkpoint
+
+- `DEV_000069_STATUS = PRODUCTION_ACTIVE`
+- `LAST_COMPLETED = ADR-0017 accepted; general agent delegation / Codex bridge production baseline; live delegation persistence and resume lifecycle; production continuation regression fix for CONTINUED/REJECTED attention response projection; live production delegation resumed on the same Delegation after human Continue`
+- `ADR_STATUS = ADR-0017 accepted`
+- `OWNERSHIP_STATUS = no new owner; Work owns Delegation / AgentRun / AgentResult / DelegationVerification; Continuity owns AttentionItem / HumanResponse; Epistemics owns ExperienceRecord`
+- `DELEGATION_LIFECYCLE_STATUS = PASS: Delegation persisted; AgentRun #1 reached EXECUTION_WINDOW_EXHAUSTED; AgentRun #2 reached HUMAN_DECISION_REQUIRED/BLOCKED; same Delegation resumed into AgentRun #3 after authenticated human continuation`
+- `EXECUTION_WINDOW_STATUS = PASS: exhaustion checkpoint did not fail higher-level Delegation; same Delegation resumed without requesting the human to restate the full task`
+- `HUMAN_DECISION_STATUS = PASS: production created AGENT_DELEGATION AttentionItem with human-readable question; authenticated human continuation path is now persisted without continuity DB constraint failure`
+- `RESULT_VERIFICATION_STATUS = in progress at this checkpoint: live docs-only artifact path is the accepted verification target for the resumed coding-agent run`
+- `NON_CODEX_TRANSFER_STATUS = PASS at architecture level: canonical HumanIntent / Work / Delegation / AgentRun contracts remain agent-neutral and do not require Codex-specific canonical entities`
+- `REGRESSION_FIX_STATUS = PASS: migration 026 allows attention response projection outcomes CONTINUED / REJECTED so resolved delegation attention can persist without 500`
+- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production artifact confirmation; production health; live continuity response endpoint returned 201 CONTINUED`
+- `LIVE_ACCEPTANCE = PASS IN PROGRESS: external /chat created real delegation f693ed472239d083e39e8fd87efba9b7; real run #1 exhausted; real run #2 blocked for human decision; production response continuation bug reproduced, fixed, promoted and redeployed; same delegation resumed into run #3 9345bfaf4b5c538f01207442806cf375`
+- `PRODUCTION_STATUS = healthy`
+- `PRODUCTION_REVISION = 4352e00491eaed6da032003a6bf032a4c6990fe7`
+- `ACTIVE_COGNITIVE_BINDINGS = CPU CANARY allowed only where explicitly requested; no ACTIVE binding promotion`
+- `OPENAI_REAL_CREDENTIAL = not required / not activated`
 
 ## DEV-000067 checkpoint
 
-- `DEV_000067_STATUS = IN_PROGRESS_LOCAL_FOUNDATION`
+- `DEV_000067_STATUS = PRODUCTION_FOUNDATION_ACTIVE`
 - `LAST_COMPLETED = ADR-0016 accepted; no new Learning owner; Epistemics-owned SystemExpectation / ExperienceRecord / ReflectionCandidate contracts; Capability-owned SkillProfile / FastPathDecision lifecycle contracts; append-only migration 023; owner-local regression tests for positive reminder experience, user correction reflection, fast-path decline, and repeated failure skill degradation`
 - `ADR_STATUS = ADR-0016 accepted`
 - `OWNERSHIP_STATUS = no new owner; Experience/Expectation/Reflection belong to Epistemics; Skill/FastPath lifecycle belongs to Capability; Interaction/Continuity/Work/Capability state is referenced by typed refs only`
@@ -14,6 +33,11 @@ Audit date: 2026-08-17. Active implementation: DEV-000067 revision 1.
 - `SKILL_STATUS = SkillProfile lifecycle CANDIDATE/EVALUATING/VALIDATED/DEGRADED/SUSPENDED/RETIRED; fast path can decline with NOT_APPLICABLE/LOW_CONFIDENCE/OUT_OF_DISTRIBUTION/CONFLICT/STALE and return to thinking`
 - `EVIDENCE_RETENTION_STATUS = skill degradation/replacement preserves supporting and failure experience refs; no source evidence deletion path introduced`
 - `RUNTIME_STATUS = persistence foundation is present; production runtime credential wiring for Epistemics writes is intentionally not expanded in this checkpoint`
+- `NOTIFICATION_RECEIVER_STATUS = local receiver endpoint corrected to canonical assistant.cin.su spelling`
+- `PRODUCTION_SCHEMA_STATUS = migration 023 applied; epistemics system_expectations / experience_records / reflection_candidates present; capability skill_profiles / skill_profile_heads present; seed skill skill-obvious-reminder-response-v1 VALIDATED`
+- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; notification receiver no-display poll; production health; production /chat HTTP 200`
+- `PRODUCTION_STATUS = healthy`
+- `PRODUCTION_REVISION = origin/main 2de2885f2f143d41ce0d9cf09ca12a6e5751c52c; Docker runtime artifact not rebuilt because new runtime paths are not activated and migration/script/status were sufficient`
 - `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
 - `OPENAI_REAL_CREDENTIAL = not required / not activated`
 
@@ -39,6 +63,24 @@ Audit date: 2026-08-17. Active implementation: DEV-000067 revision 1.
 
 - `DEV_000065_STATUS = COMPLETED`
 - `LAST_COMPLETED = ADR-0014 accepted; Continuity-owned AttentionItem contract and persistence; due reminder scanner; Commit internal prospective notification endpoint; human-facing Chat / Today / History surface; relative reminder parsing for "через N минут"; deterministic due-delivery regression tests; notification binding origin corrected to assistant.cin.su revision 2`
+## DEV-000068 checkpoint
+
+- `DEV_000068_STATUS = COMPLETED`
+- `LAST_COMPLETED = Runtime Experience + Reflection Loop V1: production runtime now records meaningful ExperienceRecords, deterministic ReflectionCandidates and SkillProfile evidence from /chat, reminder response, correction, capability and fast-path-decline outcomes`
+- `RUNTIME_EXPERIENCE_LOOP = ACTIVE for production interactions; no LearningManager and no automatic self-modification`
+- `REFLECTION_STATUS = deterministic candidate generation only; candidates cannot mutate skills, Authority, source code, deployment or canonical lifecycle`
+- `SKILL_EVIDENCE_STATUS = skill-obvious-reminder-response-v1 accumulates evidence from target-resolution outcomes; current production SkillProfile status is SUSPENDED after repeated ambiguous/unsupported acceptance probes, demonstrating deterministic degradation without deletion`
+- `FAST_PATH_STATUS = uncertain/unsupported continuation can decline and return to clarification/fallback instead of guessed mutation`
+- `OPERATOR_INSPECTION = Creator Console exposes recent ExperienceRecords, ReflectionCandidates and SkillProfile status through authenticated proxy`
+- `HUMAN_CHAT_URL = https://assistant.cin.su/chat`
+- `ACTIVE_COGNITIVE_BINDINGS = none; CPU CANARY unchanged`
+- `OPENAI_REAL_CREDENTIAL = not required / not activated`
+- `TESTS_PASS = go test ./...; go vet ./...; go run ./cmd/devctl preflight -active dev/ACTIVE_TASK.json; go run ./cmd/devctl check-architecture; go run ./cmd/devctl check-diff -active dev/ACTIVE_TASK.json; tests/cognitive_advisory/cognitive_worker_env_policy_test.ps1; tests/owner_acl/verify.ps1 -DockerContext docker-prod -PostgresContainer assistant-postgres-1; production artifact confirmation; production health`
+- `LIVE_ACCEPTANCE = PASS: reminder completion produced positive ExperienceRecord; explicit correction produced USER_CORRECTED ExperienceRecord and ReflectionCandidate; unsupported/uncertain continuation produced fast-path decline/fallback evidence without guessed mutation; operator learning feed returns ExperienceRecords, ReflectionCandidates and SUSPENDED SkillProfile status; /chat reachable and human-facing replies did not expose learning IDs`
+- `PRODUCTION_STATUS = healthy`
+- `PRODUCTION_REVISION = runtime artifact 4bfca4fe24dfebda1f248003e3b9e42a0a9f9dad`
+- `NEXT_RECOMMENDED_REVISION = DEV-000069 only after separate approval; no next milestone started automatically`
+
 - `ADR_STATUS = ADR-0014 accepted`
 - `OWNERSHIP_STATUS = no new owner; AttentionItem belongs to Continuity; notification delivery remains Commit/Capability/receiver path`
 - `REMINDER_LIFECYCLE_STATUS = ARMED -> TRIGGERED -> REVALIDATING -> DELIVERED implemented for due scanner`

modules/continuity/domain/human_response.go

@@ -41,7 +41,7 @@ func InterpretHumanResponse(request contract.HumanResponseRequest, owner identit
 		Revision:                1,
 		UserReportedNotVerified: false,
 	}
-	if operation == contract.ResponseUnknown || operation == contract.ResponseContinue || operation == contract.ResponseReject {
+	if operation == contract.ResponseUnknown {
 		return contract.HumanResponseResult{Response: response, Handled: false}, nil
 	}
 	if len(candidates) == 0 {
@@ -67,11 +67,22 @@ func InterpretHumanResponse(request contract.HumanResponseRequest, owner identit
 		response.TargetKind = contract.ResponseTargetAttentionItem
 		response.TargetAttentionID = candidate.Attention.ID
 		response.TargetProspectiveID = candidate.Attention.SourceProspectiveID
+		response.TargetExternalRef = candidate.Attention.SourceExternalRef
 	} else {
 		response.TargetKind = contract.ResponseTargetProspectiveItem
 		response.TargetProspectiveID = candidate.Prospective.ID
 	}
 	response.ResolutionState = contract.ResponseResolved
+	if response.TargetExternalRef != "" && candidate.Attention.SourceKind == contract.AttentionSourceAgentDelegation {
+		switch operation {
+		case contract.ResponseContinue:
+			response.Outcome = contract.ResponseOutcomeContinued
+			return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Принял. Продолжаю работу по этой задаче."}, nil
+		case contract.ResponseReject:
+			response.Outcome = contract.ResponseOutcomeRejected
+			return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Понял. Зафиксировал, что здесь нужно другое решение."}, nil
+		}
+	}
 	switch operation {
 	case contract.ResponseComplete:
 		response.Outcome = contract.ResponseOutcomeUserReportedComplete

modules/continuity/domain/human_response_test.go

@@ -87,6 +87,42 @@ func TestInterpretHumanResponseNoTargetAsksClarification(t *testing.T) {
 	}
 }
 
+func TestInterpretHumanResponseContinuesAgentDelegationAttention(t *testing.T) {
+	result := interpretResponseForTest(t, "Продолжай", []ResponseCandidate{{
+		Attention: continuity.AttentionItem{
+			ID:                "attention-1",
+			OwnerPrincipalID:  "principal-1",
+			ScopeID:           "scope-1",
+			SourceKind:        continuity.AttentionSourceAgentDelegation,
+			SourceExternalRef: "work:delegation:delegation-1",
+			State:             continuity.AttentionDelivered,
+			Summary:           "нужен твой выбор по задаче coding-agent",
+			Revision:          1,
+		},
+	}})
+	if !result.Handled || result.Response.Operation != continuity.ResponseContinue || result.Response.Outcome != continuity.ResponseOutcomeContinued || result.Response.TargetExternalRef != "work:delegation:delegation-1" {
+		t.Fatalf("unexpected delegation continue response: %#v", result)
+	}
+}
+
+func TestInterpretHumanResponseRejectsAgentDelegationAttention(t *testing.T) {
+	result := interpretResponseForTest(t, "Нет, нужен другой вариант", []ResponseCandidate{{
+		Attention: continuity.AttentionItem{
+			ID:                "attention-1",
+			OwnerPrincipalID:  "principal-1",
+			ScopeID:           "scope-1",
+			SourceKind:        continuity.AttentionSourceAgentDelegation,
+			SourceExternalRef: "work:delegation:delegation-1",
+			State:             continuity.AttentionDelivered,
+			Summary:           "нужен твой выбор по задаче coding-agent",
+			Revision:          1,
+		},
+	}})
+	if !result.Handled || result.Response.Operation != continuity.ResponseReject || result.Response.Outcome != continuity.ResponseOutcomeRejected {
+		t.Fatalf("unexpected delegation reject response: %#v", result)
+	}
+}
+
 func interpretResponseForTest(t *testing.T, message string, candidates []ResponseCandidate) continuity.HumanResponseResult {
 	t.Helper()
 	result, err := InterpretHumanResponse(continuity.HumanResponseRequest{

modules/epistemics/domain/experience.go

@@ -25,6 +25,9 @@ func NewSystemExpectation(value epistemics.SystemExpectation) (epistemics.System
 		value.RecordedAtUnixMillis < 1 {
 		return epistemics.SystemExpectation{}, ErrInvalidExpectation
 	}
+	if value.EvidenceBasis == nil {
+		value.EvidenceBasis = []epistemics.EvidenceRef{}
+	}
 	return value, nil
 }
 
@@ -41,6 +44,12 @@ func NewExperienceRecord(value epistemics.ExperienceRecord) (epistemics.Experien
 		value.ConfidenceMillis < 0 || value.ConfidenceMillis > 1000 || value.RecordedAtUnixMillis < 1 {
 		return epistemics.ExperienceRecord{}, ErrInvalidExperience
 	}
+	if value.ContextRefs == nil {
+		value.ContextRefs = []epistemics.ContextRef{}
+	}
+	if value.VerificationEvidence == nil {
+		value.VerificationEvidence = []epistemics.EvidenceRef{}
+	}
 	return value, nil
 }
 
@@ -81,6 +90,9 @@ func ValidateReflectionCandidate(value epistemics.ReflectionCandidate) error {
 		value.RecordedAtUnixMillis < 1 || value.Revision < 1 {
 		return ErrInvalidReflectionCandidate
 	}
+	if value.EvidenceRefs == nil {
+		value.EvidenceRefs = []epistemics.EvidenceRef{}
+	}
 	return nil
 }
 

modules/work/domain/delegation.go

@@ -0,0 +1,326 @@
+package domain
+
+import (
+	"errors"
+	"strings"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+	"git.cin.su/m/Assistant/platform/ids"
+)
+
+var ErrInvalidDelegation = errors.New("invalid delegation")
+var ErrInvalidAgentRun = errors.New("invalid agent run")
+var ErrInvalidAgentCheckpoint = errors.New("invalid agent checkpoint")
+var ErrInvalidAgentResult = errors.New("invalid agent result")
+var ErrInvalidDelegationVerification = errors.New("invalid delegation verification")
+
+type DelegationRequest struct {
+	Goal                work.Goal
+	Plan                work.WorkPlan
+	Candidate           work.PlanCandidate
+	Requirement         work.CapabilityRequirement
+	Implementation      capability.CapabilityImplementation
+	ConversationID      work.ConversationRef
+	OriginalIntentText  string
+	ContextSummary      string
+	ContextRefs         []string
+	VerificationSummary string
+	DerivedInstruction  string
+	StartedAt           time.Time
+}
+
+type DelegationBundle struct {
+	Delegation work.Delegation
+	Run        work.AgentRun
+}
+
+func StartDelegation(input DelegationRequest) (DelegationBundle, error) {
+	if input.Goal.ID == "" || input.Plan.ID == "" || input.Candidate.ID == "" || input.Requirement.ID == "" ||
+		input.Implementation.ID == "" || input.Implementation.Kind != capability.ImplementationAgent ||
+		input.Requirement.CapabilityKind == "" || input.StartedAt.IsZero() || strings.TrimSpace(input.OriginalIntentText) == "" {
+		return DelegationBundle{}, ErrInvalidDelegation
+	}
+	delegationID, err := ids.New()
+	if err != nil {
+		return DelegationBundle{}, err
+	}
+	runID, err := ids.New()
+	if err != nil {
+		return DelegationBundle{}, err
+	}
+	millis := input.StartedAt.UnixMilli()
+	delegation := work.Delegation{
+		ID:                         work.DelegationID(delegationID),
+		GoalID:                     input.Goal.ID,
+		PlanID:                     input.Plan.ID,
+		PlanCandidateID:            input.Candidate.ID,
+		CapabilityRequirementID:    input.Requirement.ID,
+		CapabilityKind:             input.Requirement.CapabilityKind,
+		SelectedImplementationID:   input.Implementation.ID,
+		SelectedImplementationRev:  input.Implementation.Revision,
+		SelectedImplementationKind: input.Implementation.Kind,
+		Protocol:                   protocolForImplementation(input.Implementation),
+		SourceIntentID:             input.Goal.SourceIntentID,
+		SourceUtteranceID:          input.Goal.SourceUtteranceID,
+		ConversationID:             input.ConversationID,
+		ProjectID:                  input.Goal.ProjectID,
+		ProjectDisplayName:         input.Goal.ProjectDisplayName,
+		DesiredOutcome:             input.Goal.DesiredOutcome,
+		ConstraintSummary:          nonEmpty(input.Goal.Constraints, "no additional constraints"),
+		VerificationSummary:        nonEmpty(input.VerificationSummary, "verify outcome through tests, repository state, and explicit evidence"),
+		ContextSummary:             buildContextSummary(input),
+		ContextRefs:                append([]string{}, input.ContextRefs...),
+		State:                      work.DelegationRunning,
+		LatestRunID:                work.AgentRunID(runID),
+		CreatedAtUnixMillis:        millis,
+		UpdatedAtUnixMillis:        millis,
+	}
+	run := work.AgentRun{
+		ID:                        work.AgentRunID(runID),
+		DelegationID:              delegation.ID,
+		ImplementationID:          input.Implementation.ID,
+		ImplementationRevision:    input.Implementation.Revision,
+		Protocol:                  delegation.Protocol,
+		State:                     work.AgentRunStarted,
+		DerivedInstructionSummary: summarizeInstruction(input.DerivedInstruction),
+		StartedAtUnixMillis:       millis,
+		UpdatedAtUnixMillis:       millis,
+	}
+	if err := ValidateDelegation(delegation); err != nil {
+		return DelegationBundle{}, err
+	}
+	if err := ValidateAgentRun(run); err != nil {
+		return DelegationBundle{}, err
+	}
+	return DelegationBundle{Delegation: delegation, Run: run}, nil
+}
+
+func ValidateDelegation(value work.Delegation) error {
+	if value.ID == "" || value.GoalID == "" || value.PlanID == "" || value.PlanCandidateID == "" ||
+		value.CapabilityRequirementID == "" || value.CapabilityKind == "" || value.SelectedImplementationID == "" ||
+		value.SelectedImplementationRev < 1 || value.SelectedImplementationKind != capability.ImplementationAgent ||
+		value.Protocol == "" || value.SourceIntentID == "" || value.SourceUtteranceID == "" ||
+		strings.TrimSpace(value.DesiredOutcome) == "" || value.State == "" || value.CreatedAtUnixMillis < 1 ||
+		value.UpdatedAtUnixMillis < value.CreatedAtUnixMillis {
+		return ErrInvalidDelegation
+	}
+	return nil
+}
+
+func ValidateAgentRun(value work.AgentRun) error {
+	if value.ID == "" || value.DelegationID == "" || value.ImplementationID == "" || value.ImplementationRevision < 1 ||
+		value.Protocol == "" || value.State == "" || value.StartedAtUnixMillis < 1 || value.UpdatedAtUnixMillis < value.StartedAtUnixMillis {
+		return ErrInvalidAgentRun
+	}
+	return nil
+}
+
+func CheckpointRun(run work.AgentRun, blocker work.AgentBlockerClass, completed, remaining, tests, branch, commit, next string, refs []work.EvidenceRef, now time.Time) (work.AgentRun, work.AgentCheckpoint, error) {
+	if err := ValidateAgentRun(run); err != nil || now.IsZero() {
+		return work.AgentRun{}, work.AgentCheckpoint{}, ErrInvalidAgentRun
+	}
+	checkpointID, err := ids.New()
+	if err != nil {
+		return work.AgentRun{}, work.AgentCheckpoint{}, err
+	}
+	state := work.AgentRunCheckpointed
+	switch blocker {
+	case work.AgentBlockerExecutionWindow:
+		state = work.AgentRunExecutionWindowExhausted
+	case work.AgentBlockerHumanDecisionRequired, work.AgentBlockerMissingExternalCredential, work.AgentBlockerArchitectureDecision, work.AgentBlockerSecurityConflict:
+		state = work.AgentRunBlocked
+	case work.AgentBlockerTechnicalFailure:
+		state = work.AgentRunFailed
+	case work.AgentBlockerNone:
+		state = work.AgentRunCheckpointed
+	default:
+		return work.AgentRun{}, work.AgentCheckpoint{}, ErrInvalidAgentCheckpoint
+	}
+	run.State = state
+	run.UpdatedAtUnixMillis = now.UnixMilli()
+	checkpoint := work.AgentCheckpoint{
+		ID:                   work.AgentCheckpointID(checkpointID),
+		DelegationID:         run.DelegationID,
+		RunID:                run.ID,
+		State:                state,
+		BlockerClass:         blocker,
+		CompletedSummary:     strings.TrimSpace(completed),
+		RemainingSummary:     strings.TrimSpace(remaining),
+		TestSummary:          strings.TrimSpace(tests),
+		BranchName:           strings.TrimSpace(branch),
+		CommitHash:           strings.TrimSpace(commit),
+		NextStep:             strings.TrimSpace(next),
+		ArtifactRefs:         append([]work.EvidenceRef{}, refs...),
+		RecordedAtUnixMillis: now.UnixMilli(),
+	}
+	if err := ValidateAgentCheckpoint(checkpoint); err != nil {
+		return work.AgentRun{}, work.AgentCheckpoint{}, err
+	}
+	return run, checkpoint, nil
+}
+
+func ValidateAgentCheckpoint(value work.AgentCheckpoint) error {
+	if value.ID == "" || value.DelegationID == "" || value.RunID == "" || value.State == "" || value.BlockerClass == "" || value.RecordedAtUnixMillis < 1 {
+		return ErrInvalidAgentCheckpoint
+	}
+	return nil
+}
+
+func CompleteRun(run work.AgentRun, summary, outcomeRef, verification string, refs []work.EvidenceRef, now time.Time) (work.AgentRun, work.AgentResult, error) {
+	if err := ValidateAgentRun(run); err != nil || now.IsZero() || strings.TrimSpace(summary) == "" {
+		return work.AgentRun{}, work.AgentResult{}, ErrInvalidAgentResult
+	}
+	resultID, err := ids.New()
+	if err != nil {
+		return work.AgentRun{}, work.AgentResult{}, err
+	}
+	run.State = work.AgentRunCompleted
+	run.UpdatedAtUnixMillis = now.UnixMilli()
+	run.CompletedAtUnixMillis = now.UnixMilli()
+	result := work.AgentResult{
+		ID:                   work.AgentResultID(resultID),
+		DelegationID:         run.DelegationID,
+		RunID:                run.ID,
+		State:                work.AgentRunCompleted,
+		Summary:              strings.TrimSpace(summary),
+		OutcomeRef:           strings.TrimSpace(outcomeRef),
+		VerificationRequired: true,
+		VerificationSummary:  nonEmpty(verification, "verify result before higher-level work completion"),
+		ArtifactRefs:         append([]work.EvidenceRef{}, refs...),
+		RecordedAtUnixMillis: now.UnixMilli(),
+	}
+	if err := ValidateAgentResult(result); err != nil {
+		return work.AgentRun{}, work.AgentResult{}, err
+	}
+	return run, result, nil
+}
+
+func ValidateAgentResult(value work.AgentResult) error {
+	if value.ID == "" || value.DelegationID == "" || value.RunID == "" || value.State == "" ||
+		strings.TrimSpace(value.Summary) == "" || value.RecordedAtUnixMillis < 1 {
+		return ErrInvalidAgentResult
+	}
+	return nil
+}
+
+func ResumeDelegationRun(delegation work.Delegation, previous work.AgentRun, checkpoint work.AgentCheckpoint, now time.Time) (work.Delegation, work.AgentRun, error) {
+	if err := ValidateDelegation(delegation); err != nil {
+		return work.Delegation{}, work.AgentRun{}, ErrInvalidAgentRun
+	}
+	if err := ValidateAgentRun(previous); err != nil {
+		return work.Delegation{}, work.AgentRun{}, ErrInvalidAgentRun
+	}
+	if err := ValidateAgentCheckpoint(checkpoint); err != nil || now.IsZero() {
+		return work.Delegation{}, work.AgentRun{}, ErrInvalidAgentRun
+	}
+	if delegation.ID != previous.DelegationID || checkpoint.RunID != previous.ID {
+		return work.Delegation{}, work.AgentRun{}, ErrInvalidAgentRun
+	}
+	if previous.State != work.AgentRunExecutionWindowExhausted && previous.State != work.AgentRunBlocked && previous.State != work.AgentRunCheckpointed {
+		return work.Delegation{}, work.AgentRun{}, ErrInvalidAgentRun
+	}
+	runID, err := ids.New()
+	if err != nil {
+		return work.Delegation{}, work.AgentRun{}, err
+	}
+	delegation.State = work.DelegationRunning
+	delegation.UpdatedAtUnixMillis = now.UnixMilli()
+	delegation.LatestRunID = work.AgentRunID(runID)
+	run := work.AgentRun{
+		ID:                        work.AgentRunID(runID),
+		DelegationID:              delegation.ID,
+		ImplementationID:          previous.ImplementationID,
+		ImplementationRevision:    previous.ImplementationRevision,
+		Protocol:                  previous.Protocol,
+		State:                     work.AgentRunStarted,
+		DerivedInstructionSummary: summarizeInstruction(checkpoint.NextStep),
+		StartedAtUnixMillis:       now.UnixMilli(),
+		UpdatedAtUnixMillis:       now.UnixMilli(),
+	}
+	if err := ValidateAgentRun(run); err != nil {
+		return work.Delegation{}, work.AgentRun{}, err
+	}
+	return delegation, run, nil
+}
+
+func VerifyDelegationResult(delegation work.Delegation, run work.AgentRun, result work.AgentResult, verified bool, summary string, refs []work.EvidenceRef, now time.Time) (work.Delegation, work.DelegationVerification, error) {
+	if err := ValidateDelegation(delegation); err != nil {
+		return work.Delegation{}, work.DelegationVerification{}, ErrInvalidDelegationVerification
+	}
+	if err := ValidateAgentRun(run); err != nil {
+		return work.Delegation{}, work.DelegationVerification{}, ErrInvalidDelegationVerification
+	}
+	if err := ValidateAgentResult(result); err != nil || now.IsZero() || strings.TrimSpace(summary) == "" {
+		return work.Delegation{}, work.DelegationVerification{}, ErrInvalidDelegationVerification
+	}
+	verificationID, err := ids.New()
+	if err != nil {
+		return work.Delegation{}, work.DelegationVerification{}, err
+	}
+	if verified {
+		delegation.State = work.DelegationCompleted
+	} else {
+		delegation.State = work.DelegationFailed
+	}
+	delegation.UpdatedAtUnixMillis = now.UnixMilli()
+	verification := work.DelegationVerification{
+		ID:                   work.DelegationVerificationID(verificationID),
+		DelegationID:         delegation.ID,
+		RunID:                run.ID,
+		ResultID:             result.ID,
+		Verified:             verified,
+		Summary:              strings.TrimSpace(summary),
+		EvidenceRefs:         append([]work.EvidenceRef{}, refs...),
+		RecordedAtUnixMillis: now.UnixMilli(),
+	}
+	if err := ValidateDelegationVerification(verification); err != nil {
+		return work.Delegation{}, work.DelegationVerification{}, err
+	}
+	return delegation, verification, nil
+}
+
+func ValidateDelegationVerification(value work.DelegationVerification) error {
+	if value.ID == "" || value.DelegationID == "" || value.RunID == "" || value.ResultID == "" || strings.TrimSpace(value.Summary) == "" || value.RecordedAtUnixMillis < 1 {
+		return ErrInvalidDelegationVerification
+	}
+	return nil
+}
+
+func protocolForImplementation(value capability.CapabilityImplementation) work.AgentExecutionProtocol {
+	if strings.HasPrefix(string(value.TargetRef), "codex://") {
+		return work.AgentProtocolCodexBridgeV1
+	}
+	return work.AgentProtocolCodexBridgeV1
+}
+
+func buildContextSummary(input DelegationRequest) string {
+	parts := []string{}
+	if input.Goal.ProjectDisplayName != "" {
+		parts = append(parts, "project="+input.Goal.ProjectDisplayName)
+	}
+	parts = append(parts, "human_intent="+strings.TrimSpace(input.OriginalIntentText))
+	if text := strings.TrimSpace(input.ContextSummary); text != "" {
+		parts = append(parts, "added_context="+text)
+	}
+	return strings.Join(parts, "; ")
+}
+
+func summarizeInstruction(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "derived execution context prepared from canonical intent, project context, and verification requirements"
+	}
+	if len(value) > 500 {
+		return value[:500]
+	}
+	return value
+}
+
+func nonEmpty(value, fallback string) string {
+	if strings.TrimSpace(value) == "" {
+		return fallback
+	}
+	return strings.TrimSpace(value)
+}

modules/work/domain/delegation_test.go

@@ -0,0 +1,115 @@
+package domain
+
+import (
+	"testing"
+	"time"
+
+	"git.cin.su/m/Assistant/contracts/capability"
+	"git.cin.su/m/Assistant/contracts/work"
+)
+
+func TestStartDelegationPreservesCanonicalIntentAndUsesAgentImplementation(t *testing.T) {
+	now := time.Unix(170, 0)
+	bundle, err := StartDelegation(DelegationRequest{
+		Goal: work.Goal{
+			ID:                 "goal-1",
+			SourceIntentID:     "intent-1",
+			SourceUtteranceID:  "utterance-1",
+			ProjectID:          "assistant",
+			ProjectDisplayName: "Assistant",
+			DesiredOutcome:     "fix the human-facing chat wording",
+			Constraints:        "follow architecture constitution",
+		},
+		Plan:                work.WorkPlan{ID: "plan-1"},
+		Candidate:           work.PlanCandidate{ID: "candidate-1"},
+		Requirement:         work.CapabilityRequirement{ID: "requirement-1", CapabilityKind: capability.CapabilityKindModifyCode},
+		Implementation:      agentImplementation("codex-impl-1", "codex://assistant"),
+		ConversationID:      "conversation-1",
+		OriginalIntentText:  "Исправь текст в чате Assistant.",
+		ContextSummary:      "relevant files: creator-web chat surface",
+		ContextRefs:         []string{"interaction:intent:intent-1", "situation:project:assistant"},
+		VerificationSummary: "run targeted tests and verify reply text",
+		DerivedInstruction:  "Open the current branch, inspect chat surface, implement minimal wording fix, run tests.",
+		StartedAt:           now,
+	})
+	if err != nil {
+		t.Fatalf("start delegation: %v", err)
+	}
+	if bundle.Delegation.SelectedImplementationKind != capability.ImplementationAgent {
+		t.Fatalf("delegation must keep AGENT implementation kind: %#v", bundle.Delegation)
+	}
+	if bundle.Delegation.SourceIntentID != "intent-1" || bundle.Delegation.SourceUtteranceID != "utterance-1" {
+		t.Fatalf("canonical human refs lost: %#v", bundle.Delegation)
+	}
+	if bundle.Run.Protocol != work.AgentProtocolCodexBridgeV1 {
+		t.Fatalf("expected codex bridge protocol, got %#v", bundle.Run.Protocol)
+	}
+	if bundle.Run.DerivedInstructionSummary == "" {
+		t.Fatalf("derived instruction summary must be present")
+	}
+}
+
+func TestCheckpointExecutionWindowExhaustionIsNotFailure(t *testing.T) {
+	run := work.AgentRun{
+		ID:                     "run-1",
+		DelegationID:           "delegation-1",
+		ImplementationID:       "impl-1",
+		ImplementationRevision: 1,
+		Protocol:               work.AgentProtocolCodexBridgeV1,
+		State:                  work.AgentRunRunning,
+		StartedAtUnixMillis:    1,
+		UpdatedAtUnixMillis:    1,
+	}
+	updated, checkpoint, err := CheckpointRun(run, work.AgentBlockerExecutionWindow, "inspected files", "apply patch and run tests", "go test pending", "codex/dev-000069", "abc123", "continue with next execution window", []work.EvidenceRef{"artifact:diff:1"}, time.Unix(200, 0))
+	if err != nil {
+		t.Fatalf("checkpoint: %v", err)
+	}
+	if updated.State != work.AgentRunExecutionWindowExhausted {
+		t.Fatalf("execution window exhaustion must be explicit state, got %#v", updated.State)
+	}
+	if checkpoint.BlockerClass != work.AgentBlockerExecutionWindow {
+		t.Fatalf("checkpoint blocker mismatch: %#v", checkpoint)
+	}
+}
+
+func TestDifferentFutureAgentStillSatisfiesSameCapabilityContract(t *testing.T) {
+	now := time.Unix(170, 0)
+	for _, implementation := range []capability.CapabilityImplementation{
+		agentImplementation("codex-impl-1", "codex://assistant"),
+		agentImplementation("future-impl-1", "research-agent://cluster-a"),
+	} {
+		bundle, err := StartDelegation(DelegationRequest{
+			Goal:               work.Goal{ID: "goal-1", SourceIntentID: "intent-1", SourceUtteranceID: "utterance-1", DesiredOutcome: "do the work"},
+			Plan:               work.WorkPlan{ID: "plan-1"},
+			Candidate:          work.PlanCandidate{ID: "candidate-1"},
+			Requirement:        work.CapabilityRequirement{ID: "requirement-1", CapabilityKind: capability.CapabilityKindModifyCode},
+			Implementation:     implementation,
+			OriginalIntentText: "Сделай безопасное изменение.",
+			StartedAt:          now,
+		})
+		if err != nil {
+			t.Fatalf("start delegation for %s: %v", implementation.ID, err)
+		}
+		if bundle.Delegation.CapabilityKind != capability.CapabilityKindModifyCode {
+			t.Fatalf("capability contract changed for %s: %#v", implementation.ID, bundle.Delegation)
+		}
+	}
+}
+
+func agentImplementation(id, target string) capability.CapabilityImplementation {
+	return capability.CapabilityImplementation{
+		ID:                   capability.CapabilityImplementationID(id),
+		CapabilityID:         "modify-code",
+		CapabilityKind:       capability.CapabilityKindModifyCode,
+		OwnerPrincipalID:     "domovoy-creator-principal",
+		Revision:             1,
+		Kind:                 capability.ImplementationAgent,
+		TargetRef:            capability.ImplementationTargetRef(target),
+		Qualification:        capability.QualificationValidated,
+		Activation:           capability.ActivationCanary,
+		Health:               capability.HealthAvailable,
+		AuthorityPolicyRef:   capability.AuthorityPolicyCreatorDirectiveV1,
+		DataConstraints:      []capability.DataConstraint{capability.DataConstraintLocalOnly, capability.DataConstraintNoCredentialForward},
+		ObservedAtUnixMillis: 1,
+	}
+}

tests/delegated_continuity/attention_response_projection_test.go

@@ -0,0 +1,27 @@
+package delegatedcontinuity
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAttentionResponseProjectionAllowsDelegationContinuationOutcomes(t *testing.T) {
+	path := filepath.Join("..", "..", "database", "migrations", "026_continuity_attention_response_outcomes.sql")
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read migration: %v", err)
+	}
+	sql := string(content)
+	for _, want := range []string{
+		"attention_items_response_projection_check",
+		"'CONTINUED'",
+		"'REJECTED'",
+		"'CLARIFICATION_NEEDED'",
+	} {
+		if !strings.Contains(sql, want) {
+			t.Fatalf("migration %s must contain %s", path, want)
+		}
+	}
+}