AI-translated from English; not yet reviewed by a fluent editor.

# Claude Code సెషన్ ప్రారంభానికి పరిమిత ప్రాజెక్ట్ సందర్భ hook జోడించండి

> ప్రస్తుత Git బ్రాంచ్‌ను Claude Code సందర్భంలో చేర్చే చిన్న ప్రాజెక్ట్ SessionStart hook అమర్చండి. నేరుగా వచ్చే అవుట్‌పుట్, ప్రారంభం, పునఃప్రారంభం, వైఫల్య ప్రవర్తనను తనిఖీ చేయండి.

By BIG CHANGE Editorial

Published: 2026-10-20T00:22:54.831Z
Updated: 2026-10-20T00:22:54.831Z
Canonical: https://bigchange.ai/blog/claude-code-session-start-branch-context-hook-guide

![Conceptual charcoal illustration of an unbranded desktop monitor with one short orange stroke above two soft charcoal strokes; a keyboard rests in front.](https://bigchange.ai/api/media/file/claude-code-session-start-context-hero-v2.png)
AI-generated conceptual illustration by BIG CHANGE; no actual Claude Code interface, hook execution or model result is depicted.

Claude Code hook అనేది సెషన్‌లో నిర్దిష్ట సమయంలో యాప్ నడిపే కమాండ్. ఈ మార్గదర్శి ప్రాజెక్ట్ పరిధిలో ఒక `SessionStart` hook జోడిస్తుంది. అది ప్రస్తుత Git బ్రాంచ్ చదివి సంభాషణను ప్రారంభించినప్పుడు లేదా కొనసాగించినప్పుడు చిన్న సందర్భ పంక్తి ఇస్తుంది. ఇది [Anthropic ప్రస్తుత hook సూచన పత్రాన్ని](https://code.claude.com/docs/en/hooks) అనుసరిస్తుంది; దాన్ని 2026 అక్టోబర్ 19న తనిఖీ చేశాం. BIG CHANGE Nodeతో స్క్రిప్ట్‌ను నేరుగా, సెట్టింగ్‌ల JSONను కూడా తనిఖీ చేసింది; Claude Code hook నడపలేదు లేదా మోడల్ సమాధానం పరీక్షించలేదు.

## ముఖ్యమైన మార్పు

- **ఏం మారింది:** ఈ ప్రాజెక్ట్ `SessionStart` hook Claude Code సంభాషణను ప్రారంభించినప్పుడు లేదా కొనసాగించినప్పుడు చిన్న Git బ్రాంచ్ పంక్తిని ఇస్తుంది.
- **ఇది ఎందుకు ముఖ్యం:** ప్రతిసారి చేతితో అతికించకుండానే ప్రారంభం లేదా పునఃప్రారంభంలో ప్రస్తుత బ్రాంచ్ సెషన్ సందర్భానికి చేరుతుంది.
- **గమనించాల్సింది:** సందర్భం నియమాన్ని అమలు చేయదు, మోడల్ సమాధానానికి హామీ ఇవ్వదు. మీ నమ్మకమైన ప్రాజెక్ట్‌లో ప్రారంభం, పునఃప్రారంభం సమయంలో అది నిజంగా అందుతుందో తనిఖీ చేయండి.

## అమర్చే ముందు

మార్చేందుకు మీకు అనుమతి ఉన్న Git ప్రాజెక్ట్ వాడండి. ఒకే టెర్మినల్‌లో Claude Code, Node.js, Git అందుబాటులో ఉండాలి; ప్రాజెక్ట్‌లోని `.claude/settings.json` ఫైల్ మార్చేందుకు అనుమతి కావాలి. తనిఖీ చేయండి: `node --version`, `git --version` , `claude --version`. సిద్ధం చేసిన కంప్యూటర్‌లో Claude Code 2.1.301, Node 24.19.0 ఉన్నాయి; ఇవి గమనించిన వెర్షన్లు, కనీస అవసరాలు కావు.

**మోడల్‌కు పంపేముందు బ్రాంచ్ పేరు పరిశీలించండి.** బ్రాంచ్‌లో క్లయింట్, టికెట్ లేదా ఘటన పేరు ఉండవచ్చు. అక్షరాలను వడపోయడం, వాక్యాన్ని చిన్నది చేయడం ఆ అర్థాన్ని తొలగించవు. బ్రాంచ్ పేరు మోడల్ సందర్భానికి ఆమోదించబడితేనే ఉదాహరణ అమర్చండి. లేకపోతే అనుమతించిన సున్నితేతర స్థితిని చూపేలా స్క్రిప్ట్ మార్చి, అమర్చే ముందు మార్పును సమీక్షించండి. [Anthropic డేటా వినియోగ పత్రాలు](https://code.claude.com/docs/en/data-usage) సేవలో డేటా నిర్వహణను వివరిస్తాయి; మీ ప్రాజెక్ట్ అనుమతులనూ వర్తింపజేయండి.

Hook కమాండ్‌లు మీ వినియోగదారు అధికారాలతో నడుస్తాయి. ప్రారంభించే ముందు ఇప్పటికే ఉన్న ప్రాజెక్ట్, వినియోగదారు hookలు, సంస్థ విధానం, పూర్తి స్క్రిప్ట్ తనిఖీ చేయండి. ప్రాజెక్ట్ సెట్టింగ్‌లను రిపోజిటరీలో కమిట్ చేయవచ్చు; `.claude/settings.local.json` స్థానికంగా ఉంటుంది. కాన్ఫిగరేషన్ ఆ ప్రాజెక్ట్‌కు పరిమితం కావడానికి ఈ ఉదాహరణ ప్రాజెక్ట్ సెట్టింగ్‌ల ఫైల్ వాడుతుంది.

## రెండు ఫైళ్లు అమర్చండి

1. ప్రాజెక్ట్‌లో `.claude/hooks/` సృష్టించండి. ఈ బ్లాక్ మొత్తాన్ని `.claude/hooks/session-context.cjs`గా భద్రపరచండి.

```javascript
'use strict';

const { execFileSync } = require('node:child_process');

const project = process.env.CLAUDE_PROJECT_DIR;
if (!project) {
  process.stderr.write('CLAUDE_PROJECT_DIR is unavailable\n');
  process.exit(1);
}

try {
  const raw = execFileSync('git', ['-C', project, 'branch', '--show-current'], {
    encoding: 'utf8',
    timeout: 1500,
    maxBuffer: 4096,
    stdio: ['ignore', 'pipe', 'pipe'],
  }).trim();
  const branch = raw ? raw.replace(/[^A-Za-z0-9._/-]/g, '_').slice(0, 80) : 'detached HEAD';
  process.stdout.write(`Current project branch: ${branch}\n`);
} catch {
  process.stderr.write('Could not read the project branch; check Git and project path\n');
  process.exit(1);
}
```

Git చైల్డ్ ప్రాసెస్‌కు 1.5 సెకన్ల పరిమితి, 4,096 బైట్ల అవుట్‌పుట్ బఫర్ ఉన్నాయి. detached HEADలోలాగా బ్రాంచ్ ఫలితం ఖాళీ అయితే అది `detached HEAD` అవుతుంది. ప్రాజెక్ట్ పాత్ లేకపోవడం లేదా Git వైఫల్యంతో చిన్న stderr నిర్ధారణ, ఎగ్జిట్ కోడ్ 1 వస్తాయి.

2. ఇప్పటికే ఉన్న మీ `.claude/settings.json` తెరవండి. కింద ఉన్న `hooks.SessionStart` ఎంట్రీని ఇతర సెట్టింగ్‌లు, hook సమూహాలతో కలపండి; పాత ఎంట్రీలు ఉంచండి. బ్లాక్ సమీక్షించిన ప్యాకెట్‌లోని పూర్తి `settings.example.json` చూపుతుంది. ఫైల్‌లో ఇప్పటికే `SessionStart` ఎంట్రీలు ఉంటే వాటి అరే మార్చకుండా ఈ సమూహాన్ని అందులో జోడించండి.

```json
{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup|resume",
        "hooks": [
          {
            "type": "command",
            "command": "node",
            "args": ["${CLAUDE_PROJECT_DIR}/.claude/hooks/session-context.cjs"],
            "timeout": 5
          }
        ]
      }
    ]
  }
}
```

Matcher కొత్త, పునఃప్రారంభించిన సెషన్‌లను కవర్ చేస్తుంది. Anthropic `clear`, `compact` , `fork` లను కూడా `SessionStart` మూలాలుగా పేర్కొంటుంది; ఉదాహరణ వాటిని ఉద్దేశపూర్వకంగా వదిలేస్తుంది. `args` ఫీల్డ్ exec రూపాన్ని ఎంచుకుంటుంది: Claude Code `node` ను పరిష్కరించిన ప్రాజెక్ట్ స్క్రిప్ట్ పాత్ ఒకే ఆర్గ్యుమెంట్‌గా ఇచ్చి పిలుస్తుంది; shell quoting లేదా parsing ఉండదు. Windowsలో `node.exe` నిజమైన executableగా లభించాలి; `.cmd` shim exec రూపానికి సరిపోదు. కమాండ్‌కు ఐదు సెకన్ల hook పరిమితి, స్క్రిప్ట్‌లోని 1.5 సెకన్ల Git పరిమితికి వేరు.

## ముందు స్క్రిప్ట్, తర్వాత Claude Code తనిఖీ చేయండి

3. Claude Code తెరవేముందు ప్రాజెక్ట్ టెర్మినల్‌లో స్క్రిప్ట్ నడిపి అవుట్‌పుట్‌ను Gitతో పోల్చండి. PowerShellలో:

```powershell
$env:CLAUDE_PROJECT_DIR = (Get-Location).Path
node .claude/hooks/session-context.cjs
git branch --show-current
```

Bashలో:

```bash
CLAUDE_PROJECT_DIR="$PWD" node .claude/hooks/session-context.cjs
git branch --show-current
```

స్క్రిప్ట్ stdoutలో సరిగ్గా ఒక్క పంక్తి రావాలి: `Current project branch: BRANCH`, ఇందులో `BRANCH` అనేది స్క్రిప్ట్ అక్షర ఫిల్టర్, 80-అక్షర పరిమితి తర్వాత Git ఫలితం. Detached HEADలో `Current project branch: detached HEAD` ముద్రిస్తుంది. ప్రత్యక్ష తనిఖీ ఈ టెర్మినల్‌లో స్థానిక స్క్రిప్ట్ పనిచేస్తుందని మాత్రమే నిరూపిస్తుంది. మా సిద్ధత తనిఖీలో సాధారణ బ్రాంచ్ Gitతో సరిపోయింది; లేని, చెల్లని ప్రాజెక్ట్ పాత్‌లు ఖాళీ stdout, stderr నిర్ధారణ, ఎగ్జిట్ 1 ఇచ్చాయి. పొడవైన పేరు పరిమితి, detached HEAD ప్రత్యామ్నాయాన్ని సోర్స్‌లో చూశాం, కానీ ఆ సందర్భాలు నడపలేదు.

4. నమ్మకమైన ప్రాజెక్ట్‌లో కొత్త **ఇంటరాక్టివ్** Claude Code ప్రాసెస్‌ను `claude --debug-file STARTUP_PRIVATE_LOG`తో ప్రారంభించి, మీ నియంత్రణలోని ప్రైవేట్ పాత్ వాడండి. workspace trust అంగీకరించే ముందు ప్రాజెక్ట్, వినియోగదారు hookలు సమీక్షించండి. debug లాగ్‌లో `SessionStart` ఈవెంట్, మూలం `startup`, ఎంచుకున్న స్క్రిప్ట్ పాత్, ఎగ్జిట్ స్థితి, అవుట్‌పుట్ నిర్వహణ చూడండి. టూల్ వాడటం లేదా Git స్వతంత్రంగా చదవటం అనుమతించకుండా Claudeకు అందిన బ్రాంచ్ సందర్భం ఏమిటో అడగండి. సమాధానం, debug రికార్డును నేర ఫలితంతో పోల్చండి. Hook stdout Claude సందర్భంలో చేరుతుంది; కనిపించే UIలో సందేశంగా వస్తుందని హామీ లేదు.
5. ఆ సెషన్ నుంచి బయటకు రండి. వేరే ప్రాసెస్‌లో `claude --debug-file RESUME_PRIVATE_LOG --resume`తో కొనసాగించి, తర్వాత `SessionStart` `resume` ఈవెంట్ తనిఖీ చేయండి; టూల్ లేదా Git మళ్లీ చదవకుండా ప్రశ్న తనిఖీ పునరావృతం చేయండి. రెండు debug లాగ్‌లను ప్రైవేట్‌గా ఉంచండి; ప్రాజెక్ట్ వివరాలు బయటపడవచ్చు. ఇంటరాక్టివ్ కాని `-p` లేదా SDK రన్‌లో అదే workspace-trust ప్రశ్న ఉండదు, రిపోజిటరీ hookలు స్వయంచాలకంగా నడవవచ్చు. కాబట్టి ఈ తనిఖీకి ఇంటరాక్టివ్ పద్ధతి వాడండి. ఫైల్ వాచర్ సాధారణంగా hook సెట్టింగ్‌ల మార్పులను తీసుకుంటుందని Anthropic చెబుతుంది; కానీ కొత్త ప్రాసెస్‌తో ప్రారంభం, పునఃప్రారంభ పరీక్ష మరింత స్పష్టంగా ఉంటుంది.

తర్వాత సాధారణ ప్రాజెక్ట్ పనిలో బ్రాంచ్ మారితే ప్రత్యక్ష తనిఖీ, కొత్త సెషన్ పునరావృతం చేసి పంక్తి మారుతుందో చూడండి. ఈ మార్గదర్శి పరీక్షించామని చెప్పటానికే బ్రాంచ్ మార్చవద్దు.

## నడవకపోతే

స్క్రిప్ట్ ప్రత్యక్ష ఫలితంతో మొదలుపెట్టి JSON కలపడం, `SessionStart` స్పెల్లింగ్, `startup|resume` matcher, ప్రాజెక్ట్-రూట్ పాత్, `node` , `git` అందుబాటు, workspace trust, debug లోపాలు తనిఖీ చేయండి. `CLAUDE_PROJECT_DIR` లేకపోతే `CLAUDE_PROJECT_DIR is unavailable` ను stderrలో ముద్రిస్తుంది. తప్పు ప్రాజెక్ట్ పాత్ లేదా Git వైఫల్యం `Could not read the project branch; check Git and project path` ముద్రిస్తుంది. రెండూ ఎగ్జిట్ 1 ఇస్తాయి, సందర్భ పంక్తి ఇవ్వవు. `SessionStart` వైఫల్యం నిర్ధారణ కోసం మాత్రమే, పని అడ్డుకోదు; చర్యకు అడ్డుకట్టగా ఉపయోగపడదు. టూల్ చర్యను నియంత్రించేందుకు Anthropic `PreToolUse` ను పేర్కొంటుంది; అది వేరే ఈవెంట్, విడిగా సమీక్షించిన రూపకల్పన అవసరం.

స్క్రిప్ట్ స్థానిక Git మాత్రమే నడుపుతుంది; నెట్‌వర్క్ అభ్యర్థన లేదా మోడల్ కాల్ చేయదు. Claude Code ప్రారంభం, కొనసాగింపు, ప్రశ్న తనిఖీలు ఖాతా, ప్రొవైడర్ లేదా మోడల్ పరిమితిని వినియోగించవచ్చు; [Anthropic ఖర్చుల మార్గదర్శిలో](https://code.claude.com/docs/en/costs) ప్రస్తుత షరతులు ఉన్నాయి. ఇక్కడ స్థిర ధర లేదా చెల్లించిన సెషన్ పరీక్షను ప్రకటించడం లేదు.

సంభాషణ మొదలయ్యాక వేరే పని కోసం మా [Claude Code సెషన్ సందర్భాన్ని పరిశీలించి కొనసాగించే మార్గదర్శి](https://bigchange.ai/blog/claude-code-session-context-continue-guide) సందర్భ పరిశీలన, కొనసాగింపును వివరిస్తుంది. ఈ ప్రారంభ hook అమర్చదు.

## మూలాలు, మరింత చదవండి

- [Anthropic, Claude Code hook సూచన](https://code.claude.com/docs/en/hooks) — ప్రస్తుత ప్రాథమిక నిర్దేశాన్ని 2026 అక్టోబర్ 19న తనిఖీ చేశాం. ఇది `SessionStart` మూలాలు, matcherలు, exec రూపం `args`, పాత్ placeholderలు, stdout సందర్భం, సెట్టింగ్‌లు మళ్లీ లోడ్ చేయడం, నమ్మకం, debug లాగ్‌లు, అడ్డుకోని వైఫల్యాన్ని వివరిస్తుంది. ఇది పత్రాల సమాచారం, BIG CHANGE hook నడపడం కాదు.
- [Anthropic, hookలతో చర్యలు ఆటోమేట్ చేయండి](https://code.claude.com/docs/en/hooks-guide) — hook అమరిక, పరీక్షకు అధికారిక సూచనలు. పైనున్న నిర్దిష్ట స్క్రిప్ట్, సెట్టింగ్‌లు ఈ మార్గదర్శి కోసం సమీక్షించిన పరిమిత BIG CHANGE ఉదాహరణలు; విక్రేత పరీక్ష ఫలితాన్ని కాపీ చేసినవి కావు.
- [Anthropic, Claude Code అమరిక](https://code.claude.com/docs/en/setup) — ఇన్‌స్టాలేషన్, పర్యావరణ అవసరాలు. ఉదాహరణ వాడేముందు ప్రస్తుత ప్లాట్‌ఫారమ్ సూచనలు చూడండి.
- [Anthropic, Claude Code డేటా వినియోగం](https://code.claude.com/docs/en/data-usage) — బ్రాంచ్ సమాచారాన్ని మోడల్ సందర్భంలో పంపేముందు సమీక్షించాల్సిన ప్రొవైడర్ ప్రస్తుత డేటా నిర్వహణ షరతులు; ప్రాజెక్ట్ అనుమతి వేరే నిర్ణయం.
- [Anthropic, ఖర్చులను సమర్థంగా నిర్వహించండి](https://code.claude.com/docs/en/costs) — ఇంటరాక్టివ్ తనిఖీల కోసం ప్రస్తుత ఖాతా, వినియోగ సూచనలు. స్థానిక Git స్క్రిప్ట్ స్వయంగా మోడల్ లేదా నెట్‌వర్క్ అభ్యర్థన చేయదు.

## Sources

- [Claude Code hook సూచన](https://code.claude.com/docs/en/hooks) — Anthropic ప్రస్తుత ప్రాథమిక మాన్యువల్‌ను 2026 అక్టోబర్ 19 ఆమోదిత స్నాప్‌షాట్‌తో, రచన సమయంలో మళ్లీ తనిఖీ చేశాం. SessionStart startup/resume మూలాలు, matcher అర్థం, exec రూపం command, args, ప్రాజెక్ట్-రూట్ placeholder, సాధారణ stdout సందర్భం, సెట్టింగ్‌ల వాచర్, workspace trust, debug-file పరిశీలన, Windows నిజమైన executable నియమం, అడ్డుకోని SessionStart లోపాలను నిర్ధారిస్తుంది. ఇది ఉత్పత్తి ప్రవర్తన వివరిస్తుంది; BIG CHANGE Claude పిలిచిన hook నడపలేదు. మాన్యువల్‌కు స్థిర సవరణ తేదీ ఇవ్వలేదు.
- [hookలతో చర్యలు ఆటోమేట్ చేయండి](https://code.claude.com/docs/en/hooks-guide) — అధికారిక Anthropic అమరిక, పరీక్ష సూచనలు. పాఠకుని hook కాన్ఫిగరేషన్, నిర్ధారణ ప్రక్రియకు ఆధారం; BIG CHANGE Claude Codeలో ఉదాహరణ నడిపిందనే వాదన కాదు. వ్యాసంలోని ఖచ్చితమైన పరిమిత Node స్క్రిప్ట్, సెట్టింగ్‌లు వేరుగా సమీక్షించిన స్థానిక అమలు ప్యాకెట్ నుంచి వచ్చాయి.
- [Claude Code అధునాతన అమరిక](https://code.claude.com/docs/en/setup) — స్థానిక Claude Code అమరికను తనిఖీ చేసేందుకు అధికారిక ఇన్‌స్టాలేషన్, పర్యావరణ సూచన. సిద్ధతలో 2.1.301 మాత్రమే గమనించాం; ఈ మూలం దానిని కనీస అవసరంగా చేయదు.
- [Claude Code డేటా వినియోగం](https://code.claude.com/docs/en/data-usage) — ఖాతాను బట్టి వర్తించే అధికారిక డేటా నిర్వహణ షరతులు. Git బ్రాంచ్ సమాచారాన్ని మోడల్ సందర్భంలో పెట్టేముందు వీటిని చూడాలని వ్యాసం సూచిస్తుంది. వడపోత, కత్తిరింపు వల్ల బ్రాంచ్ పేరు గోప్యమైన క్లయింట్ లేదా ఘటన వివరాలను బయటపెట్టకుండా ఆపలేవు. సమగ్ర గోప్యత హామీ ఊహించలేదు.
- [ఖర్చులను సమర్థంగా నిర్వహించండి](https://code.claude.com/docs/en/costs) — ఇంటరాక్టివ్ ప్రారంభం/కొనసాగింపు ప్రశ్న తనిఖీలకు అధికారిక ఖాతా, మోడల్ వినియోగ సూచనలు. స్థానిక స్క్రిప్ట్ స్వయంగా మోడల్ లేదా నెట్‌వర్క్ అభ్యర్థన చేయదు; నిజమైన Claude సెషన్‌లు ప్లాన్, ప్రొవైడర్ లేదా API పరిమితిని వాడవచ్చు. స్థిర ధర లేదా చెల్లించిన పరీక్ష వాదన లేదు.
- [Claude Code సెషన్ సందర్భాన్ని ఎలా పరిశీలించి కొనసాగించాలి](https://bigchange.ai/blog/claude-code-session-context-continue-guide) — మునుపటి BIG CHANGE వ్యాసం 414ను సందర్భానుకూల అంతర్గత లింక్, సంబంధ వర్గీకరణ కోసం మాత్రమే వాడాం. అది ఉన్న సంభాషణను పరిశీలించి పనిని కొనసాగించడం వివరిస్తుంది; ఈ hook అమలుకు ఆధారం లేదా అదే ఘటనకు నేరుగా తేదీగల మూల కథనం కాదు.