# ಮುಂದಿನ ಖಾತೆಗೆ ಬದಲಾಯಿಸುವುದು

> ccam next ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯ ನಂತರದ ಖಾತೆಯಾಗಿ Claude Code ಅನ್ನು ತೆರೆಯುತ್ತದೆ; --auto ಅತಿ ಕಡಿಮೆ 5 ಗಂಟೆಯ ಬಳಕೆಯ ಖಾತೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತದೆ ಮತ್ತು --continue ಸಂಭಾಷಣೆಯನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.

Source: https://ccam.dev/kn/features/next/ · Updated 2026-10-19

`ccam next` ನೀವು ಹೆಸರಿಸದೆಯೇ ಇನ್ನೊಂದು ಖಾತೆಯಾಗಿ Claude Code ಅನ್ನು ತೆರೆಯುತ್ತದೆ. ಒಂದು ಖಾತೆ ತನ್ನ ಬಳಕೆಯ ಮಿತಿಯನ್ನು ತಲುಪಿದಾಗ ಇದನ್ನು ಬಳಸಿ: ಸಾಮಾನ್ಯ `ccam next` ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯ ನಂತರದ ಖಾತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, `--auto` ತನ್ನ 5 ಗಂಟೆಯ ಅವಧಿಯಲ್ಲಿ ಹೆಚ್ಚು ಅವಕಾಶ ಇರುವ ಖಾತೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು `--continue` ಕೊನೆಯ ಸಂಭಾಷಣೆಯನ್ನು ಹೊಸ ಖಾತೆಯಲ್ಲಿ ಮುಂದುವರಿಸುತ್ತದೆ.

## ಬಳಕೆ

```sh
ccam next                       # the account after the one you used last
ccam next --auto                # the account with the lowest 5-hour usage
ccam next --continue            # the next account that shares history, with claude --continue
ccam next -c --auto             # both: lowest usage among accounts sharing history
ccam next -- -p "summarize"     # pass arguments to claude after --
ccam --dry-run next --auto      # print the choice and the command, start nothing
```

```console
$ ccam --dry-run next
→ personal → work
CLAUDE_CONFIG_DIR=/home/you/.local/share/ccam/profiles/work /usr/local/bin/claude
```

ccam ಬದಲಾವಣೆಯನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎರರ್‌ನಲ್ಲಿ `→ <from> → <to>` ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ, ನಂತರ `ccam <name>` ಮಾಡುವಂತೆಯೇ ಹೊಸ ಖಾತೆಯಾಗಿ Claude Code ಅನ್ನು ಆರಂಭಿಸುತ್ತದೆ. `<from>` ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆ. `--` ನಂತರದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಬದಲಾವಣೆ ಇಲ್ಲದೆ `claude` ಗೆ ಹೋಗುತ್ತವೆ.

## ಆಯ್ಕೆಗಳು

| ಆಯ್ಕೆ | ಏನು ಮಾಡುತ್ತದೆ | ಡೀಫಾಲ್ಟ್ |
| --- | --- | --- |
| `--auto` | ಅತಿ ಕಡಿಮೆ 5 ಗಂಟೆಯ ಬಳಕೆಯ, ಲಾಗಿನ್ ಆಗಿರುವ ಖಾತೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತದೆ; 100% ತಲುಪಿದ ಖಾತೆಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ | ಆಫ್ |
| `-c`, `--continue` | ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯೊಂದಿಗೆ ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸ ಹಂಚಿಕೊಳ್ಳುವ ಖಾತೆಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುತ್ತದೆ, ಮತ್ತು `claude --continue` ಆರಂಭಿಸುತ್ತದೆ | ಆಫ್ |
| `-- <claude args>` | ccam ನ ಸ್ವಂತ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ನಂತರ `claude` ಗೆ ರವಾನಿಸುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು | ಇಲ್ಲ |
| `--dry-run` | ಪಾಲಿಸಲಾಗುತ್ತದೆ: Claude Code ಅನ್ನು ಆರಂಭಿಸದೆ ಅಥವಾ ಆರಂಭವನ್ನು ದಾಖಲಿಸದೆ, `→ <from> → <to>` ಮತ್ತು ರನ್ ಮಾಡಲಿದ್ದ ಕಮಾಂಡ್ ಲೈನ್ ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ | ಆಫ್ |

`--auto` ಮತ್ತು `--continue` ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ. `--continue` ಇದ್ದಾಗ, `--continue` ಅನ್ನು ನಿಮ್ಮ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಿಗಿಂತ ಮೊದಲು ಇಡಲಾಗುತ್ತದೆ.

## ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ccam ಮೂಲಕ ಆಗುವ ಪ್ರತಿ ಆರಂಭವೂ ಸಮಯವನ್ನು `~/.local/state/ccam/last-used/<name>` ಗೆ ಬರೆಯುತ್ತದೆ. `ccam next` ಈ ಫೈಲ್‌ಗಳನ್ನು ಓದುತ್ತದೆ, ಯಾವ ಖಾತೆಗಳು ಲಾಗಿನ್ ಆಗಿವೆ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಆಯ್ಕೆಮಾಡುತ್ತದೆ.

1. `cli.candidates` `config.toml` ನಿಂದ ಪ್ರತಿ ಖಾತೆಗೆ ಒಂದು `next.Candidate` ರಚಿಸುತ್ತದೆ: ಖಾತೆ, ಅದರ ಕೊನೆಯ ಆರಂಭದ ಸಮಯ (`launcher.LastUsed`) ಮತ್ತು ಅದಕ್ಕೆ ಲಾಗಿನ್ ಇದೆಯೇ (`creds.Has`: ಓದಬಹುದಾದ `.credentials.json`, ಅಥವಾ macOS ನಲ್ಲಿ ಒಂದು Keychain ಐಟಂ).
2. `--auto` ಇಲ್ಲದಿದ್ದರೆ, `next.Rotate` ಖಾತೆಗಳನ್ನು ಸ್ಲಾಟ್ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರ ವಿಂಗಡಿಸಿ, ಇತ್ತೀಚೆಗೆ ಆರಂಭಿಸಿದ ಖಾತೆಯನ್ನು ಹುಡುಕುತ್ತದೆ. ನೀವು ಬದಲಾಯಿಸುತ್ತಿರುವುದು ಆ ಖಾತೆಯಿಂದ. ಯಾವ ಖಾತೆಯನ್ನೂ ಇನ್ನೂ ಆರಂಭಿಸಿಲ್ಲದಿದ್ದರೆ, ಅದು ಅತಿ ಕಡಿಮೆ ಸ್ಲಾಟ್.
3. ಅಲ್ಲಿಂದ ಅದು ಸ್ಲಾಟ್ ಕ್ರಮದಲ್ಲಿ ಮುಂದೆ ಸಾಗುತ್ತದೆ, ಕೊನೆಯ ಸ್ಲಾಟ್‌ನಿಂದ ಮತ್ತೆ ಮೊದಲನೆಯದಕ್ಕೆ ಸುತ್ತಿ ಬರುತ್ತದೆ, ಮತ್ತು ಲಾಗಿನ್ ಆಗಿರುವ ಮೊದಲ ಖಾತೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
4. `launcher.LaunchWith` ಆಯ್ಕೆಯಾದ ಖಾತೆಯನ್ನು `ccam <name>` ಮಾಡುವಂತೆಯೇ ಸಿದ್ಧಪಡಿಸಿ ಆರಂಭಿಸುತ್ತದೆ: ಖಾತೆಯ ಲಿಂಕ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, MCP ಹಂಚಿಕೆಯನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ, ಸೆಷನ್ ಅನ್ನು ನೋಂದಾಯಿಸುತ್ತದೆ ಮತ್ತು `syscall.Exec` ಮೂಲಕ ccam ನ ಜಾಗದಲ್ಲಿ `claude` ಅನ್ನು ತರುತ್ತದೆ.

ಈ ಸಾಗುವಿಕೆ ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯಿಂದ ಆರಂಭವಾಗಿ, ಅದರ ನಂತರ ಲಾಗಿನ್ ಆಗಿರುವ ಮೊದಲ ಖಾತೆಯಲ್ಲಿ ನಿಲ್ಲುತ್ತದೆ:

`work` ಅನ್ನು ಇತ್ತೀಚೆಗೆ ಆರಂಭಿಸಲಾಗಿತ್ತು, ಹೀಗಾಗಿ ಸಾಗುವಿಕೆ ಅದರ ನಂತರದಿಂದ ಆರಂಭವಾಗುತ್ತದೆ. `side` ಗೆ ಲಾಗಿನ್ ಇಲ್ಲ, ಅದನ್ನು ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ, ಮತ್ತು `lab` ಆಯ್ಕೆಯಾಗುತ್ತದೆ. `lab` ಕೂಡ ಲಾಗ್ ಔಟ್ ಆಗಿದ್ದರೆ, ಸಾಗುವಿಕೆ ಸುತ್ತಿ `personal` ಗೆ ಬರುತ್ತಿತ್ತು (ಚಿತ್ರದಲ್ಲಿನ `% len`). ರೊಟೇಶನ್ ನೀವು ಆರಂಭಿಸಿದ ಖಾತೆಯನ್ನು ಎಂದಿಗೂ ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ: ಲಾಗಿನ್ ಆಗಿರುವ ಇನ್ನೊಂದು ಖಾತೆ ಇಲ್ಲದಿದ್ದರೆ, ಅದು ದೋಷದೊಂದಿಗೆ ನಿಲ್ಲುತ್ತದೆ.

### --auto

`--auto` ಸ್ಲಾಟ್ ಕ್ರಮದ ಬದಲು ಬಳಕೆಯ ಆಧಾರದಲ್ಲಿ ನಿರ್ಧರಿಸುತ್ತದೆ. `cli.pickAuto` ಲಾಗಿನ್ ಆಗಿರುವ ಖಾತೆಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ, `ccam usage` ಬಳಸುವ ಅದೇ `Fetcher.FetchAll` ಮೂಲಕ ಅವೆಲ್ಲದರ ಬಳಕೆಯನ್ನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಕೇಳುತ್ತದೆ, ಮತ್ತು `usage.Best()` ಗೆ ಆಯ್ಕೆಮಾಡಲು ಬಿಡುತ್ತದೆ:

`usage.Best()` ಅತಿ ಕಡಿಮೆ 5 ಗಂಟೆಯ ಶೇಕಡಾವಾರನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು 100% ತಲುಪಿದ ಅಥವಾ 5 ಗಂಟೆಯ ಬಳಕೆ ತಿಳಿಯದ ಖಾತೆಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಹುಡುಕಾಟವು `ccam usage` ನ ನಿಯಮಗಳನ್ನು ಪಾಲಿಸುತ್ತದೆ: 60 ಸೆಕೆಂಡ್‌ಗಿಂತ ಹೊಸ ಸಂಖ್ಯೆಗಳನ್ನು ಮತ್ತೆ ಬಳಸಲಾಗುತ್ತದೆ, ಪ್ರತಿ ಖಾತೆಗೆ 3 ಸೆಕೆಂಡ್ ಇರುತ್ತದೆ, ಮತ್ತು ಉತ್ತರಿಸದ ಅಥವಾ ಲಾಗಿನ್ ಅವಧಿ ಮುಗಿದ ಖಾತೆಯನ್ನು ಅದರ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳಿಂದ ನಿರ್ಣಯಿಸಲಾಗುತ್ತದೆ. ರೀಸೆಟ್ ಸಮಯ ಕಳೆದಿರುವ ಉಳಿಸಿದ ಅವಧಿಯನ್ನು 0% ಎಂದು ಎಣಿಸಲಾಗುತ್ತದೆ, ಹೀಗಾಗಿ ನಂತರ ಅವಧಿ ರೀಸೆಟ್ ಆಗಿರುವ ಖಾತೆಯನ್ನು ಕಡೆಗಣಿಸಲಾಗುವುದಿಲ್ಲ. `--auto` ಎಂದಿಗೂ ಟೋಕನ್‌ಗಳನ್ನು ನವೀಕರಿಸುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯ ರೊಟೇಶನ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯಲ್ಲೇ ಇನ್ನೂ ಹೆಚ್ಚು ಅವಕಾಶವಿದ್ದರೆ `--auto` ಅದನ್ನೇ ಆಯ್ಕೆಮಾಡಬಹುದು.

### --continue

Claude Code ನ `--continue` ಈಗಿನ ಫೋಲ್ಡರ್‌ನ ಇತ್ತೀಚಿನ ಸಂಭಾಷಣೆಯನ್ನು ತೆರೆಯುತ್ತದೆ; ಹೊಸ ಖಾತೆಗೆ ಆ ಸಂಭಾಷಣೆ ಕಾಣಿಸಿದರೆ ಮಾತ್ರ ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ `--continue` ಇದ್ದಾಗ, ccam ನೀವು ಕೊನೆಯದಾಗಿ ಬಳಸಿದ ಖಾತೆಯ ಅದೇ `history` ಗುಂಪಿನಲ್ಲಿರುವ ಖಾತೆಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುತ್ತದೆ, ನಂತರ `--continue` ಅನ್ನು ನಿಮ್ಮ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಮುಂದೆ ಇಡುತ್ತದೆ. ಇತಿಹಾಸ `local` ಆಗಿರುವ ಖಾತೆಗಳು ಯಾರೊಂದಿಗೂ ಹಂಚಿಕೊಳ್ಳುವುದಿಲ್ಲ, ಹೀಗಾಗಿ ಅಂತಹ ಖಾತೆಯಿಂದ `--continue` ಯಾವಾಗಲೂ ವಿಫಲವಾಗುತ್ತದೆ. ಮೊದಲು `ccam share <name> --history on` ಮೂಲಕ ಹಂಚಿಕೆಯನ್ನು ಆನ್ ಮಾಡಿ ([ಹಂಚಿಕೆ](https://ccam.dev/kn/docs/sharing.md) ನೋಡಿ).

## ಸುರಕ್ಷತೆ ಮತ್ತು ವಿಶೇಷ ಸಂದರ್ಭಗಳು

- ಲಾಗಿನ್ ಇಲ್ಲದ ಖಾತೆಗಳನ್ನು ಎಂದಿಗೂ ಆಯ್ಕೆಮಾಡುವುದಿಲ್ಲ. ಲಾಗಿನ್ ಆಗಿರುವ ಇನ್ನೊಂದು ಖಾತೆ ಇಲ್ಲದಿದ್ದರೆ, ಸಾಮಾನ್ಯ `ccam next` `no logged-in account other than <name>` ಎಂದು ನಿಲ್ಲುತ್ತದೆ.
- `--continue` ಇದ್ದು ಯಾವ ಖಾತೆಯೂ ಇತಿಹಾಸ ಹಂಚಿಕೊಳ್ಳದಿದ್ದಾಗ: `` no other account shares conversation history with <name>. Turn it on with `ccam share <name> --history on` ``.
- `--auto` ಇದ್ದು ಲಾಗಿನ್ ಆಗಿರುವ ಖಾತೆ ಇಲ್ಲದಿದ್ದಾಗ: `no logged-in account to pick`. ಪ್ರತಿ ಖಾತೆಯೂ ತುಂಬಿದ್ದಾಗ ಅಥವಾ ಅದರ ಬಳಕೆ ತಿಳಿಯದಿದ್ದಾಗ: `` no account with known usage and headroom (see `ccam usage`) ``.
- `--dry-run` ಇದ್ದರೂ `--auto` ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಅದು ಓದುತ್ತದೆ ಅಷ್ಟೇ, ಮತ್ತು ಟೋಕನ್ ಫೈಲ್‌ಗಳಿಗೆ ಎಂದಿಗೂ ಬರೆಯುವುದಿಲ್ಲ.
- ಆಯ್ಕೆಯಾದ ಖಾತೆ `ccam <name>` ನ ಅದೇ ಹಾದಿಯಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ, ಹೀಗಾಗಿ ಅದೇ ಪರಿಶೀಲನೆಗಳು ಅನ್ವಯವಾಗುತ್ತವೆ; ಅದೇ ಇತಿಹಾಸ ಹಂಚಿಕೊಳ್ಳುವ ಇನ್ನೊಂದು Claude Code ಈ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿದ್ದಾಗ ಬರುವ ಎಚ್ಚರಿಕೆಯೂ ಸೇರಿ.
- Claude Code ನಿಜವಾಗಿ ಆರಂಭವಾದಾಗ ಮಾತ್ರ `last-used` ಬರೆಯಲಾಗುತ್ತದೆ. `--dry-run` ಅದನ್ನು ಮುಟ್ಟುವುದಿಲ್ಲ, ಹೀಗಾಗಿ ಡ್ರೈ ರನ್ ರೊಟೇಶನ್ ಅನ್ನು ಮುಂದಕ್ಕೆ ಸರಿಸುವುದಿಲ್ಲ.

## ಸಂಬಂಧಿತ

- [ಬಳಕೆಯ ಮಿತಿಗಳು](https://ccam.dev/kn/features/usage.md)
- [ಬಳಕೆಯ ಮಿತಿಗಳು ಮತ್ತು ಖಾತೆ ಬದಲಾವಣೆ](https://ccam.dev/kn/docs/usage-limits.md)
- [MCP ಸರ್ವರ್‌ಗಳು, ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮತ್ತು ಇತಿಹಾಸವನ್ನು ಹಂಚಿಕೊಳ್ಳಿ](https://ccam.dev/kn/docs/sharing.md)
- [ಬಳಕೆಯ ಮಿತಿಯ ಕಾರ್ಯವಿಧಾನ](https://ccam.dev/kn/guides/usage-limit-workflow.md)