> For the complete documentation index, see [llms.txt](https://docs.lpp-minduniverse.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.lpp-minduniverse.org/lingua-pactum-protocol-lpp-documentation/7.-mind-universe-governance-stack/7.5-taskchain-engine.md).

# 7.5 TaskChain Engine

The **TaskChain Engine** is the structural backbone of Jarvis task governance.

Its purpose is to convert a statement-driven interaction into a traceable task sequence.

The reference model contains:

```
TaskChain
 ├── TaskNode
 ├── SubTaskNode
 └── OutputNode
```

and maintains three governance chains:

```
Task Chain
Error Chain
Repair Chain
```

#### Task Dependency

Tasks are not isolated outputs.

A TaskNode may depend on earlier statements, subtasks, or governance decisions.

The TaskChain allows the system to preserve these dependencies explicitly.

A reference TaskNode includes fields such as:

```
TaskID
StatementID
IntentType
RiskScore
ModuleTrace
Timestamp
```

The purpose is not the specific legacy field list itself.

The important architectural property is that a consequential action should remain linked to the task structure from which it arose.

#### Task Evolution

Agentic tasks change over time.

A task may progress from:

```
Information Query
```

to:

```
Analytical Task
```

to:

```
Task Execution
```

or:

```
System Command
```

The TaskChain provides a place to record that evolution.

This helps identify when a seemingly informational conversation is becoming action-producing.

#### Responsibility Continuity

A core Jarvis principle is that system output should remain attributable to a structured task path.

Responsibility continuity therefore asks:

> Which statement produced this task?

> Which task produced this Action Candidate?

> Which module transformed it?

> What errors occurred?

> What repairs were applied?

The TaskChain, ErrorChain, and RepairChain provide different parts of this answer.

#### Task Chain

The Task Chain records task progression.

Conceptually:

```
Statement
        ↓
Task Node
        ↓
Subtask
        ↓
Action Candidate
```

#### Error Chain

The ErrorChain records where governance failure occurred.

Conceptually:

```
Error Detected
        ↓
Module Source
        ↓
Error Type
        ↓
Record
```

The purpose is to prevent a failed step from disappearing after the system retries.

#### Repair Chain

The RepairChain records how a failed task state was modified and revalidated.

Conceptually:

```
Error
        ↓
Repair Action
        ↓
Validation
```

A repaired task is therefore distinguishable from a task that never failed.

#### Task Consensus

The reference Jarvis model uses Task Consensus Shield to require consistency among:

```
IntentType
TaskNode
ModuleTrace
```

If these become inconsistent, the reference system may reject or route the task into runtime defense.

This is a **task-governance consensus** concept.

It must not be confused with SVNN semantic verification quorum.

#### TaskChain and LPP

TaskChain answers:

> **How did this Action Candidate emerge?**

LPP asks:

> **Does the resulting Action Candidate possess legitimate constitutional authority to proceed?**

Thus:

```
Task Traceability
≠
Constitutional Admissibility
```

Both are useful.

They solve different problems.