@dev-sergeev/datalab-kit 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## 0.1.1 — 2026-10-01
+
+- Служебный todo и безопасные читающие цепочки с шаблонами файлов больше не требуют подтверждения по правилам набора.
+- Добавлены сессионные команды `/yolo on`, `/yolo off`, `/yolo status`; постоянная настройка YOLO сохранена. Явные запреты и ограничения Plan mode остаются активными.
+- Исправлен разбор имён файлов после `<`, которые могли скрыть изменяющую команду или опасную опцию.
+- Исправлена атрибуция эффектов опасных опций и приоритет пользовательских правил в составных командах.
+- Пользовательские ограничения путей проверяются для файлов, раскрытых shell-шаблонами, включая симлинки и команды после `cd`.
+- Добавлены интеграционные матрицы читающих и изменяющих команд, обновление todo, проверки симлинков, режимов Plan/YOLO и смены сессии.
+
+## 0.1.0 — 2026-09-30
+
+- Первый публичный выпуск набора из восьми дополнений для Pi coding agent.
+- Значения по умолчанию разрешают чтение и требуют подтверждения изменений; пользовательские настройки имеют приоритет.
+- Plan mode контролирует допустимость операций без дополнительных подтверждений набора.
+- Общий предел параллельности субагентов; GigaChat обновляется независимо от версии набора.

package/README.md

@@ -1,6 +1,6 @@
 # Datalab Kit
 
-Готовый набор дополнений для **Pi coding agent**. Пакет предназначен для публикации как `@dev-sergeev/datalab-kit`.
+Готовый набор дополнений для **Pi coding agent**, опубликованный как `@dev-sergeev/datalab-kit`. История выпусков — в [CHANGELOG](CHANGELOG.md).
 
 ## Установка
 
@@ -42,6 +42,8 @@ pi install ./dev-sergeev-datalab-kit-0.1.0.tgz
 ## Значения по умолчанию
 
 - Чтение файлов, просмотр каталогов и поиск разрешены в любых папках.
+- Служебный `todo` создаёт и обновляет список задач сессии без подтверждения.
+- Читающие цепочки вроде `grep foo *.ts | head`, регулярные выражения, комментарии, чтение через `<`, объединение stderr со stdout и вывод в `/dev/null` не требуют подтверждения. У команд с изменяющими опциями шаблоны файлов разрешаются с фиксированным префиксом пути или после `--`, когда это исключает внедрение опций из имён файлов.
 - Изменения через `write`, `edit`, `npm install`, `git commit` требуют подтверждения.
 - `rm`, `hadoop`, `hdfs`, неизвестные команды и любой удалённый `curl` требуют подтверждения.
 - `curl` к `localhost`, `127.0.0.1` и `::1` разрешён только для GET/HEAD. Для автоматически разрешённых запросов отключаются `.curlrc` и прокси; перенаправления, вывод в файл и изменяющие запросы требуют подтверждения.
@@ -53,6 +55,12 @@ pi install ./dev-sergeev-datalab-kit-0.1.0.tgz
 
 В **Plan mode** допустимые инструменты и команды проверяет pi-plan-mode без дополнительных подтверждений по правилам набора. Явные пользовательские `ask` и `deny` продолжают действовать; некорректная конфигурация разрешений также не обходится. После выхода из Plan mode или перехода к реализации правила набора снова действуют. Это поведение сохраняется при восстановлении сессии и смене ветки. Plan mode допускает некоторые тесты и проверки, которые могут создавать артефакты.
 
+## YOLO
+
+`/yolo on` отключает запросы подтверждения в текущей сессии; в статусе появляется `yolo`. `/yolo off` возвращает подтверждения, а `/yolo status` показывает эффективный режим. Команды не переписывают настройки; новая или повторно открытая сессия использует постоянную настройку.
+
+YOLO автоматически разрешает любые `ask`, включая явные пользовательские запросы и запросы из-за некорректной конфигурации. Явные `deny` и ограничения Plan mode сохраняются. Для постоянного включения откройте `/permission-system` → **YOLO mode** или задайте `"yoloMode": true` в конфигурации permission-system. Сессионный `/yolo off` временно выключает и постоянно включённый YOLO.
+
 ## Обновление и ограничение Pi 0.85.1
 
 После первого запуска Pi:

package/dist/defaults.d.ts

@@ -6,10 +6,17 @@ export declare const kitPermission: {
     readonly grep: "allow";
     readonly find: "allow";
     readonly path_read: "allow";
-    readonly path_write: "ask";
+    readonly path_write: {
+        readonly '*': "ask";
+        readonly '/dev/null': "allow";
+    };
     readonly external_directory_read: "allow";
-    readonly external_directory_write: "ask";
+    readonly external_directory_write: {
+        readonly '*': "ask";
+        readonly '/dev/null': "allow";
+    };
     readonly bash: "ask";
+    readonly todo: "allow";
     readonly subagent: "allow";
     readonly get_subagent_result: "allow";
     readonly steer_subagent: "allow";

package/dist/defaults.js

@@ -1,7 +1,7 @@
 /** A lower policy layer; explicit global/project/agent rules override it. */
 export const kitPermission = {
     '*': 'ask', read: 'allow', ls: 'allow', grep: 'allow', find: 'allow',
-    path_read: 'allow', path_write: 'ask',
-    external_directory_read: 'allow', external_directory_write: 'ask',
-    bash: 'ask', subagent: 'allow', get_subagent_result: 'allow', steer_subagent: 'allow',
+    path_read: 'allow', path_write: { '*': 'ask', '/dev/null': 'allow' },
+    external_directory_read: 'allow', external_directory_write: { '*': 'ask', '/dev/null': 'allow' },
+    bash: 'ask', todo: 'allow', subagent: 'allow', get_subagent_result: 'allow', steer_subagent: 'allow',
 };

package/dist/read-policy.d.ts

@@ -1,5 +1,11 @@
+export declare function isKnownReadCommand(name: string): boolean;
 export declare function isReadOnlyWords(words: readonly string[]): boolean;
 export declare function isReadOnlyCommand(command: string): boolean;
+/** Only syntax whose effects can be decided by the individual command gates. */
+export declare function inspectionCommands(command: string): string[] | undefined;
+/** Expand accepted shell globs for path checks without executing the command. */
+export declare function shellGlobTokens(command: string): string[];
+export declare function expandShellGlob(pattern: string, cwd: string): string[];
 export declare function isReadOnlyCommandInput(input: unknown): boolean;
 /** Local read requests must not inherit a proxy, curlrc mutation or redirect. */
 export declare function normalizeLocalReadCurl(command: string): string | undefined;

package/dist/read-policy.js

@@ -1,12 +1,27 @@
-/** Conservative shell parsing: unfamiliar syntax is confirmed, never executed here. */
+import { globSync } from 'node:fs';
+import { resolve } from 'node:path';
+/** Parse inspection syntax without executing expansions or subprocesses. */
 function shellCommands(input) {
+    if (input.includes('\u0000'))
+        return undefined;
     const commands = [];
     let words = [];
     let word = '';
+    let glob = false;
     let started = false;
+    let inputTarget = false;
     let quote;
-    const pushWord = () => { if (started)
-        words.push(word); word = ''; started = false; };
+    const pushWord = () => {
+        if (started) {
+            if (inputTarget)
+                inputTarget = false;
+            else
+                words.push({ text: word, glob });
+        }
+        word = '';
+        glob = false;
+        started = false;
+    };
     const pushCommand = () => { pushWord(); if (words.length)
         commands.push(words); words = []; };
     for (let index = 0; index < input.length; index++) {
@@ -16,11 +31,27 @@ function shellCommands(input) {
                 quote = undefined;
                 continue;
             }
-            if (quote === '"' && (char === '$' || char === '`' || char === '\\'))
+            if (quote === '"' && (char === '$' || char === '`'))
                 return undefined;
+            if (quote === '"' && char === '\\') {
+                const next = input[++index];
+                if (next === undefined)
+                    return undefined;
+                if (next !== '\n')
+                    word += ['$', '`', '"', '\\'].includes(next) ? next : '\\' + next;
+                continue;
+            }
             word += char;
             continue;
         }
+        if (!started) {
+            // Descriptor duplication and discarding output touch no regular file.
+            const redirect = input.slice(index).match(/^(?:[012])?(?:[<>]&[012]|>[ \t]*\/dev\/null)(?=$|[\s|;&])/);
+            if (redirect) {
+                index += redirect[0].length - 1;
+                continue;
+            }
+        }
         if (char === "'" || char === '"') {
             quote = char;
             started = true;
@@ -28,15 +59,40 @@ function shellCommands(input) {
         }
         if (char === '\\') {
             const next = input[++index];
-            if (next === undefined || next === '\n')
+            if (next === undefined)
                 return undefined;
-            word += next;
-            started = true;
+            if (next !== '\n') {
+                word += next;
+                started = true;
+            }
             continue;
         }
-        if ('<>$`(){}#*?['.includes(char) || char === '\u0000')
+        if (char === '#' && !started) {
+            if (inputTarget)
+                return undefined;
+            while (index < input.length && input[index] !== '\n')
+                index++;
+            pushCommand();
+            continue;
+        }
+        if (char === '<') {
+            // A single file input redirect only reads; heredocs/process substitutions
+            // can execute code and are deliberately left to confirmation.
+            if (input[index + 1] === '<' || input[index + 1] === '(')
+                return undefined;
+            pushWord();
+            if (inputTarget)
+                return undefined;
+            inputTarget = true;
+            continue;
+        }
+        if ('>$`(){}'.includes(char) || char === '\u0000')
             return undefined;
+        if ('*?['.includes(char))
+            glob = true;
         if (char === '&') {
+            if (inputTarget && !started)
+                return undefined;
             if (input[index + 1] !== '&')
                 return undefined;
             index++;
@@ -44,6 +100,8 @@ function shellCommands(input) {
             continue;
         }
         if (char === '|' || char === ';' || char === '\n') {
+            if (inputTarget && !started)
+                return undefined;
             pushCommand();
             continue;
         }
@@ -57,12 +115,17 @@ function shellCommands(input) {
     if (quote)
         return undefined;
     pushCommand();
-    return commands.length ? commands : undefined;
+    if (inputTarget)
+        return undefined;
+    return commands;
 }
 const readers = new Set(['read', 'cat', 'ls', 'grep', 'egrep', 'fgrep', 'rg', 'find', 'fd',
     'head', 'tail', 'wc', 'stat', 'pwd', 'basename', 'dirname', 'realpath', 'which',
     'diff', 'cmp', 'comm', 'du', 'df', 'md5sum', 'sha1sum', 'sha256sum', 'cksum',
     'whoami', 'id', 'uname', 'uptime', 'ps', 'printenv', 'echo', 'cd', 'sort']);
+export function isKnownReadCommand(name) {
+    return readers.has(name) || name === 'git' || name === 'curl';
+}
 export function isReadOnlyWords(words) {
     const [name, ...args] = words;
     if (!name)
@@ -72,25 +135,78 @@ export function isReadOnlyWords(words) {
             && args.includes('--noproxy') && isLocalReadCurl(args);
     if (name === 'git') {
         return ['status', 'diff', 'log', 'show', 'blame', 'ls-files'].includes(args[0] ?? '')
-            && !args.some(arg => /^--(?:output|ext-diff|textconv)/.test(arg));
+            && !optionWords(args).some(arg => dangerousLongOption(arg, ['--output', '--ext-diff', '--textconv']));
     }
     if (!readers.has(name))
         return false;
     if (name === 'find' && args.some(arg => /^-(?:delete|exec|ok|fprint|fprintf|fls)/.test(arg)))
         return false;
-    if (name === 'fd' && args.some(arg => /^--exec/.test(arg) || /^-[^-]*[xX]/.test(arg)))
+    const options = optionWords(args);
+    if (name === 'fd' && options.some(arg => /^--exec/.test(arg) || /^-[^-]*[xX]/.test(arg)))
         return false;
-    if (name === 'rg' && args.some(arg => /^--pre/.test(arg)))
+    if (name === 'rg' && options.some(arg => /^--pre/.test(arg)))
         return false;
-    if (name === 'sort' && args.some(arg => /^--[oc]/.test(arg) || /^-[^-]*o/.test(arg)))
+    if (name === 'sort' && options.some(arg => dangerousLongOption(arg, ['--output', '--compress-program']) || /^-[^-]*o/.test(arg)))
         return false;
-    if (name === 'diff' && args.some(arg => /^--out/.test(arg)))
+    if (name === 'diff' && options.some(arg => /^--out/.test(arg)))
         return false;
     return true;
 }
+function optionWords(args) {
+    const end = args.indexOf('--');
+    return end < 0 ? args : args.slice(0, end);
+}
+/** GNU tools accept abbreviated long options; harmless complete names stay usable. */
+function dangerousLongOption(arg, names) {
+    const option = arg.split('=', 1)[0];
+    return option.startsWith('--') && names.some(name => name.startsWith(option) || option.startsWith(name));
+}
+function isReadOnlyShellWords(words) {
+    const [head, ...args] = words;
+    if (!head || head.glob || !isReadOnlyWords(words.map(word => word.text)))
+        return false;
+    // Expansion must not introduce write/exec options. A fixed path prefix or
+    // an explicit end-of-options marker keeps glob results in operand position.
+    if (['find', 'fd', 'rg', 'sort', 'diff', 'git', 'curl'].includes(head.text)) {
+        let operandsOnly = false;
+        for (const arg of args) {
+            if (!arg.glob && arg.text === '--')
+                operandsOnly = true;
+            if (!arg.glob)
+                continue;
+            const prefix = arg.text.split(/[*?[]/, 1)[0] ?? '';
+            const fixedPath = prefix.includes('/') && !prefix.startsWith('-');
+            // find expressions remain active after its paths, even with --.
+            if (!fixedPath && (!operandsOnly || head.text === 'find'))
+                return false;
+        }
+    }
+    return true;
+}
 export function isReadOnlyCommand(command) {
     const commands = shellCommands(command);
-    return commands !== undefined && commands.every(isReadOnlyWords);
+    return commands !== undefined && commands.every(isReadOnlyShellWords);
+}
+/** Only syntax whose effects can be decided by the individual command gates. */
+export function inspectionCommands(command) {
+    const commands = shellCommands(command);
+    if (commands === undefined || !commands.every(words => {
+        const head = words[0];
+        return head !== undefined && !head.glob && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(head.text)
+            && words.every(word => !word.glob || !/[\s'"$`\\<>|&;(){}]/.test(word.text));
+    }))
+        return undefined;
+    // Redirection filenames are not argv. Keep quoting and expansion roles when
+    // asking the policy about the actual command, independently of upstream AST.
+    return commands.map(words => words.map(word => word.glob || /^[\w./:@%+=,-]+$/.test(word.text)
+        ? word.text : `'${word.text.replaceAll("'", "'\\''")}'`).join(' '));
+}
+/** Expand accepted shell globs for path checks without executing the command. */
+export function shellGlobTokens(command) {
+    return (shellCommands(command) ?? []).flatMap(words => words.filter(word => word.glob).map(word => word.text));
+}
+export function expandShellGlob(pattern, cwd) {
+    return globSync(pattern, { cwd }).map(path => resolve(cwd, path));
 }
 export function isReadOnlyCommandInput(input) {
     if (typeof input === 'string')
@@ -140,12 +256,15 @@ function isLocalReadCurl(args) {
 }
 /** Local read requests must not inherit a proxy, curlrc mutation or redirect. */
 export function normalizeLocalReadCurl(command) {
+    // Normalization must not erase the caller's redirect semantics.
+    if (/[<>]/.test(command))
+        return undefined;
     const commands = shellCommands(command);
-    if (commands?.length !== 1 || commands[0]?.[0] !== 'curl' || !isLocalReadCurl(commands[0].slice(1)))
+    if (commands?.length !== 1 || commands[0]?.[0]?.text !== 'curl' || !isLocalReadCurl(commands[0].slice(1).map(word => word.text)))
         return undefined;
     const quote = (word) => `'${word.replaceAll("'", "'\\''")}'`;
     return commands.map(words => {
-        const args = words[0] === 'curl' ? ['curl', '-q', '--noproxy', '*', ...words.slice(1)] : words;
+        const args = ['curl', '-q', '--noproxy', '*', ...words.slice(1).map(word => word.text)];
         return args.map(quote).join(' ');
     }).join('');
 }

package/dist/yolo.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+/** Session overrides stay in memory; persistent settings retain their own value. */
+export declare function registerYoloControl(pi: ExtensionAPI, configured: () => boolean): {
+    isEnabled(): boolean;
+    refresh(ctx?: ExtensionContext): void;
+};

package/dist/yolo.js

@@ -0,0 +1,33 @@
+/** Session overrides stay in memory; persistent settings retain their own value. */
+export function registerYoloControl(pi, configured) {
+    let override;
+    let context;
+    const enabled = () => override ?? configured();
+    const refresh = (ctx) => {
+        if (ctx)
+            context = ctx;
+        context?.ui.setStatus('pi-permission-system', enabled() ? 'yolo' : undefined);
+    };
+    pi.on('session_start', (_event, ctx) => {
+        override = undefined;
+        context = ctx;
+    });
+    pi.registerCommand('yolo', {
+        description: 'Set session YOLO: on, off, or status; explicit deny and Plan mode remain active',
+        getArgumentCompletions: prefix => ['on', 'off', 'status'].filter(value => value.startsWith(prefix))
+            .map(value => ({ value, label: value })),
+        handler: async (args, ctx) => {
+            context = ctx;
+            const command = args.trim().toLowerCase() || 'status';
+            if (!['on', 'off', 'status'].includes(command)) {
+                ctx.ui.notify('Usage: /yolo on|off|status', 'warning');
+                return;
+            }
+            if (command !== 'status')
+                override = command === 'on';
+            refresh();
+            ctx.ui.notify(`YOLO ${enabled() ? 'on' : 'off'} (${override === undefined ? 'settings' : 'session'}). Explicit deny and Plan mode remain active.`, 'info');
+        },
+    });
+    return { isEnabled: () => { refresh(); return enabled(); }, refresh };
+}

package/node_modules/@gotgenes/pi-permission-system/src/access-intent/bash/bash-path-resolver.ts

@@ -1,3 +1,5 @@
+// Datalab Kit adaptation
+import { shellGlobTokens, expandShellGlob, isReadOnlyCommand } from "../../../../../../dist/read-policy.js";
 import type { AccessPath } from "#src/access-intent/access-path";
 import {
   mergeTokenEffects,
@@ -152,11 +154,15 @@ export class BashPathResolver {
     for (const salvaged of salvagedRoots) {
       this.walkForCandidates(salvaged, UNKNOWN_BASE, candidates);
     }
+    const globTokens = new Set(shellGlobTokens(rootNode.text));
+    const expandedCandidates = candidates.flatMap(candidate => {
+      if (candidate.base.kind !== 'known' || !globTokens.has(candidate.token)) return [candidate];
+      const cwd = this.normalizer.resolveBase(candidate.base.offset);
+      return [candidate, ...expandShellGlob(candidate.token, cwd).map(token => ({ ...candidate, token }))];
+    });
     return {
-      externalAccesses: this.withWorkdirExternal(
-        this.projectExternalPaths(candidates),
-      ),
-      ruleCandidates: this.projectRuleCandidates(candidates),
+      externalAccesses: this.withWorkdirExternal(this.projectExternalPaths(expandedCandidates)),
+      ruleCandidates: this.projectRuleCandidates(expandedCandidates),
     };
   }
 
@@ -229,7 +235,13 @@ export class BashPathResolver {
       case "redirected_statement":
         return this.walkCurrentShellSequence(node, base, out);
       case "command":
-        tagTokens(collectCommandTokens(node), base, out);
+        const tokens = collectCommandTokens(node);
+        const present = new Set(tokens.map(token => token.token));
+        const globEffect = isReadOnlyCommand(node.text) ? { effect: 'read' as const, source: 'core' as const } : UNPROVEN_EFFECT;
+        tagTokens([
+          ...tokens,
+          ...shellGlobTokens(node.text).filter(token => !present.has(token)).map(token => ({ token, effect: globEffect })),
+        ], base, out);
         return this.foldCd(node, base);
       case "pipeline":
         // tree-sitter-bash mis-groups a redirect-bearing `&&`/`;` list as the

package/node_modules/@gotgenes/pi-permission-system/src/access-intent/bash/command-effects.ts

@@ -1,5 +1,5 @@
 // Datalab Kit adaptation
-import { isReadOnlyWords } from "../../../../../../dist/read-policy.js";
+import { isReadOnlyWords, isKnownReadCommand } from "../../../../../../dist/read-policy.js";
 import { type TokenEffect, UNPROVEN_EFFECT } from "#src/access-intent/effect";
 
 // ── Public surface ─────────────────────────────────────────────────────────
@@ -26,7 +26,7 @@ export function proveCommandEffect(
   headWord: string,
   argWords: readonly string[],
 ): TokenEffect {
-  if (isReadOnlyWords([headWord, ...argWords])) return CORE_READ_EFFECT;
+  if (isKnownReadCommand(headWord)) return isReadOnlyWords([headWord, ...argWords]) ? CORE_READ_EFFECT : UNPROVEN_EFFECT;
   if (!isBareCoreWord(headWord)) return UNPROVEN_EFFECT;
   const guard = RETRACTION_GUARDS.get(headWord);
   if (guard && argWords.some((word) => retractsClaim(word, guard))) {

package/node_modules/@gotgenes/pi-permission-system/src/handlers/gates/bash-command.ts

@@ -1,5 +1,5 @@
 // Datalab Kit adaptation
-
+import { inspectionCommands } from "../../../../../../dist/read-policy.js";
 import type {
   BashCommand,
   WrapperKind,
@@ -77,7 +77,7 @@ export function resolveBashCommandCheck(
   resolver: ScopedPermissionResolver,
 ): PermissionCheckResult {
   const kitWhole = resolveOnBashSurface(command, agentName, resolver);
-  if (kitWhole.origin === 'builtin' && kitWhole.state === 'ask') return kitWhole;
+  if (kitWhole.state === 'deny') return kitWhole;
   if (isTriviallyEmptyCommand(command)) {
     return resolveOnBashSurface(command, agentName, resolver);
   }
@@ -106,13 +106,13 @@ export function resolveBashCommandCheck(
     }
   }
 
-  const results = commands.map((cmd) =>
-    resolveCommandUnit(cmd, command, agentName, resolver),
-  );
-  return (
-    pickMostRestrictive(results) ??
-    resolveOnBashSurface(command, agentName, resolver)
-  );
+  const parsedCommands = inspectionCommands(command);
+  const results = [
+    ...commands.map(cmd => resolveCommandUnit(cmd, command, agentName, resolver)),
+    ...(parsedCommands?.map(text => resolveOnBashSurface(text, agentName, resolver)) ?? []),
+  ];
+  const worst = pickMostRestrictive(kitWhole.origin === 'builtin' && parsedCommands !== undefined ? results : [kitWhole, ...results]);
+  return worst ?? kitWhole;
 }
 
 /**

package/node_modules/@gotgenes/pi-permission-system/src/index.ts

@@ -1,6 +1,7 @@
 // Datalab Kit adaptation
 import { normalizeLocalReadCurl } from "../../../../dist/read-policy.js";
 import { isPlanModeActive } from "../../../../dist/plan-mode.js";
+import { registerYoloControl } from "../../../../dist/yolo.js";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir, getPackageDir } from "@earendil-works/pi-coding-agent";
 import { warmBashParser } from "#src/access-intent/bash/parser";
@@ -113,7 +114,8 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
   // close over it; every call runs after configStore is assigned below. yolo is
   // a composition-stage ask→allow rewrite (#526) that the gate runner extends
   // to asks synthesized after resolution (#712), so both share this reader.
-  const isYoloEnabled = (): boolean => isYoloModeEnabled(configStore.current());
+  const kitYolo = registerYoloControl(pi, () => isYoloModeEnabled(configStore.current()));
+  const isYoloEnabled = (): boolean => kitYolo.isEnabled();
 
   let kitSession: ExtensionContext["sessionManager"] | undefined;
   const permissionManager = new PermissionManager({
@@ -381,15 +383,25 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
     gateRunner,
   );
 
-  pi.on("session_start", (event, ctx) =>
-    { kitSession = ctx.sessionManager; return lifecycle.handleSessionStart(event, ctx); },
-  );
+  pi.on("session_start", async (event, ctx) => {
+    kitSession = ctx.sessionManager;
+    await lifecycle.handleSessionStart(event, ctx);
+    kitYolo.refresh(ctx);
+  });
   pi.on("resources_discover", (event, ctx) =>
     lifecycle.handleResourcesDiscover(event, ctx),
   );
   pi.on("session_shutdown", () => lifecycle.handleSessionShutdown());
-  pi.on("before_agent_start", (event, ctx) => agentPrep.handle(event, ctx));
-  pi.on("input", (event, ctx) => gates.handleInput(event, ctx));
+  pi.on("before_agent_start", async (event, ctx) => {
+    const result = await agentPrep.handle(event, ctx);
+    kitYolo.refresh(ctx);
+    return result;
+  });
+  pi.on("input", async (event, ctx) => {
+    const result = await gates.handleInput(event, ctx);
+    kitYolo.refresh(ctx);
+    return result;
+  });
   pi.on(
     "tool_call",
     createFailClosedToolCall(

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@dev-sergeev/datalab-kit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A ready-to-use collection of Pi coding agent extensions",
   "type": "module",
   "license": "MIT",
   "engines": { "node": ">=22.19.0" },
   "keywords": ["pi-package", "pi-coding-agent", "gigachat"],
   "publishConfig": { "access": "public" },
-  "files": ["dist", "scripts/postinstall.mjs", "docs/adr", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.md"],
+  "files": ["dist", "scripts/postinstall.mjs", "docs/adr", "README.md", "CHANGELOG.md", "LICENSE", "THIRD_PARTY_NOTICES.md"],
   "pi": {
     "extensions": [
       "./dist/extension.js",