---
title: "The work process: from the ISMS to the closed finding | JASCON"
description: "Who does what in an ISMS run on JASCON, which object each step writes and which files cross from one party to another. From building the ISMS and the first measurement through Plan, Do, Check, Act to the audit and the work on its findings."
lang: en
url: https://jascon.net/process.html
---

The work process

# Who does what, from the first risk to the closed finding

An ISMS runs in a cycle, and each turn of it leaves records. This page follows one turn through JASCON: who acts, which object each step writes, and which files pass from one party to another. Where the kernel holds nothing for a step, the page says so at that step.

01 The roles

## Nine roles, each named by an identifier

The kernel has no Party type. A party is a URI under the namespace of the organisation it belongs to, such as `https://cso.example/party/ciso`, and it is named in the fields below. Where the kernel requires a party and none is named, the app refuses the save and says which field is missing.

| Role | Usually | Named in | Writes |
|---|---|---|---|
| Authority | BSI, NIST, ASD, a regulator, a standards body | the namespace of every id it publishes | Requirement, RequirementSet, Tailoring as a baseline, Mapping, an Attestation over its bundle |
| Top management, risk owner | the board, the owner of a process or a duty | `Risk.owner-ref`, `Risk.acceptance.approver-ref` | the acceptance of a residual risk |
| ISMS owner | CISO, information security officer | `provenance.author-ref`; `Deviation.approver-ref` on the organisation's own Tailoring | Risk, the scales, Tailoring as the Statement of Applicability, Mapping |
| System owner, operations | IT operations, a product or platform team | `obligated-parties` of a statement; `provenance.author-ref` | Component, Implementation |
| Vendor, upstream provider | a product vendor, a cloud or platform provider | the publisher in a pack's manifest; `Component.authorizations` | an advice pack; the authorizations an inherited edge leans on |
| Check author | security engineering | `Check.provenance.author-ref` | Check, with its collector code in a facet |
| Assessor | internal audit, an external auditor or assessment body | `Assessment.performer-ref`; `Deviation.approver-ref` on a Finding | Assessment, Finding |
| Authorizing official | certifier, authorizing official of an agency | the key that signs the envelope | Attestation |
| Customer, buyer | an agency, a customer, procurement | nowhere: this role reads | nothing; it runs the validator on what it receives |

One person may hold several roles. The kernel keeps them apart by field, not by person: accepting a residual risk is `Risk.acceptance`, weakening a clause because of it is a Deviation, and the two are two acts even when one person does both (handbook [§10.6](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch10-assessment-findings-deviations.md)).

*Figure: The work process in JASCON.* An authority and a vendor deliver a catalogue bundle and an advice pack to the organisation, which builds its ISMS: catalogue, scope, scales, first measurement. Then the cycle runs: Plan writes Risk and Tailoring, Do writes Implementation and Check, Check writes Assessment and Finding, Act writes Deviations and new versions and leads back to Plan. From Check the organisation hands a bundle with an Attestation to the audit. The audit returns an Assessment and Findings, which are worked off and feed the next cycle.

*a step inside the organisation; outside the organisation; the answer to an audit*

02 The cycle

## Plan, Do, Check, Act, and two hand-overs

ISO/IEC 27001 and BSI Standard 200-1 describe an ISMS as a cycle. JASCON does not run the cycle. It gives each step a typed record, so that the next step and the next party read what the last one decided.

- **Every record has an id, a version and two digests.** A changed Tailoring is a new version, not an edited file, and `history` says why.
- **Every decision names who made it and when.** `provenance` carries author and date; the validator lists the records that name nobody (AUTHOR-1 to AUTHOR-4).
- **What crosses to another party is a bundle.** A folder with its objects, a content manifest, evidence files named by their SHA-256 and, when someone signs, an Attestation beside the manifest.

03 Building the ISMS

## Five steps before the first turn

The build ends with a first measurement: the gap between what the catalogue asks and what is in place. Every later turn measures against it.

## Choose a namespace and name the parties

The ISMS owner chooses a prefix under a domain the organisation controls and keeps it, for example `https://grc.your.example/`. The parties get identifiers under it: the CISO, the risk owners, operations, the internal assessor. Identifiers are compared as strings and never fetched. Nothing is written yet; every later object depends on this choice.

Who: ISMS owner. Writes: no object. [Handbook, chapter 3](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch03-identity-versions-lifecycle.md)

## Take in the catalogue

The authority's catalogue arrives as a bundle: Requirements, RequirementSets for chapters and baselines, Tailorings for its variants, Mappings to other catalogues. The validator checks it before anything is built on it, and where the authority has signed, the Attestation says whether the content is the one it signed (Full Match or Semantic Match) or does not bind. A catalogue that exists only in OSCAL goes through the Import page and its report.

Who: ISMS owner, from the authority. Receives: a catalogue bundle. App: Home, Import. [The shipped catalogues](https://jascon.net/start.html#open)

## Draw the scope as a system

The scope of the ISMS is a Component of kind `system` whose members are the services, software, hardware, policies and processes it covers. A system that is authorized names its authorization contexts on the Component; an absent one asserts nothing. A policy can be a member as a Component of kind `policy`; its text stays a document outside the kernel.

Who: system owners with the ISMS owner. Writes: Component. App: Implement. [Handbook, chapter 9](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch09-systems-components-inheritance.md)

## Define the risk scales

Likelihood, impact and the matrix that combines them are the organisation's own: as many levels as it uses, in its own words, each scale a small definition file the bundle pins. The validator refuses a level a scale does not define and a rating that contradicts its own matrix, unless the rating says why it departs. The example bundle carries the scales of BSI Standard 200-3.

Who: ISMS owner, for top management to approve. Writes: three scale definitions. App: Risk, view of the scales. [The example scales](https://github.com/christoph-puppe/JASCON/tree/main/jascon/examples)

## Take the first measurement

The first measurement is a gap analysis in records. An Implementation per requirement or clause says how far it is in place: `planned`, `partial`, `implemented` or `not-applicable`. A first Assessment records what was actually found, with a Finding per clause that is not satisfied.

JASCON defines no compliance score. What can be counted are states: Implementations per status, Assessment results, Findings per state, the selected requirements that no risk justifies. Those counts are the baseline the later turns are compared with.

*jascon/examples/implementation-acme-konf-14-1-s2.json — worked example*

```json
{
 "id": "https://cso.example/impl/acme--konf-14-1-s2",
 "version": "2026-11",
 "lifecycle": "active",
 "provenance": {
  "author-ref": "https://cso.example/party/platform-ops",
  "date": "2026-11-06"
 },
 "component-ref": "https://cso.example/component/acme-saas",
 "requirement-ref": "https://ns.bsi.bund.de/gspp/req/KONF.14.1",
 "statement-refs": [
  "s2"
 ],
 "responsibility": "provider",
 "satisfied-by": [
  {
   "capability-ref": "https://dbvendor.example/component/server-7#cap-key-rotation"
  }
 ],
 "status": "planned"
}
```

Who: system owners record, an internal assessor checks. Writes: Implementation, Assessment, Finding. App: Implement, Assess, Validate.

04 The cycle in records

## What each phase writes, and who writes it

The four phases with the records they leave, the app page that writes them and the rules that hold them. Risk and Check are in the 2.0.0 release candidate.

Plan

### Risks and the Statement of Applicability

Each Risk has a scenario, an owner, a rating on a named scale, one of four treatment options and the clauses that carry the treatment. The Tailoring selects the requirements and sets parameters; it is the Statement of Applicability. `risk-coverage` lists every selected requirement that no assessed risk justifies.

**Who, and where** ISMS owner with the risk owners; the owner accepts the residual. App: Risk, Tailor.

Do

### Implementations and machine checks

An Implementation says which component satisfies which clause, and whose job it is: `provider`, `customer`, `shared` or `inherited`. An inherited edge names the upstream authorization it leans on. A vendor's recommendation counts once an Implementation adopts it. A Check states which facts a collector reports and what passes.

**Who, and where** System owners, the check author; the vendor supplies advice. App: Implement, Checks.

Check

### Assessments and findings

An Assessment records who checked what, by which method, when and with which result. A machine run carries one row per Check with the observation itself, and the validator recomputes each verdict. A clause that is not satisfied becomes a Finding against that clause. An internal audit is an Assessment whose performer is internal.

**Who, and where** Internal assessor; collectors run outside JASCON. App: Assess, Validate.

Act

### Actions, deviations and new versions

A Finding carries actions with a due date a machine can compute. Where a clause is not met on purpose, a Deviation records why and who approved it. The Risk gets its residual rating, the Tailoring a new version. The validator lists every approved Deviation and every Risk whose `review-due` has passed.

**Who, and where** Risk owners, ISMS owner, top management. App: Assess, Risk, Tailor.

| Phase | Record | What the validator holds |
|---|---|---|
| Plan | Risk | The level is on the named scale and agrees with its matrix. A treated or retained Risk carries the owner's acceptance. Only an assessed or treated Risk with a chosen option justifies a requirement. |
| Plan | Tailoring | In a consumer's Tailoring, an easing of a modality or a move between obligation and prohibition needs a recorded Deviation with an approver. An operation names the statement it changes. With `--require-risk-basis`, a selected requirement no risk justifies is a failure. |
| Do | Implementation | An inherited edge names an authorization that exists on the upstream component. An adopted recommendation belongs to a product that is a member of the system. |
| Do | Check | Facts are typed, criteria use twelve comparators joined by one AND, the collector code is covered by the Check's digest. |
| Check | Assessment | The method is held to the facet it names. Each recorded check verdict is recomputed from its observation and the parameter value of the Tailoring. |
| Check | Finding | A due date is a date, an elapsed duration or a calendar period with its calendar. Without the calendar, no date is computed. |
| Act | Deviation | One of five types, one of four states, a named approver once approved. A passed `review-due` is reported, and nothing is switched off by it. |

Management review: the kernel has no record for it. Its inputs are the reports the validator prints and the states counted above; its decisions return as new versions of Risks and Tailorings. Handbook [chapter 6](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch06-tailoring-without-tears.md) (tailoring), [chapter 9](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch09-systems-components-inheritance.md) (implementation), [chapter 10](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch10-assessment-findings-deviations.md) (risk, assessment, findings).

05 The audit

## The auditor receives a folder and checks it offline

An external audit, a certification or an authorization starts with a hand-over. The organisation passes its bundle; the assessor verifies it on a machine of their own, without access to the organisation's systems and without a network.

- **Integrity first.** The validator compares both digests of every object with the manifest and judges each Attestation against what it binds. The PowerShell twin does the same on a stock Windows machine.
- **Then the decisions.** `--require-risk-basis` asks the question of ISO/IEC 27001 6.1.3: which selected control rests on no risk. `--as-of` fixes the date of the audit, so the overdue reviews are those of that day. `--require-authors` turns every record that names no author into a failure.
- **Then the machine verdicts.** Every recorded check verdict is recomputed from its observation. An evidence file is found by its SHA-256; a raw output withheld under a retention rule is reported as withheld.
- **Then the Deviations, by hand.** Does the type fit the facts, does the rationale carry without the meeting that produced it, may the approver approve this, do the references lead to evidence a stranger can re-examine.

The assessor writes an Assessment and Findings under the assessor's own namespace, and hands them back as a bundle. The authorizing official signs an Attestation that binds the semantic digests of the objects, the digest of the manifest and the digest of the rendered document they read.

**Objects**

Components, Implementations, Risks, the Tailoring, Checks, Assessments with their rows, Findings. Each as one JSON file.

**Content manifest**

lists every object with its package digest and its semantic digest, and pins the facet schemas.

**Evidence**

files under `evidence/sha256/`, each named by the SHA-256 of its bytes, with a record per run that binds the observation.

**Rendering**

the document a person reads and signs, such as the authorization summary of the example bundle.

**Attestation**

a DSSE envelope beside the manifest, never listed in it. It binds the objects, the manifest and the rendering.

*the assessor's first command*

```sh
python jascon/scripts/validate_core.py path/to/received-bundle \
    --require-risk-basis \
    --as-of 2026-11-15 \
    --require-authors \
    --trusted-keys path/to/trusted-keys.json
```

[Handbook, chapter 11: integrity, attestation, air gaps](https://github.com/christoph-puppe/JASCON/blob/main/jascon/references/ch11-integrity-attestation-airgaps.md)

06 Working off the findings

## One finding, end to end

The worked example of the handbook: an assessment of a SaaS finds no evidence of key rotation for clause s2 of a requirement. Clause s1 passed and is not touched.

Finding

`open` → `in-remediation` → `closed`

Deviation

`investigating` → `pending` → `approved`

`pending` → `withdrawn`

- **The assessor opens the Finding.** Against statement `s2`, with the Risk it materialised against and one action: a runbook and rotation evidence, due in twenty business days on a named calendar.
- **The organisation answers with evidence.** Rotation runs monthly; the scanner misread an export. That is a Deviation on the Finding, type `false-positive`, with references to the logs.
- **The assessor decides.** The Deviation becomes `approved` under the assessor's identifier, with the day it was decided and a date for its next review. The action and the Finding close.
- **The record stays.** Next year's auditor who asks why the finding ended without a fix reads one object. When `review-due` has passed, the validator lists the Deviation until someone renews or withdraws it.

A finding that needs a fix runs the other way: the action is done, the check runs again, and the new Assessment satisfies the clause. Running a check again on the Assess page replaces its Assessment and removes a Finding that is still open and no longer applies; a Finding that was moved on is kept.

*jascon/examples/finding-017.json — fictional parties*

```json
{
 "id": "https://assessor.example/finding/2026-q3-acme-017",
 "version": "1",
 "lifecycle": "active",
 "provenance": {
  "author-ref": "https://assessor.example/party/lead-assessor",
  "date": "2026-07-18"
 },
 "assessment-ref": "https://assessor.example/assessment/2026-q3-acme",
 "requirement-ref": "https://ns.bsi.bund.de/gspp/req/KONF.14.1",
 "statement-ref": "s2",
 "state": "closed",
 "actions": [
  {
   "description": {
    "en": "Provide key-rotation runbook and rotation evidence"
   },
   "due": {
    "type": "calendar-period",
    "num": 20,
    "unit": "bizdays",
    "calendar-ref": "https://ns.fedramp.gov/cr26/calendar/us-federal"
   },
   "status": "closed"
  }
 ],
 "deviations": [
  {
   "type": "false-positive",
   "state": "approved",
   "rationale": {
    "en": "Scanner misread KMS export; monthly rotation evidenced in KMS logs."
   },
   "approver-ref": "https://assessor.example/party/lead-assessor",
   "opened": "2026-07-16",
   "decided": "2026-07-18",
   "review-due": {
    "type": "date",
    "value": "2027-07-18"
   },
   "refs": [
    "https://cso.example/doc/kms-log-extract-2026-07"
   ]
  }
 ],
 "risk-refs": [
  "https://cso.example/risk/R-2026-007"
 ]
}
```

07 What crosses

## Every hand-over, with what the receiver checks

Within the organisation the records are files in one repository. Between parties they travel as bundles, and the receiver checks them with the same rules the sender ran.

| From | To | What | In JASCON | The receiver checks |
|---|---|---|---|---|
| Authority | Organisation | the catalogue and its baselines | bundle of Requirements, RequirementSets, Tailorings, Mappings; Attestation | schema and kernel rules; both digests; whether the Attestation binds |
| Vendor | Organisation | hardening advice for a product | advice pack: Components with capabilities, a manifest naming the publisher | ADVICE-1 to ADVICE-11; publisher claimed, attested or proven |
| Upstream provider | Organisation | the authorization a service runs under | `Component.authorizations` | that an inherited Implementation names one that exists |
| Check author | Operations | a machine check | Check with collector code in `collector@1` | the Check's digest covers the code that runs |
| Operations | Assessor | observations of a run | Assessment rows, evidence records, files under `evidence/sha256/` | every verdict recomputed; every file found by its digest |
| Organisation | Assessor | the ISMS for the audit | the whole bundle: system, Implementations, Risks, Tailoring, Assessments, Findings | all of the above, risk coverage, overdue reviews, missing authors |
| Assessor | Organisation | the audit result | Assessment and Findings under the assessor's namespace; approved Deviations | the same kernel rules; the assessor's Attestation, where one is signed |
| Authorizing official | Customer | the signed authorization | Attestation over objects, manifest and rendering | Full Match, Semantic Match, or it does not bind; signature under a trusted key |

08 Limits

## What this page describes is designed, not measured in use

designed for No organisation has run a full cycle of its ISMS on JASCON. The example bundle walks one requirement, one risk and one finding through it, with fictional parties.

### Not in the kernel

The text of the ISMS policies and the scope statement, the minutes of the management review, the audit programme and its calendar, training records. A policy can be a Component of kind `policy`; its text stays a document.

### Not a workflow engine

Nothing assigns a task, sends a reminder or moves a state on its own. A passed review date is reported; the record keeps its meaning until a person decides. No tool of the repository runs a collector.

## Walk the cycle on the example bundle

The app opens the example with its Risk, its Tailorings, the Implementations, two Checks with their runs, the Findings and the Attestation. Each page of the app is one step of this process.

[Open the Risk page](https://jascon.net/app/index.html#load=../jascon/examples/&tool=risk) [Open the Assess page](https://jascon.net/app/index.html#load=../jascon/examples/&tool=assess)
