# Team decisions (/team-decisions)



In a linked repository, the agent records the decisions that matter as it works, and keeps to the team's decisions
that are in your code.

## What the agent records [#what-the-agent-records]

A choice between real alternatives that a teammate would otherwise undo or redo: an architecture or a data shape, a
library picked or refused, a convention set, a behavior you asked for that the code can't explain, a trade-off accepted
on purpose. Each says what was decided, why, and what was turned down.

It doesn't record renames, obvious fixes, what the code already makes plain, or anything about one conversation only.
It never puts secrets, keys or personal data in a decision, and Jinion refuses one that looks like it holds them.

Each shows in the turn that made it:

```text
[x] Recorded decision Sessions expire after 30 days without a request · you asked for it
```

| Says             | Because                                                |
| ---------------- | ------------------------------------------------------ |
| you asked for it | You asked for it                                       |
| from your answer | You answered the agent's question or approved its plan |
| its call         | The agent chose it on its own                          |

Open the line to read the whole decision. Delete one of yours from `/decisions`, or with **Delete** under it in the
desktop app; it goes for everyone.

## Which decisions apply [#which-decisions-apply]

A decision binds your agent only when its commit is in your code: when one of the commits that carry it is in the
history of the branch you're on.

Say Ayşe records a decision on `feat/cache` and pushes it. Until her branch is merged and you pull, it isn't in your
code, and your agent doesn't follow it. Once you pull, it does. A teammate's decision never reaches your agent before
the code it was made for.

Jinion sorts each decision by your branch:

| Group                      | What it means                                          | Your agent                 |
| -------------------------- | ------------------------------------------------------ | -------------------------- |
| In your code               | Its commit is in your branch's history                 | Keeps to it                |
| Not pulled yet             | It is on your branch's upstream, after your last fetch | Will, once you pull        |
| On other branches          | A teammate's, on a branch your code doesn't have       | Doesn't follow it          |
| Yours, not in a commit yet | A draft: only you see it, until a commit carries it    | Keeps to it on this branch |

A draft finds its commit by itself, whether you commit in Jinion or in your own terminal. One never committed is
deleted after 14 days. A decision that was archived, replaced by a newer one, or whose pull request was closed without
merging no longer applies.

`/decisions`, or the **Decisions** page in the desktop app, shows these groups for the branch you're on. The status
line's `[T] Acme 2 to pull` and the badge on the desktop's icon count the ones not pulled yet.

## When the agent keeps to one [#when-the-agent-keeps-to-one]

When a decision in your code shapes the work, the turn says so, and the agent names it in its reply:

```text
[x] Kept to Ayşe's decision Keep sessions in Redis, not in Postgres · Oct 3
```

When you ask for something a decision rules out, the agent says which one, and asks whether to keep it or replace it.
Replacing it records a new decision that supersedes the old one.

## When a teammate decided something elsewhere [#when-a-teammate-decided-something-elsewhere]

When a turn changes files that a teammate's decision on another branch concerns, the turn warns you, once per decision,
so you can talk before the two branches meet:

```text
[!] Also on another branch Mehmet's "Move sessions to Postgres" · feat/sessions-pg #42 open
```

## The archive [#the-archive]

Every decision of the workspace, with search and filters by project, author, branch, state and file, is on
[cloud.jinion.co](https://cloud.jinion.co). A decision's page says what, why and what was turned down, its commits and
pull requests, and what it replaced. Admins archive a decision there, or mark it replaced by another; agents stop
following it on their next sync.