Moral Agency and the Stories We Tell About Ourselves: Responsibility, Excuse, and Repair

Last Updated June 11, 2026

Moral agency is not only a matter of isolated decisions. It is also shaped by the stories people tell about who they are, what they intended, what they suffered, what they chose, what they avoided, what they owe, and what kind of person they believe they are becoming.

Moral Agency and the Stories We Tell About Ourselves examines how self-narratives shape responsibility, excuse, repentance, blame, repair, self-deception, moral growth, and public accountability. It asks how people use stories to understand their own actions, defend themselves, confess failure, seek forgiveness, claim victimhood, justify harm, resist shame, or imagine change.

This article treats moral self-story as powerful but dangerous. Stories can help people acknowledge responsibility, repair harm, and become more truthful about themselves. They can also excuse wrongdoing, hide agency, exaggerate innocence, center suffering to avoid accountability, or convert moral growth into a flattering personal brand.

Why Moral Agency Matters

Moral agency matters because human beings do not merely act; they answer for action. A person can explain what happened, describe intention, acknowledge harm, deny responsibility, seek forgiveness, justify a choice, make a promise, or repair a wrong. Moral agency is the capacity to participate in this world of answerability.

Stories matter because people rarely understand responsibility as a single event. They locate actions inside larger accounts: childhood, pressure, loyalty, fear, ambition, ignorance, habit, trauma, temptation, duty, betrayal, institution, culture, or survival. These stories shape whether someone sees themselves as responsible, helpless, justified, guilty, ashamed, obligated, or capable of change.

The danger is that self-narratives can protect the self from moral truth. A person can tell a story that makes harm seem inevitable, blame seem unfair, apology seem complete, or repair seem unnecessary. Moral agency therefore requires not only a story about oneself, but the ability to test that story against consequences, witnesses, evidence, and the claims of others.

Moral agency matters because the stories people tell about themselves can either deepen responsibility or protect them from it.

Back to top ↑

What Is Moral Agency?

Moral agency is the capacity to act, deliberate, recognize reasons, affect others, understand norms, accept responsibility, and respond to moral claims. It includes intention, choice, awareness, consequence, accountability, and the possibility of repair.

Moral agency does not require total freedom. People act under pressure, constraint, fear, ignorance, habit, institution, culture, and unequal power. But agency is not erased every time conditions are difficult. A responsible analysis asks what the person knew, what options were available, what harms were foreseeable, what obligations existed, and what response followed.

In storytelling, moral agency appears through character, decision, motive, omission, silence, witness, consequence, confession, and change. A story can show agency clearly, obscure it, exaggerate it, or deny it. That is why moral self-narratives require careful analysis.

Moral agency is the capacity to be more than the narrator of one’s own innocence.

Back to top ↑

Self-Narration and Responsibility

Self-narration is one way people make moral sense of themselves. A person may say, “I was trying to help,” “I had no choice,” “I did not know,” “I was under pressure,” “I was protecting someone,” “I was wrong,” or “I have changed.” Each statement places action inside a story.

Some self-narratives make responsibility clearer. They identify the action, name the harm, acknowledge the affected person, explain without excusing, and describe what repair requires. Other self-narratives make responsibility harder to see. They shift attention to pressure, intention, pain, misunderstanding, or identity while leaving consequences vague.

The ethical issue is not whether people should tell stories about themselves. They must. The issue is whether those stories remain accountable to reality beyond the self.

Self-narration becomes responsible when it can survive the presence of the people affected by the story.

Back to top ↑

The Moral Self as Story

People often understand themselves through moral identity: good person, loyal friend, responsible parent, honest worker, faithful believer, survivor, reformer, activist, patriot, helper, protector, rebel, victim, witness, or truth-teller. These identities are story-shaped. They explain what actions fit the self and what actions threaten it.

A moral identity can guide behavior. Someone who sees themselves as honest may resist lying. Someone who sees themselves as a protector may take risks for others. Someone who sees themselves as responsible may repair a wrong. Stories can sustain moral courage.

But moral identity can also become self-protection. The stronger the story “I am a good person,” the harder it may be to hear that one has caused harm. A person may defend the identity rather than examine the action. Moral growth often begins when the story of the self becomes honest enough to include failure.

A moral self-story is useful only if it remains open to correction.

Back to top ↑

Intention, Action, and Consequence

Moral self-stories often overemphasize intention. People defend themselves by saying what they meant, hoped, or believed. Intention matters, but it does not settle moral responsibility. A person can intend good and still cause harm. A person can fail to intend harm because they refused to notice what should have been obvious.

Action and consequence must remain visible. What was done? What was omitted? What changed for others? What damage followed? Who bore the cost? What did the person do after learning the impact?

Narrative ethics requires keeping intention, action, and consequence in relation. A good self-story does not erase motive, but neither does it allow motive to swallow consequence.

A morally serious story asks not only “What did I mean?” but “What did my action do?”

Back to top ↑

Excuse, Justification, and Self-Deception

People often use stories to manage guilt, shame, or blame. Some explanations are legitimate. Pressure, fear, misinformation, coercion, immaturity, illness, structural constraint, or emergency can matter morally. But explanation becomes evasion when it removes the harmed person from view.

An excuse says responsibility is reduced. A justification says the action was right or necessary. Self-deception says the story has become organized to protect the narrator from unwanted moral knowledge. These forms can overlap.

Self-deception is especially powerful because the narrator may believe the story sincerely. A person can select details, omit context, exaggerate constraint, minimize consequence, and make their own reaction seem inevitable. Moral agency requires the discipline of testing self-story against evidence and others’ accounts.

Self-deception is storytelling turned inward as a defense against moral truth.

Back to top ↑

Confession, Repentance, and Repair

Confession can be morally important, but confession is not the same as repair. A person can confess to relieve guilt, perform honesty, regain status, control the narrative, or preempt criticism. Confession becomes ethically meaningful only when it names harm truthfully and accepts responsibility beyond the self’s emotional need.

Repentance is more than feeling bad. It involves a changed relation to the action, the harmed person, the truth, and the future. It requires giving up the self-protective version of the story. It may require apology, restitution, changed behavior, public correction, institutional reform, or long-term accountability.

Repair is the test of moral self-narration. A story that ends with “I learned a lot” is not enough. The question is what the person now owes and whether the harmed party’s reality remains central.

Moral repair begins when the story stops being mainly about how the narrator feels about being wrong.

Back to top ↑

Victimhood, Harm, and Agency

Victimhood can be a truthful moral category. People are harmed by violence, neglect, exploitation, betrayal, discrimination, abuse, and structural injustice. Naming victimhood can restore reality where denial has erased it. It can also create the conditions for witness, protection, justice, and repair.

But victimhood can also become narratively complicated. A person who has been harmed may also cause harm. A group that has suffered may also justify wrongdoing. A self-story organized only around injury may make agency difficult to see. The ethical task is not to deny victimhood, but to avoid making it the only moral fact.

Moral agency after harm requires care. Survivors should not be pressured into inspirational resilience or moral purity. At the same time, suffering does not automatically authorize every action taken afterward. A responsible narrative can hold harm suffered and responsibility for action together.

A morally serious story can name harm suffered without using it to erase harm caused.

Back to top ↑

Moral Memory and Retrospective Judgment

Moral memory is the way people remember actions under later ethical understanding. Someone may look back and realize a joke was cruel, a silence was cowardly, a loyalty was misplaced, an ambition was harmful, or an apology was insufficient. Moral self-understanding often changes because the narrator changes.

Retrospective judgment can clarify responsibility. It can also distort the past. A narrator may judge an earlier self too harshly, too generously, or too cleanly. Hindsight can turn confusion into intention or intention into innocence. It can make growth seem inevitable.

A responsible moral memory distinguishes what was known then, what is known now, what should have been known, and what remains uncertain. This distinction is especially important in memoir, apology, testimony, public reckoning, and institutional history.

Moral memory is responsible when it revises the self-story without using hindsight as a shield.

Back to top ↑

Others Inside the Moral Story

Every moral self-story includes others. The harmed person, witness, critic, accomplice, bystander, beneficiary, community, institution, and future audience all shape the meaning of action. A self-story that removes others becomes morally thin.

The narrator may describe others unfairly. A harmed person may become “too sensitive.” A critic may become “hostile.” A witness may become “confused.” A community may become “ungrateful.” These narrative moves protect the self by discrediting moral claims from outside.

Responsible moral self-narration gives others reality. It allows the harmed person’s experience to matter. It does not demand that others validate the narrator’s preferred identity. It understands that being a moral agent means being answerable to more than one’s own account.

A moral self-story becomes trustworthy when it gives other people more than supporting roles.

Back to top ↑

Public Moral Narratives

Public life is full of moral self-narratives. Leaders, organizations, movements, nations, professions, platforms, and institutions tell stories about integrity, service, sacrifice, reform, innocence, victimhood, learning, and progress. These stories seek legitimacy.

Public moral narratives can guide accountability. They can also become reputation management. An institution may say it has learned from harm while avoiding material repair. A leader may present criticism as persecution. A movement may define itself as righteous and therefore excuse its own abuses. A nation may narrate historical violence as necessary progress.

The ethical test for public moral narrative is whether the story can name harm, preserve evidence, include counter-memory, identify responsible agents, and commit to repair. A public story that protects legitimacy while avoiding accountability is not moral narration; it is moral branding.

Public moral narratives require evidence, counter-memory, and repair because reputation is not the same as responsibility.

Back to top ↑

Digital and AI-Mediated Moral Selfhood

Digital platforms intensify moral self-narration. People explain themselves in posts, apology videos, comment threads, profiles, newsletters, podcasts, and public statements. Audiences judge actions quickly, often through partial information. Platforms reward simplified moral roles: victim, villain, hypocrite, hero, fraud, witness, traitor, survivor, reformer.

Digital moral narratives can expose harm that would otherwise remain hidden. They can also flatten context, encourage performance, punish complexity, and make moral identity dependent on public visibility. The pressure to narrate oneself morally online can produce defensive confession, strategic vulnerability, or preemptive apology.

AI adds another layer. Systems can summarize reputations, infer character from traces, generate apology drafts, classify sentiment, or model moral scenarios. These tools can assist reflection, but they can also automate moral framing without context, consent, or accountability. Moral selfhood should not be reduced to a profile, score, or generated statement.

Digital moral selfhood requires a distinction between public performance, genuine accountability, and automated reputation.

Back to top ↑

Ethics of Self-Narration

The ethics of self-narration begins with humility. A person is never the only authority on the moral meaning of their action. The self knows intention, feeling, context, and memory from inside. Others may know consequence, harm, pattern, and impact from outside. A responsible self-story must be porous enough to hear them.

Ethical self-narration also requires proportion. The narrator should not overstate innocence, suffering, growth, coercion, ignorance, or transformation. The story should name what is known, what is uncertain, what remains contested, and what repair still requires.

The strongest moral self-stories are not the most flattering. They are the ones that can include failure without collapsing into shame, context without evasion, harm without defensiveness, and change without premature closure.

Ethical self-narration is not the art of appearing good. It is the discipline of becoming answerable.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Moral agency should not be reduced to a score. Still, modeling can make the assumptions of moral self-narrative analysis more explicit. It can help audit whether a story identifies action, consequence, agency, excuse, repair, other-person reality, and method limits.

A moral-agency clarity score can estimate whether a self-story names responsibility clearly:

An excuse-risk score can estimate whether the self-story is avoiding responsibility:

A repair-readiness score can estimate whether the narrative moves toward obligation:

An interpretation-readiness score can estimate whether the moral analysis is suitable for reuse:

Computation can support moral self-narrative analysis only when it remains accountable to evidence, witnesses, context, and human judgment.

Back to top ↑

Python Workflow: Moral Agency Canvas Audit

The Python workflow below follows the advanced Catalyst Canvas standard: typed records, config-driven scoring, validation, governance notes, Canvas-card exports, CSV outputs, JSON outputs, markdown governance queues, and review priorities. The companion repository version includes the shared `python/catalyst_canvas/` layer plus article-specific data for moral agency, excuse risk, repair readiness, witness visibility, and digital moral selfhood.

# run_moral_agency_canvas_audit.py
from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
import json
from hashlib import sha256
from statistics import mean
from typing import Any


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
OUTPUTS = ARTICLE_ROOT / "outputs"


@dataclass(frozen=True)
class MoralAgencyRecord:
    item: str
    claim_context: str
    action_naming: float
    intention_distinction: float
    consequence_clarity: float
    harm_marking: float
    repair_orientation: float
    other_visibility: float
    context_overuse: float
    intention_shielding: float
    victimhood_shielding: float
    blame_shifting: float
    growth_substitution: float
    harm_minimization: float
    harm_acknowledgment: float
    apology_precision: float
    material_response: float
    conduct_change: float
    future_accountability: float
    third_party_oversight: float
    source_context: float
    evidence_visibility: float
    uncertainty_notes: float
    cultural_context: float
    method_limits: float
    review_owner_clarity: float
    public_consequence: float
    owner: str = "editorial"
    status: str = "active"
    notes: str = ""


@dataclass(frozen=True)
class MoralAgencyConfig:
    article_title: str = "Moral Agency and the Stories We Tell About Ourselves"
    article_slug: str = "moral-agency-and-the-stories-we-tell-about-ourselves"
    medium_threshold: float = 0.45
    high_threshold: float = 0.62
    allowed_statuses: tuple[str, ...] = ("active", "archive", "review", "revise")


def validate_score(value: float, field_name: str) -> None:
    if value < 0 or value > 1:
        raise ValueError(f"{field_name} must be between 0 and 1.")


def validate_record(record: MoralAgencyRecord, config: MoralAgencyConfig) -> None:
    if not record.item.strip():
        raise ValueError("item is required.")
    if not record.claim_context.strip():
        raise ValueError("claim_context is required.")
    if record.status not in config.allowed_statuses:
        raise ValueError(f"Invalid status: {record.status}")

    for field_name, value in record.__dict__.items():
        if isinstance(value, float):
            validate_score(value, field_name)


def moral_clarity(record: MoralAgencyRecord) -> float:
    return mean([
        record.action_naming,
        record.intention_distinction,
        record.consequence_clarity,
        record.harm_marking,
        record.repair_orientation,
        record.other_visibility,
    ])


def excuse_risk(record: MoralAgencyRecord) -> float:
    return min(
        1.0,
        record.context_overuse * 0.16
        + record.intention_shielding * 0.18
        + record.victimhood_shielding * 0.18
        + record.blame_shifting * 0.18
        + record.growth_substitution * 0.16
        + record.harm_minimization * 0.14,
    )


def repair_readiness(record: MoralAgencyRecord) -> float:
    return mean([
        record.harm_acknowledgment,
        record.apology_precision,
        record.material_response,
        record.conduct_change,
        record.future_accountability,
        record.third_party_oversight,
    ])


def interpretation_readiness(record: MoralAgencyRecord) -> float:
    return mean([
        record.source_context,
        record.evidence_visibility,
        record.uncertainty_notes,
        record.cultural_context,
        record.method_limits,
        record.review_owner_clarity,
    ])


def governance_priority_score(record: MoralAgencyRecord, config: MoralAgencyConfig) -> float:
    score = (
        excuse_risk(record) * 0.36
        + (1 - repair_readiness(record)) * 0.24
        + (1 - interpretation_readiness(record)) * 0.22
        + record.public_consequence * 0.18
    )

    if record.status == "revise":
        score = max(score, config.high_threshold)
    elif record.status == "review":
        score = max(score, config.medium_threshold)

    return min(1.0, max(0.0, score))


def review_priority(record: MoralAgencyRecord, config: MoralAgencyConfig) -> str:
    score = governance_priority_score(record, config)
    if score >= config.high_threshold:
        return "high"
    if score >= config.medium_threshold:
        return "medium"
    return "standard"


def card_id(record: MoralAgencyRecord, config: MoralAgencyConfig) -> str:
    raw = f"{config.article_slug}|{record.item}|{record.claim_context}"
    return sha256(raw.encode("utf-8")).hexdigest()[:16]


def governance_note(record: MoralAgencyRecord, config: MoralAgencyConfig) -> str:
    priority = review_priority(record, config)
    risk = excuse_risk(record)
    repair = repair_readiness(record)

    notes = []

    if priority == "high":
        notes.append("High-priority moral-agency governance review required.")
    elif priority == "medium":
        notes.append("Medium-priority review recommended before reuse.")
    else:
        notes.append("Standard editorial review sufficient.")

    if risk >= 0.55:
        notes.append("Excuse risk is elevated; review context overuse, intention shielding, victimhood shielding, blame shifting, growth substitution, and harm minimization.")
    if repair < 0.60:
        notes.append("Repair readiness is limited; strengthen harm acknowledgment, apology precision, material response, conduct change, future accountability, and oversight.")
    if record.notes:
        notes.append(record.notes)

    return " ".join(notes)


def canvas_card(record: MoralAgencyRecord, config: MoralAgencyConfig) -> dict[str, Any]:
    return {
        "schema_version": "1.0.0",
        "card_id": card_id(record, config),
        "card_type": "moral_agency_self_narrative",
        "article_title": config.article_title,
        "article_slug": config.article_slug,
        "item": record.item,
        "claim_context": record.claim_context,
        "scores": {
            "moral_clarity": round(moral_clarity(record), 4),
            "excuse_risk": round(excuse_risk(record), 4),
            "repair_readiness": round(repair_readiness(record), 4),
            "interpretation_readiness": round(interpretation_readiness(record), 4),
            "governance_priority_score": round(governance_priority_score(record, config), 4),
        },
        "review": {
            "priority": review_priority(record, config),
            "owner": record.owner,
            "status": record.status,
            "governance_note": governance_note(record, config),
        },
    }


def write_csv(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    fieldnames = list(rows[0].keys())
    with path.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")


def write_markdown_queue(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    lines = [
        "# Moral Agency Governance Queue",
        "",
        "| Item | Context | Moral clarity | Excuse risk | Repair readiness | Readiness | Priority | Owner |",
        "|---|---|---:|---:|---:|---:|---|---|",
    ]

    for row in rows:
        lines.append(
            f"| {row['item']} | {row['claim_context']} | "
            f"{row['moral_clarity']} | {row['excuse_risk']} | "
            f"{row['repair_readiness']} | {row['interpretation_readiness']} | "
            f"{row['review_priority']} | {row['owner']} |"
        )

    path.write_text("\n".join(lines) + "\n", encoding="utf-8")


def main() -> None:
    config = MoralAgencyConfig()

    records = [
        MoralAgencyRecord(
            "Personal apology",
            "action harm repair and accountability audit",
            0.86, 0.82, 0.84, 0.88, 0.80, 0.82,
            0.36, 0.42, 0.30, 0.34, 0.40, 0.32,
            0.86, 0.84, 0.76, 0.78, 0.82, 0.72,
            0.84, 0.82, 0.80, 0.82, 0.84, 0.80,
            0.78,
            "editorial", "active",
            "Standard review; check whether repair follows apology."
        ),
        MoralAgencyRecord(
            "Institutional reform story",
            "closure language legitimacy and repair audit",
            0.68, 0.70, 0.66, 0.62, 0.58, 0.60,
            0.72, 0.68, 0.50, 0.76, 0.82, 0.78,
            0.58, 0.62, 0.44, 0.50, 0.46, 0.42,
            0.76, 0.74, 0.78, 0.80, 0.76, 0.78,
            0.92,
            "governance", "revise",
            "Escalate premature closure and reputation management."
        ),
        MoralAgencyRecord(
            "Victimhood shielding",
            "harm suffered harm caused and agency audit",
            0.72, 0.68, 0.70, 0.64, 0.60, 0.58,
            0.62, 0.58, 0.88, 0.66, 0.54, 0.70,
            0.62, 0.60, 0.50, 0.54, 0.56, 0.48,
            0.80, 0.76, 0.78, 0.82, 0.78, 0.80,
            0.88,
            "ethics review", "review",
            "Honor harm suffered while reviewing responsibility for harm caused."
        ),
    ]

    rows = []
    cards = []

    for record in records:
        validate_record(record, config)
        cards.append(canvas_card(record, config))
        rows.append({
            "item": record.item,
            "claim_context": record.claim_context,
            "moral_clarity": round(moral_clarity(record), 4),
            "excuse_risk": round(excuse_risk(record), 4),
            "repair_readiness": round(repair_readiness(record), 4),
            "interpretation_readiness": round(interpretation_readiness(record), 4),
            "governance_priority_score": round(governance_priority_score(record, config), 4),
            "review_priority": review_priority(record, config),
            "owner": record.owner,
            "status": record.status,
            "governance_note": governance_note(record, config),
        })

    priority_order = {"high": 3, "medium": 2, "standard": 1}
    rows = sorted(
        rows,
        key=lambda row: (
            priority_order.get(str(row["review_priority"]), 0),
            float(row["governance_priority_score"]),
        ),
        reverse=True,
    )

    queue = [row for row in rows if row["review_priority"] != "standard"]
    queue_cards = [card for card in cards if card["review"]["priority"] != "standard"]

    write_csv(OUTPUTS / "tables" / "moral_agency_audit.csv", rows)
    write_csv(OUTPUTS / "tables" / "moral_agency_governance_queue.csv", queue)
    write_json(OUTPUTS / "json" / "moral_agency_canvas_cards.json", cards)
    write_json(OUTPUTS / "json" / "moral_agency_governance_queue.json", queue_cards)
    write_markdown_queue(OUTPUTS / "markdown" / "moral_agency_governance_queue.md", queue)

    print("Moral agency Canvas audit complete.")


if __name__ == "__main__":
    main()

This workflow treats moral self-narratives as accountable claims about action, consequence, agency, repair, and the presence of others.

Back to top ↑

R Workflow: Moral Agency Diagnostics

The R workflow below provides a portable base R diagnostic for moral self-narrative analysis. It calculates moral clarity, excuse risk, repair readiness, interpretation readiness, governance priority, and review status.

# moral_agency_diagnostics.R
# Base R workflow for Moral Agency and the Stories We Tell About Ourselves.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

records <- data.frame(
  item = c(
    "Personal apology",
    "Institutional reform story",
    "Victimhood shielding"
  ),
  claim_context = c(
    "action harm repair and accountability audit",
    "closure language legitimacy and repair audit",
    "harm suffered harm caused and agency audit"
  ),
  action_naming = c(0.86, 0.68, 0.72),
  intention_distinction = c(0.82, 0.70, 0.68),
  consequence_clarity = c(0.84, 0.66, 0.70),
  harm_marking = c(0.88, 0.62, 0.64),
  repair_orientation = c(0.80, 0.58, 0.60),
  other_visibility = c(0.82, 0.60, 0.58),
  context_overuse = c(0.36, 0.72, 0.62),
  intention_shielding = c(0.42, 0.68, 0.58),
  victimhood_shielding = c(0.30, 0.50, 0.88),
  blame_shifting = c(0.34, 0.76, 0.66),
  growth_substitution = c(0.40, 0.82, 0.54),
  harm_minimization = c(0.32, 0.78, 0.70),
  harm_acknowledgment = c(0.86, 0.58, 0.62),
  apology_precision = c(0.84, 0.62, 0.60),
  material_response = c(0.76, 0.44, 0.50),
  conduct_change = c(0.78, 0.50, 0.54),
  future_accountability = c(0.82, 0.46, 0.56),
  third_party_oversight = c(0.72, 0.42, 0.48),
  source_context = c(0.84, 0.76, 0.80),
  evidence_visibility = c(0.82, 0.74, 0.76),
  uncertainty_notes = c(0.80, 0.78, 0.78),
  cultural_context = c(0.82, 0.80, 0.82),
  method_limits = c(0.84, 0.76, 0.78),
  review_owner_clarity = c(0.80, 0.78, 0.80),
  public_consequence = c(0.78, 0.92, 0.88),
  owner = c("editorial", "governance", "ethics review"),
  status = c("active", "revise", "review"),
  stringsAsFactors = FALSE
)

records$moral_clarity <- rowMeans(records[, c(
  "action_naming",
  "intention_distinction",
  "consequence_clarity",
  "harm_marking",
  "repair_orientation",
  "other_visibility"
)])

records$excuse_risk <- pmin(
  1,
  records$context_overuse * 0.16 +
    records$intention_shielding * 0.18 +
    records$victimhood_shielding * 0.18 +
    records$blame_shifting * 0.18 +
    records$growth_substitution * 0.16 +
    records$harm_minimization * 0.14
)

records$repair_readiness <- rowMeans(records[, c(
  "harm_acknowledgment",
  "apology_precision",
  "material_response",
  "conduct_change",
  "future_accountability",
  "third_party_oversight"
)])

records$interpretation_readiness <- rowMeans(records[, c(
  "source_context",
  "evidence_visibility",
  "uncertainty_notes",
  "cultural_context",
  "method_limits",
  "review_owner_clarity"
)])

records$governance_priority_score <- pmin(
  1,
  records$excuse_risk * 0.36 +
    (1 - records$repair_readiness) * 0.24 +
    (1 - records$interpretation_readiness) * 0.22 +
    records$public_consequence * 0.18
)

records$review_priority <- ifelse(
  records$status == "revise" | records$governance_priority_score >= 0.62,
  "high",
  ifelse(
    records$status == "review" | records$governance_priority_score >= 0.45,
    "medium",
    "standard"
  )
)

records <- records[order(records$governance_priority_score, decreasing = TRUE), ]

write.csv(records, file.path(tables_dir, "moral_agency_diagnostics.csv"), row.names = FALSE)
write.csv(records[records$review_priority != "standard", ], file.path(tables_dir, "moral_agency_governance_queue.csv"), row.names = FALSE)

png(file.path(figures_dir, "moral_clarity_scores.png"), width = 1200, height = 700)
barplot(
  records$moral_clarity,
  names.arg = records$item,
  las = 2,
  ylab = "Moral clarity",
  main = "Moral Self-Narrative Clarity"
)
grid()
dev.off()

png(file.path(figures_dir, "excuse_risk_scores.png"), width = 1200, height = 700)
barplot(
  records$excuse_risk,
  names.arg = records$item,
  las = 2,
  ylab = "Excuse risk",
  main = "Moral Self-Narrative Excuse Risk"
)
grid()
dev.off()

print(records[, c(
  "item",
  "claim_context",
  "moral_clarity",
  "excuse_risk",
  "repair_readiness",
  "interpretation_readiness",
  "review_priority"
)])

This workflow supports structured review while preserving the interpretive and ethical limits of moral self-narrative analysis.

Back to top ↑

GitHub Repository

The companion repository for this article supports moral self-narrative analysis as a Catalyst Canvas-ready module. It includes advanced additive `python/catalyst_canvas/` governance infrastructure, article-specific moral-agency data, config-driven scoring, validation, governance notes, Canvas card generation, CSV/JSON/markdown exporters, CLI workflows, smoke tests, unit tests, R diagnostics, SQL structures, documentation, and reusable moral-agency review templates.

articles/moral-agency-and-the-stories-we-tell-about-ourselves/
├── canvas/
│   ├── canvas_manifest.json
│   ├── input_schema.json
│   ├── output_schema.json
│   ├── catalyst_canvas_config.json
│   ├── catalyst_canvas_manifest.json
│   ├── catalyst_canvas_cards.json
│   └── catalyst_canvas_governance_queue.json
├── html/
├── css/
├── php/
├── java/
├── python/
│   ├── catalyst_canvas/
│   │   ├── __init__.py
│   │   ├── __main__.py
│   │   ├── cli.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── moral_agency_canvas/
│   │   ├── __init__.py
│   │   ├── models.py
│   │   ├── scoring.py
│   │   ├── validation.py
│   │   ├── governance.py
│   │   └── exporters.py
│   ├── tests/
│   │   ├── test_catalyst_canvas.py
│   │   └── test_moral_agency_canvas.py
│   ├── run_catalyst_canvas_audit.py
│   └── run_moral_agency_canvas_audit.py
├── r/
│   ├── moral_agency_diagnostics.R
│   └── run_all_moral_agency_workflows.R
├── sql/
│   ├── canvas_schema.sql
│   └── canvas_queries.sql
├── docs/
│   ├── article_notes.md
│   ├── modeling_principles.md
│   ├── moral_agency_and_responsibility.md
│   ├── self_narration_and_accountability.md
│   ├── intention_action_and_consequence.md
│   ├── excuse_justification_and_self_deception.md
│   ├── confession_repentance_and_repair.md
│   ├── victimhood_harm_and_agency.md
│   ├── public_moral_narratives.md
│   ├── digital_and_ai_mediated_moral_selfhood.md
│   ├── ethical_risk.md
│   ├── responsible_use.md
│   ├── governance_notes.md
│   └── catalyst_canvas_upgrade_notes.md
├── data/
│   ├── moral_agency_claims.csv
│   ├── apology_repair_notes.csv
│   ├── excuse_risk_notes.csv
│   ├── public_moral_narrative_notes.csv
│   ├── digital_moral_selfhood_governance_notes.csv
│   └── catalyst_canvas_assessment.csv
├── outputs/
│   ├── figures/
│   ├── json/
│   ├── markdown/
│   └── tables/
├── notebooks/
├── shared/
│   ├── schemas/
│   ├── narrative-templates/
│   ├── story-archetypes/
│   ├── character-models/
│   ├── plot-structures/
│   ├── rhetorical-frameworks/
│   ├── cultural-memory/
│   ├── moral-agency/
│   └── governance/
├── tests/
└── README.md

Back to top ↑

Related Articles

• Autobiography, Memoir, and Life-Writing
• Narrative Identity and the Story of the Self
• Memory, Trauma, and Fragmented Narrative
• Paul Ricoeur and Narrative Time
• Law, Evidence, and Narrative Responsibility
• Rhetorical Moves and the Ethics of Persuasive Story

Back to top ↑

Back to top ↑

Back to top ↑

Why Moral Self-Narration Still Matters

Moral self-narration still matters because human beings need stories to understand responsibility across time. A person is not only a decision-maker in the moment. A person is also someone who remembers, explains, promises, regrets, apologizes, repairs, changes, and remains answerable.

The stories people tell about themselves can support moral growth. They can help someone name harm, resist self-deception, accept correction, seek repair, and become more truthful. They can also protect innocence, hide consequence, excuse wrongdoing, demand forgiveness, or convert accountability into image management.

The ethical task is not to abandon self-story. The ethical task is to tell it under discipline. A morally serious self-story must include action, consequence, others, evidence, uncertainty, and repair. It must be able to hear the people affected by it. It must be willing to change.

Moral agency begins when the self stops using story only to explain itself and begins using story to become answerable.

Back to top ↑

Further Reading

• Aristotle (2009) The Nicomachean Ethics. Translated by D. Ross. Oxford: Oxford University Press.
• Frankfurt, H.G. (1988) The Importance of What We Care About. Cambridge: Cambridge University Press.
• Lagay, F.L. (2014) ‘The Ethical Force of Stories: Narrative Ethics and Beyond’, AMA Journal of Ethics, 16(8), pp. 609–612. Available at: https://journalofethics.ama-assn.org/article/ethical-force-stories-narrative-ethics-and-beyond/2014-08
• MacIntyre, A. (1981) After Virtue: A Study in Moral Theory. Notre Dame: University of Notre Dame Press.
• Ricoeur, P. (1992) Oneself as Another. Translated by K. Blamey. Chicago: University of Chicago Press.
• Schechtman, M. (1996) The Constitution of Selves. Ithaca: Cornell University Press.
• Taylor, C. (1989) Sources of the Self: The Making of the Modern Identity. Cambridge: Cambridge University Press.
• Williams, B. (1981) Moral Luck. Cambridge: Cambridge University Press.

References

• Aristotle (2009) The Nicomachean Ethics. Translated by D. Ross. Oxford: Oxford University Press.
• Emelin, D., Le Bras, R., Hwang, J.D., Forbes, M. and Choi, Y. (2020) ‘Moral Stories: Situated Reasoning about Norms, Intents, Actions, and their Consequences’. Available at: https://arxiv.org/abs/2012.15738
• Frankfurt, H.G. (1988) The Importance of What We Care About. Cambridge: Cambridge University Press.
• Lagay, F.L. (2014) ‘The Ethical Force of Stories: Narrative Ethics and Beyond’, AMA Journal of Ethics, 16(8), pp. 609–612. Available at: https://journalofethics.ama-assn.org/article/ethical-force-stories-narrative-ethics-and-beyond/2014-08
• MacIntyre, A. (1981) After Virtue: A Study in Moral Theory. Notre Dame: University of Notre Dame Press.
• Pellauer, D. (2022) ‘Paul Ricoeur’, Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/ricoeur/
• Ricoeur, P. (1992) Oneself as Another. Translated by K. Blamey. Chicago: University of Chicago Press.
• Schechtman, M. (1996) The Constitution of Selves. Ithaca: Cornell University Press.
• Taylor, C. (1989) Sources of the Self: The Making of the Modern Identity. Cambridge: Cambridge University Press.
• Williams, B. (1981) Moral Luck. Cambridge: Cambridge University Press.

Back to top ↑