peaks-loop 4.1.13 → 4.1.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude-plugin/marketplace.json +2 -2
- package/CHANGELOG.md +138 -0
- package/dist/cli/commands/code-gate-command.d.ts +18 -0
- package/dist/cli/commands/code-gate-command.js +99 -32
- package/dist/services/hooks/pre-tool-code-gate.d.ts +44 -1
- package/dist/services/hooks/pre-tool-code-gate.js +144 -9
- package/package.json +5 -5
|
@@ -1,13 +1,13 @@
|
|
|
1
1
|
{
|
|
2
2
|
"metadata": {
|
|
3
3
|
"pluginRoot": ".",
|
|
4
|
-
"version": "4.1.
|
|
4
|
+
"version": "4.1.15"
|
|
5
5
|
},
|
|
6
6
|
"plugins": [
|
|
7
7
|
{
|
|
8
8
|
"name": "peaks-loop",
|
|
9
9
|
"description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
|
|
10
|
-
"version": "4.1.
|
|
10
|
+
"version": "4.1.15",
|
|
11
11
|
"author": {
|
|
12
12
|
"name": "SquabbyZ"
|
|
13
13
|
},
|
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,143 @@
|
|
|
1
1
|
# Changelog
|
|
2
2
|
|
|
3
|
+
## 4.1.15 — 2026-10-22(门禁剩下的三种写法也不再决定判定)
|
|
4
|
+
|
|
5
|
+
**版本级别**:候选 **patch**(沿用常设规则"默认版本新增采用最小的版本位")。本次是**纯修复**:
|
|
6
|
+
既有 CLI 参数、门禁的六个硬阻断族成员、fail-open 策略、auto-compact 三档阈值、
|
|
7
|
+
peaks-code 的 11 步工序与 Gate A–G **一字不改**。
|
|
8
|
+
上一版(4.1.14)诚实记录为"留待后续决定"的残留写法里,与本切片同类的三条
|
|
9
|
+
(**大小写变体** / **没解析的 `..`** / **项目嵌在 git 仓库里**),本次全部收口。
|
|
10
|
+
|
|
11
|
+
### 1. 族名的大小写:比较时不区分大小写
|
|
12
|
+
|
|
13
|
+
- 六个族名全是小写,而 `SRC/foo.ts` 在**任何大小写不敏感的文件系统上**(Windows、默认的 macOS)
|
|
14
|
+
**就是** `src/foo.ts`。按字面比较,等于**让写法决定判定**。
|
|
15
|
+
- 现在:**只在比较时**折叠大小写;给调用方的报错里仍然显示**工具实际请求的那个路径**(原样)。
|
|
16
|
+
- **代价(有意接受,写在这里以免看起来像疏漏)**:在**大小写敏感**的文件系统上,
|
|
17
|
+
一个仓库同时有 `src/` 和 `SRC/` 时,`SRC/` 也会被拒。
|
|
18
|
+
**误放是漏洞,误拒只是碍事** —— 判别的不对称被选在了这一边。
|
|
19
|
+
|
|
20
|
+
### 2. 相对路径里没解析的 `..`
|
|
21
|
+
|
|
22
|
+
- 现在:匹配之前把 `..` 解析掉,**基准是调用方指定的项目根**。这条基准不是猜的:
|
|
23
|
+
IDE 以 `peaks code-gate --project "<项目目录>"` 调用门禁,而工具调用的工作目录**就是项目目录**。
|
|
24
|
+
- 解析后**逃出项目根**(`../../elsewhere/src/x.ts`)⇒ 目标在项目之外 ⇒ 不属于任何族 ⇒ **放行**,
|
|
25
|
+
与"项目根之外的绝对路径放行"是同一条规则。
|
|
26
|
+
- **代价**:基准选错会误拒邻近目录的文件;项目根是调用方与工具调用**唯一都认**的那个基准,
|
|
27
|
+
所以它被选作基准,并把这条取舍写进了代码注释。
|
|
28
|
+
|
|
29
|
+
### 3. 项目嵌在 git 仓库里:族相对**调用方指定的项目根**比
|
|
30
|
+
|
|
31
|
+
- 此前 `resolveCanonicalProjectRoot` 把根提升到 **git 根**,于是族是相对 git 根比的:
|
|
32
|
+
绝对写法 `<gitroot>/app/src/x.ts` 落在 `app/` 下 → **不在 `src/` 里** → 放行;
|
|
33
|
+
而相对写法 `src/x.ts` → **被拒**。**同一个文件,两种写法,两个判定。**
|
|
34
|
+
- 现在:**硬阻断族相对 `--project` 指名的项目根**比;**租约查找仍然用规范根**
|
|
35
|
+
(会话和租约住在那里)—— 本次只改路径比对,没有顺手改租约查找。
|
|
36
|
+
|
|
37
|
+
### 4. 三条必须保持的性质(逐条复验)
|
|
38
|
+
|
|
39
|
+
- **fail-open 策略不变**:payload 判不了时**仍然放行**,只是 stderr 上仍留 `PEAKS_CODE_GATE_UNDECIDABLE`。
|
|
40
|
+
- **六个族的成员不变**:`HARD_BLOCKED_PATH_FAMILIES` 与 `ALLOW_LISTED_PATH_PATTERNS` **零行改动**。
|
|
41
|
+
- **fast lane 仍然打开这些族**:租约是 `peaks-race-code` 时,`src/` 的编辑仍然**放行**。
|
|
42
|
+
|
|
43
|
+
### 5. `.sh` 兄弟脚本
|
|
44
|
+
|
|
45
|
+
它**没有项目根**(不收环境变量、没有参数),所以**不假装能判绝对路径** —— 这一条仍然如此。
|
|
46
|
+
它能做的两件同类的事做了:比较时折叠大小写、相对路径的 `..` 折叠。
|
|
47
|
+
它**仍然不**解析 driver —— 那会是同一个决定的第二个实现。
|
|
48
|
+
|
|
49
|
+
### 6. QA 独立复核推翻了一个理由,并挖出一个洞
|
|
50
|
+
|
|
51
|
+
- ⚠️ **"两组模式不相交"是错的。** RD 报告说"大小写折叠同时作用于白名单是安全的",理由是两组模式
|
|
52
|
+
不相交。QA 实测**推翻了它**:有 **12 种路径形态同时命中两组**(`.md` / `.peaks_` 是**后缀**模式,
|
|
53
|
+
族是**前缀**模式)。**结论仍然成立,但理由必须换成 QA 实测的那一个**:折叠让判定**恰好等于**它的
|
|
54
|
+
小写写法(84 条路径 0 例外),而每一个"新被放行"的路径,**它的小写写法在修之前就已被放行**
|
|
55
|
+
⇒ **折叠没有放进任何新文件**。
|
|
56
|
+
- ⚠️ **一个 RD 报告没有提到的洞**(QA 挖出来的;**既有问题,不是本次回归**):当**工具调用的工作目录
|
|
57
|
+
不是项目根**时 —— 例如 cwd 是 `<root>/src`、payload 是 `deep/x.ts` —— 这个路径其实指向
|
|
58
|
+
`<root>/src/deep/x.ts`,**落在 `src/` 里、应当被拒**,而门禁**放行**了。
|
|
59
|
+
本切片写下的不变量是"判定只由文件落在哪个目录决定",**这一条还没有完全成立**。
|
|
60
|
+
它的成因与 `..` 那一族同源:**相对路径的基准**。本切片选了"调用方指定的项目根",
|
|
61
|
+
而这个洞是"**工具调用自己的工作目录**" —— 两者只在 cwd == 项目根时一致。
|
|
62
|
+
- **一个覆盖缺口**(不是缺陷):套件钉住的是**词法**的 `..` 折叠,不是**基于根**的折叠 ——
|
|
63
|
+
换一种写法只红一次,而那种写法会放行一个"逃出去又绕回来"的 `..`。
|
|
64
|
+
**发出去的代码是更强的那一版**(基于根),所以这是覆盖缺口,不是缺陷。
|
|
65
|
+
- **一个数字不复现**:RD 报 `..` 那个变异"5 红";QA 试了 **10 种**改法,得到 9/9/4/14/14/14/2/2/1/1,
|
|
66
|
+
**没有一种得到 5**。**每一种都变红** ⇒ 结论成立,**数字不复现**。
|
|
67
|
+
|
|
68
|
+
### 7. QA 的结论
|
|
69
|
+
|
|
70
|
+
**PASS,0 个缺陷,2 个 LOW 发现**;门禁**没有被削弱**(fail-open 不变、六个族成员零行改动、
|
|
71
|
+
fast lane 仍打开这些族)。全量 `pnpm test:unit`:**568 文件 / 6236 通过 / 3 skip / 0 失败**。
|
|
72
|
+
真实环境:5 个 tarball 装进**仓库之外**的全新目录、npm 自己的提升布局、没手工挪 ⇒
|
|
73
|
+
**装好的那个 CLI** 对三种残留写法全部 DENY,嵌套 git 仓库那一档也 DENY;
|
|
74
|
+
用**抽取出来的 pre-fix 源码**跑同一批路径,三种都 **allow** ⇒ 缺陷复现、修复闭合。
|
|
75
|
+
|
|
76
|
+
## 4.1.14 — 2026-10-21(门禁按文件判而不是按写法判、发布包在任何 npm 布局下都能启动、门禁判不了时说得出来)
|
|
77
|
+
|
|
78
|
+
**版本级别**: 未发布区间 `v4.1.13..HEAD` 共 **4 个 commit**(**3 fix / 1 docs**)。取 **patch**,依维护者 2026-07-22 的常设规则"默认版本新增采用最小的版本位"。本次是**纯修复**:既有 CLI 参数、门禁的六个硬阻断族成员、fail-open 策略、auto-compact 三档阈值、peaks-code 的 11 步工序与 Gate A–G **一字不改**。两处行为变化都是本次要修的:**硬阻断路径的绝对写法现在被拒**(原先放行),以及**判不了的 payload 从静默放行变成留下可见标记**。
|
|
79
|
+
|
|
80
|
+
### 1. 门禁按文件判,不按写法判(`eeb02060`)
|
|
81
|
+
|
|
82
|
+
- 门禁此前用**裸 `startsWith`** 把硬阻断族和 payload 里的路径对起来,**整条门禁路径上没有任何归一化**。
|
|
83
|
+
族是项目相对前缀(`src/` `tests/unit/` …),于是 `src/x.ts` **被拒**,而 `./src/x.ts` 和**同一个文件的绝对写法被放行** ——
|
|
84
|
+
同一处编辑,换个写法就过,**而且过的正是那个写法**。门禁自己的测试**只用过相对写法**,另两种从未被执行。
|
|
85
|
+
- 现在:项目根**以内**的绝对路径先变成项目相对形式再匹配,开头的 `./` 去掉,分隔符折成 `/`。
|
|
86
|
+
**项目根之外**的绝对路径保持绝对:这些族名的是**本项目**的目录,别的仓库是别的仓库的事,
|
|
87
|
+
而且**修之前所有绝对路径本来就放行**,所以这**不是放宽**。
|
|
88
|
+
- `..` 段**故意不解析**:相对路径是相对**工具调用自己的工作目录**的,门禁并不知道那个目录,
|
|
89
|
+
拿项目根去解析是猜。
|
|
90
|
+
- `.sh` 兄弟脚本只做**拼写层面**的折叠:它不收环境变量也没有参数,**没有项目根**,硬猜会变成误拦;
|
|
91
|
+
它仍然**不**解析 driver —— 那会是同一个决定的第二个实现。
|
|
92
|
+
|
|
93
|
+
### 2. 发布包在任何 npm 布局下都能启动(`386ff9d9`)
|
|
94
|
+
|
|
95
|
+
- `peaks-loop-shared` **只发布 `dist/**`**(里面没有 `skills/`),所以它**永远不可能**是"skills 在哪"的答案;
|
|
96
|
+
旧的查找靠向上找一个**同时有 `package.json` 和 `skills/`** 的目录。
|
|
97
|
+
⇒ 只有当子包**嵌套在根包之下**时才找得到 —— 而那恰好是 npm **全局**安装的布局,
|
|
98
|
+
所以 `npm i -g peaks-loop` 一直好用;**本地**安装把子包**提升**到根包旁边,于是发布的 CLI **一 import 就死**:
|
|
99
|
+
`Error: Unable to locate Peaks repository root from .../node_modules/peaks-loop-shared/dist`。
|
|
100
|
+
**README 只写了全局安装**,所以坏掉的正是没写的那条路。
|
|
101
|
+
- 现在:查找在**每一层**都多问一句"根包是不是**在我旁边**",嵌套、提升、pnpm store 三种布局都覆盖;
|
|
102
|
+
根包根本不在盘上时,回落到**真源资产库**(`PEAKS_HOME` 或 `~/.peaks`)—— skills 的法定居所。
|
|
103
|
+
- 共享包只发布 `dist/**`,**不能** import 根包的脚本,所以那个环境变量名在**两处各写一遍**,
|
|
104
|
+
并在两处都记下了原因。
|
|
105
|
+
|
|
106
|
+
### 3. 门禁判不了的时候,说得出话(`8060706e`)
|
|
107
|
+
|
|
108
|
+
- payload 缺失或解析不了时门禁**仍然放行**,这是有意的:payload 送不到时**每次编辑都被拦**比放行更糟。
|
|
109
|
+
但那个放行**是静默的**,而它藏起来的失败恰是最贵的那种 ——
|
|
110
|
+
用管道喂 payload 的验收(有些 shell 根本不往进程转发 stdin)会**每个用例都过,却什么都没验**。
|
|
111
|
+
- 现在判不了的那一处在 **stderr 上留下 `PEAKS_CODE_GATE_UNDECIDABLE`**(PreToolUse 的 stderr 本来就喂给 LLM),
|
|
112
|
+
并把"用**文件重定向**喂 payload"的配方一并写出来。
|
|
113
|
+
|
|
114
|
+
### 4. 三个残留,**诚实记录**(不是本次的回归)
|
|
115
|
+
|
|
116
|
+
QA 独立复核时把 pre-fix 的源码抽出来实际跑过,确认以下三种写法**修之前也放行**,所以不是本次引入的:
|
|
117
|
+
|
|
118
|
+
| 残留 | 修前 | 修后 | 严重度 |
|
|
119
|
+
|---|---|---|---|
|
|
120
|
+
| `SRC/foo.ts` —— 族名的**大小写变体** | allow | allow | LOW |
|
|
121
|
+
| `docs/../src/foo.ts` —— 相对路径里**没解析的 `..`** | allow | allow | LOW |
|
|
122
|
+
| `.sh` 兄弟脚本 vs Node 命令(绝对硬阻断路径) | 都 allow | shell allow / node **deny** | MEDIUM |
|
|
123
|
+
| 项目**嵌在 git 仓库里** —— 绝对写法按 git 根判 | allow | allow | MEDIUM |
|
|
124
|
+
|
|
125
|
+
⇒ **"拼写无关"这条不变量,只在「项目根就是 git 根」时成立。** 前两条与刚修的缺陷**同类**
|
|
126
|
+
(大小写不敏感的文件系统上 `SRC/foo.ts` **就是** `src/foo.ts`)。判 LOW 的理由:这道门防的是
|
|
127
|
+
**误操作**,不是敌手。**留待后续决定是否再开一个 slice。**
|
|
128
|
+
|
|
129
|
+
### 5. 证据
|
|
130
|
+
|
|
131
|
+
- QA **独立复核**(不是采信 RD 的报告):三个变异**自己重推**,结果与 RD 报的**完全一致**
|
|
132
|
+
(归一化关掉 8 红 / 「根包在旁边」关掉 1 红 / 去掉两处 `reportUndecidable` 2 红)。
|
|
133
|
+
- 全量 `pnpm test:unit`:**565 文件 / 6204 通过 / 3 skip / exit 0,零失败**;
|
|
134
|
+
`tsc` 0 错;`node .husky/peaks-gate.mjs repo` 绿且**每个上限未动**(两个 eslint 上限各**降** 1)。
|
|
135
|
+
- 真实环境:5 个打包好的 tarball 装进**仓库之外**的全新目录,**npm 自己的提升布局、没手工挪** ⇒
|
|
136
|
+
`peaks --version` 起得来;**pre-fix** 的查找在同一条路径上**复现**了
|
|
137
|
+
`Unable to locate Peaks repository root`。
|
|
138
|
+
- 拼写矩阵(**文件重定向**喂 payload,绝不走管道):相对 / `./` / Windows 反斜杠 / `.\` / 绝对
|
|
139
|
+
—— **五种写法同一个判定,全部 deny**。
|
|
140
|
+
|
|
3
141
|
## 4.1.13 — 2026-10-21(peaks-race-code 批量模式:一次门禁归因、scoped test 前置的修复阶段、上下文监控)
|
|
4
142
|
|
|
5
143
|
**版本级别**: 未发布区间 `v4.1.12..HEAD` 共 **32 个 commit**(**10 feat / 11 fix / 11 docs**)。取 **patch**,依维护者 2026-07-22 的常设规则"默认版本新增采用最小的版本位"。本次是**纯追加**:新的 `peaks batch` 命令组、新的 `src/services/batch/**` 与 `src/services/lint/**` 模块;既有 CLI 参数、peaks-code 的 11 步工序、Gate A–G 与 transition 状态机**一字不改**。唯一触及既有共享路径的两处 —— `auto-compact-decision.ts` 的可选 `atPhaseBoundary`、`skill-context-verdict.ts` 的可选 `batch` 参数 —— **缺省时行为逐字不变**,对非批量用户无影响。
|
|
@@ -21,4 +21,22 @@
|
|
|
21
21
|
*/
|
|
22
22
|
import type { Command } from 'commander';
|
|
23
23
|
import { type ProgramIO } from '../cli-helpers.js';
|
|
24
|
+
/**
|
|
25
|
+
* The marker the gate leaves on stderr when it could not decide.
|
|
26
|
+
*
|
|
27
|
+
* The gate fails OPEN on a payload it cannot read, and that is deliberate: a
|
|
28
|
+
* blocked edit on every call would be worse than an allowed one. But a silent
|
|
29
|
+
* allow is invisible, and the failure it hides is the expensive kind — an
|
|
30
|
+
* acceptance that feeds the payload through a pipe (which some shells do not
|
|
31
|
+
* forward to the process at all) then "passes" every case while proving
|
|
32
|
+
* nothing. So the case says so, on the channel the harness already reads.
|
|
33
|
+
*/
|
|
34
|
+
export declare const UNDECIDABLE_MARKER = "PEAKS_CODE_GATE_UNDECIDABLE";
|
|
35
|
+
/**
|
|
36
|
+
* How to feed the payload so that it arrives. A pipeline is not a delivery
|
|
37
|
+
* mechanism on every shell — a PowerShell pipeline to a native executable
|
|
38
|
+
* does not forward stdin at all — and then the gate reads no payload, allows
|
|
39
|
+
* everything, and the check passes vacuously.
|
|
40
|
+
*/
|
|
41
|
+
export declare const PAYLOAD_DELIVERY_RECIPE: string;
|
|
24
42
|
export declare function registerCodeGateCommand(program: Command, io: ProgramIO): void;
|
|
@@ -19,8 +19,9 @@
|
|
|
19
19
|
* to render this into any IDE's settings.json shape. This file is
|
|
20
20
|
* vendor-neutral — no vendor references in the source code itself.
|
|
21
21
|
*/
|
|
22
|
+
import { resolve } from 'node:path';
|
|
22
23
|
import { addJsonOption, printResult } from '../cli-helpers.js';
|
|
23
|
-
import { decideGateAction, extractFilePath } from '../../services/hooks/pre-tool-code-gate.js';
|
|
24
|
+
import { decideGateAction, extractFilePath, isGatedTool } from '../../services/hooks/pre-tool-code-gate.js';
|
|
24
25
|
import { hasLeaseForCaller, resolveActiveSkillForCaller } from '../../services/audit/enforcers/active-skill-resolver.js';
|
|
25
26
|
import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
|
|
26
27
|
import { pluckObject, pluckString } from '../../services/ide/hook-translator.js';
|
|
@@ -59,6 +60,81 @@ function resolveDriver(projectRoot, payload) {
|
|
|
59
60
|
return null;
|
|
60
61
|
return resolveActiveSkillForCaller(projectRoot, { callerId }).skill;
|
|
61
62
|
}
|
|
63
|
+
/**
|
|
64
|
+
* The marker the gate leaves on stderr when it could not decide.
|
|
65
|
+
*
|
|
66
|
+
* The gate fails OPEN on a payload it cannot read, and that is deliberate: a
|
|
67
|
+
* blocked edit on every call would be worse than an allowed one. But a silent
|
|
68
|
+
* allow is invisible, and the failure it hides is the expensive kind — an
|
|
69
|
+
* acceptance that feeds the payload through a pipe (which some shells do not
|
|
70
|
+
* forward to the process at all) then "passes" every case while proving
|
|
71
|
+
* nothing. So the case says so, on the channel the harness already reads.
|
|
72
|
+
*/
|
|
73
|
+
export const UNDECIDABLE_MARKER = 'PEAKS_CODE_GATE_UNDECIDABLE';
|
|
74
|
+
/**
|
|
75
|
+
* How to feed the payload so that it arrives. A pipeline is not a delivery
|
|
76
|
+
* mechanism on every shell — a PowerShell pipeline to a native executable
|
|
77
|
+
* does not forward stdin at all — and then the gate reads no payload, allows
|
|
78
|
+
* everything, and the check passes vacuously.
|
|
79
|
+
*/
|
|
80
|
+
export const PAYLOAD_DELIVERY_RECIPE = 'feed the payload by FILE REDIRECTION (cmd /c "peaks code-gate < payload.json"), not through a pipe: ' +
|
|
81
|
+
'a shell pipeline does not always forward stdin to the process, and then every case is allowed and the check proves nothing.';
|
|
82
|
+
/** Say, on stderr, that the gate could not decide — and still allow. */
|
|
83
|
+
function reportUndecidable(reason) {
|
|
84
|
+
process.stderr.write(`${UNDECIDABLE_MARKER}: ${reason}; allowing. ${PAYLOAD_DELIVERY_RECIPE}\n`);
|
|
85
|
+
}
|
|
86
|
+
/**
|
|
87
|
+
* The reason this payload cannot be judged, or `null` when it can.
|
|
88
|
+
*
|
|
89
|
+
* A payload that names a gated tool but no target path is the same "cannot
|
|
90
|
+
* decide" the empty payload is: there is no file to match against a family.
|
|
91
|
+
*/
|
|
92
|
+
function undecidableReason(tool, input) {
|
|
93
|
+
if (!isGatedTool(tool))
|
|
94
|
+
return null;
|
|
95
|
+
if (extractFilePath(input).length > 0)
|
|
96
|
+
return null;
|
|
97
|
+
return 'the payload names a gated tool but no target path';
|
|
98
|
+
}
|
|
99
|
+
/** The payload as bytes, or `''` when stdin could not be read. */
|
|
100
|
+
async function readPayload() {
|
|
101
|
+
try {
|
|
102
|
+
return await readStdin();
|
|
103
|
+
}
|
|
104
|
+
catch {
|
|
105
|
+
// Empty / unreadable stdin → fail-open allow. The shell-script
|
|
106
|
+
// sibling does the same.
|
|
107
|
+
return '';
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
/** The payload as an object, or `null` when it is empty or malformed. */
|
|
111
|
+
function parsePayload(raw) {
|
|
112
|
+
if (raw.trim().length === 0)
|
|
113
|
+
return null;
|
|
114
|
+
let parsed = null;
|
|
115
|
+
try {
|
|
116
|
+
parsed = JSON.parse(raw);
|
|
117
|
+
}
|
|
118
|
+
catch {
|
|
119
|
+
// Malformed JSON → fail-open allow. Cannot decide safely.
|
|
120
|
+
parsed = null;
|
|
121
|
+
}
|
|
122
|
+
return parsed;
|
|
123
|
+
}
|
|
124
|
+
/** The verdict envelope, in the shape the `--dry-run` mode prints. */
|
|
125
|
+
function printDryRunVerdict(io, asJson, context) {
|
|
126
|
+
const { tool, input, verdict, undecidable } = context;
|
|
127
|
+
if (verdict.action === 'allow') {
|
|
128
|
+
printResult(io, ok('code.gate', { action: 'allow', tool, filePath: extractFilePath(input) }, [], undecidable === null ? [] : [PAYLOAD_DELIVERY_RECIPE]), asJson);
|
|
129
|
+
return;
|
|
130
|
+
}
|
|
131
|
+
printResult(io, fail('code.gate', 'PEAKS_CODE_PROHIBITED_DIRECT_EDIT', verdict.message, {
|
|
132
|
+
action: 'deny',
|
|
133
|
+
tool,
|
|
134
|
+
filePath: verdict.filePath,
|
|
135
|
+
reason: verdict.reason
|
|
136
|
+
}, ['use peaks sub-agent dispatch rd']), asJson);
|
|
137
|
+
}
|
|
62
138
|
export function registerCodeGateCommand(program, io) {
|
|
63
139
|
addJsonOption(program
|
|
64
140
|
.command('code-gate')
|
|
@@ -68,48 +144,39 @@ export function registerCodeGateCommand(program, io) {
|
|
|
68
144
|
'The gate blocks Edit/Write/MultiEdit on hard-blocked path families ' +
|
|
69
145
|
'(src/, tests/unit/, tests/integration/, config/, bin/, scripts/) so the ' +
|
|
70
146
|
'orchestrator is forced to dispatch via `peaks sub-agent dispatch rd`. ' +
|
|
71
|
-
'Allow-listed paths (.peaks/**, skills/**, docs/**) are NOT gated.'
|
|
147
|
+
'Allow-listed paths (.peaks/**, skills/**, docs/**) are NOT gated. ' +
|
|
148
|
+
'A payload the gate cannot read is ALLOWED (fail-open) and says so on ' +
|
|
149
|
+
'stderr with PEAKS_CODE_GATE_UNDECIDABLE — ' +
|
|
150
|
+
'feed the payload by FILE REDIRECTION, not through a pipe.')
|
|
72
151
|
.option('--dry-run', 'emit JSON verdict to stdout instead of exit code; useful for tests')
|
|
73
152
|
.option('--project <path>', 'project the driver lease is resolved against (default: current directory)')).action(async (opts) => {
|
|
74
|
-
|
|
75
|
-
try {
|
|
76
|
-
raw = await readStdin();
|
|
77
|
-
}
|
|
78
|
-
catch {
|
|
79
|
-
// Empty / unreadable stdin → fail-open allow. The shell-script
|
|
80
|
-
// sibling does the same.
|
|
81
|
-
raw = '';
|
|
82
|
-
}
|
|
83
|
-
let parsed = null;
|
|
84
|
-
try {
|
|
85
|
-
parsed = raw.trim().length > 0 ? JSON.parse(raw) : null;
|
|
86
|
-
}
|
|
87
|
-
catch {
|
|
88
|
-
// Malformed JSON → fail-open allow. Cannot decide safely.
|
|
89
|
-
parsed = null;
|
|
90
|
-
}
|
|
153
|
+
const parsed = parsePayload(await readPayload());
|
|
91
154
|
if (parsed === null) {
|
|
155
|
+
reportUndecidable('no stdin payload');
|
|
92
156
|
if (opts.dryRun === true) {
|
|
93
|
-
printResult(io, ok('code.gate', { action: 'allow', reason: 'empty-or-malformed-payload' }, [], ['no stdin payload; allowing']), opts.json);
|
|
157
|
+
printResult(io, ok('code.gate', { action: 'allow', reason: 'empty-or-malformed-payload' }, [], ['no stdin payload; allowing', PAYLOAD_DELIVERY_RECIPE]), opts.json);
|
|
94
158
|
return;
|
|
95
159
|
}
|
|
96
160
|
process.exit(0);
|
|
97
161
|
}
|
|
98
162
|
const tool = readToolName(parsed);
|
|
99
163
|
const input = readToolInput(parsed);
|
|
100
|
-
const
|
|
164
|
+
const undecidable = undecidableReason(tool, input);
|
|
165
|
+
if (undecidable !== null) {
|
|
166
|
+
reportUndecidable(undecidable);
|
|
167
|
+
}
|
|
168
|
+
// TWO roots, because two questions ask for one. The CANONICAL root is
|
|
169
|
+
// where the session and the leases live, so the caller is placed against
|
|
170
|
+
// it. The NAMED root is the project the caller named, and it is what the
|
|
171
|
+
// deny families are relative to: a project nested inside a git repository
|
|
172
|
+
// is judged against ITSELF, not against the git root above it. One file
|
|
173
|
+
// must not get two verdicts from two spellings, and a project that is not
|
|
174
|
+
// the git root is exactly where the two would differ.
|
|
175
|
+
const namedRoot = resolve(opts.project ?? process.cwd());
|
|
176
|
+
const canonicalRoot = resolveCanonicalProjectRoot(namedRoot);
|
|
177
|
+
const verdict = decideGateAction(tool, input, resolveDriver(canonicalRoot, parsed), namedRoot);
|
|
101
178
|
if (opts.dryRun === true) {
|
|
102
|
-
|
|
103
|
-
printResult(io, ok('code.gate', { action: 'allow', tool, filePath: extractFilePath(input) }, [], []), opts.json);
|
|
104
|
-
}
|
|
105
|
-
else {
|
|
106
|
-
printResult(io, fail('code.gate', 'PEAKS_CODE_PROHIBITED_DIRECT_EDIT', verdict.message, {
|
|
107
|
-
action: 'deny',
|
|
108
|
-
tool,
|
|
109
|
-
filePath: verdict.filePath,
|
|
110
|
-
reason: verdict.reason
|
|
111
|
-
}, ['use peaks sub-agent dispatch rd']), opts.json);
|
|
112
|
-
}
|
|
179
|
+
printDryRunVerdict(io, opts.json === true, { tool, input, verdict, undecidable });
|
|
113
180
|
return;
|
|
114
181
|
}
|
|
115
182
|
if (verdict.action === 'deny') {
|
|
@@ -28,6 +28,10 @@ export interface GateInput {
|
|
|
28
28
|
export declare const HARD_BLOCKED_PATH_FAMILIES: readonly ["src/", "tests/unit/", "tests/integration/", "config/", "bin/", "scripts/"];
|
|
29
29
|
/** Allow-listed path prefixes / suffixes — orchestrator may freely Edit/Write these. */
|
|
30
30
|
export declare const ALLOW_LISTED_PATH_PATTERNS: readonly [".peaks/", ".peaks_", "skills/", "docs/", ".md", "CHANGELOG.md", "README.md"];
|
|
31
|
+
/** The tool names this gate judges. A call under any other name is allowed. */
|
|
32
|
+
export declare const GATED_TOOL_NAMES: readonly ["Edit", "Write", "MultiEdit"];
|
|
33
|
+
/** Is this tool one the gate judges at all? */
|
|
34
|
+
export declare function isGatedTool(tool: GateToolName): boolean;
|
|
31
35
|
export type GateVerdict = {
|
|
32
36
|
readonly action: 'allow';
|
|
33
37
|
} | {
|
|
@@ -38,6 +42,37 @@ export type GateVerdict = {
|
|
|
38
42
|
};
|
|
39
43
|
/** Pull the target file path from `input.file_path | input.path | input.notebook_path`. */
|
|
40
44
|
export declare function extractFilePath(input: Readonly<Record<string, unknown>>): string;
|
|
45
|
+
/**
|
|
46
|
+
* The ONE spelling-independent form of a target path.
|
|
47
|
+
*
|
|
48
|
+
* The deny families are project-relative prefixes (`src/`, `tests/unit/`, …),
|
|
49
|
+
* so how the incoming path happens to be SPELLED must not decide the verdict:
|
|
50
|
+
* `src/x.ts`, `./src/x.ts` and the absolute spelling of that same file are one
|
|
51
|
+
* file and must get one verdict. Without this, the same edit is denied in one
|
|
52
|
+
* spelling and allowed in another — and the allow is the one that happens.
|
|
53
|
+
*
|
|
54
|
+
* - separators fold to `/` (a Windows payload spells `src\x.ts`)
|
|
55
|
+
* - a leading `./` is dropped
|
|
56
|
+
* - a `..` segment is resolved
|
|
57
|
+
* - an ABSOLUTE path inside `projectRoot` becomes project-relative
|
|
58
|
+
* - an absolute path OUTSIDE `projectRoot` stays absolute: the families name
|
|
59
|
+
* THIS project's directories, and a path in another repository is another
|
|
60
|
+
* project's business. That is also what the gate already did with every
|
|
61
|
+
* absolute path, so it is not a widening.
|
|
62
|
+
* - with no `projectRoot` an absolute path cannot be made relative and is
|
|
63
|
+
* left as it is
|
|
64
|
+
*
|
|
65
|
+
* The base a `..` is resolved against is the PROJECT ROOT the caller named,
|
|
66
|
+
* and that is a fact about the caller rather than a guess: the IDE invokes
|
|
67
|
+
* `peaks code-gate --project "<the project directory>"`, and the tool call's
|
|
68
|
+
* own working directory is that same project directory. A `..` that resolves
|
|
69
|
+
* OUTSIDE the root names a file outside the project, so it belongs to no
|
|
70
|
+
* family and is allowed - the same rule an absolute path outside the root
|
|
71
|
+
* follows. The trade-off is written down rather than left implicit: a base
|
|
72
|
+
* chosen wrongly would refuse files of a neighbouring directory, and the
|
|
73
|
+
* project root is the one base both the caller and the tool call agree on.
|
|
74
|
+
*/
|
|
75
|
+
export declare function normalizeGatePath(filePath: string, projectRoot?: string | null): string;
|
|
41
76
|
/**
|
|
42
77
|
* Pure decision function. Given the tool name + input object, return
|
|
43
78
|
* the gate verdict. Tolerates malformed payloads (allow).
|
|
@@ -47,5 +82,13 @@ export declare function extractFilePath(input: Readonly<Record<string, unknown>>
|
|
|
47
82
|
* `null` are the same verdict as before this parameter existed: the
|
|
48
83
|
* hard-blocked families deny. Resolution is the caller's job, so this
|
|
49
84
|
* module keeps no session, lease or filesystem state.
|
|
85
|
+
*
|
|
86
|
+
* `projectRoot` is the root the deny families are relative to. It is what
|
|
87
|
+
* lets an ABSOLUTE path be judged like its relative spelling; without it an
|
|
88
|
+
* absolute path cannot be related to the project and is left alone. It is the
|
|
89
|
+
* project root the CALLER named, not the canonical root above it: a project
|
|
90
|
+
* nested inside a git repository is judged against itself, and the canonical
|
|
91
|
+
* root - where the session and the leases live - is a different question
|
|
92
|
+
* that this parameter does not answer.
|
|
50
93
|
*/
|
|
51
|
-
export declare function decideGateAction(tool: GateToolName, input: Readonly<Record<string, unknown>>, driver?: string | null): GateVerdict;
|
|
94
|
+
export declare function decideGateAction(tool: GateToolName, input: Readonly<Record<string, unknown>>, driver?: string | null, projectRoot?: string | null): GateVerdict;
|
|
@@ -18,6 +18,8 @@
|
|
|
18
18
|
* logic, usable from any non-Node harness. Both share the same
|
|
19
19
|
* hard-blocked + allow-listed path families.
|
|
20
20
|
*/
|
|
21
|
+
import { isAbsolute, relative, resolve } from 'node:path';
|
|
22
|
+
import { normalizePath } from '../../shared/path-utils.js';
|
|
21
23
|
/** Hard-blocked path families — orchestrator MUST NOT Edit/Write these. */
|
|
22
24
|
export const HARD_BLOCKED_PATH_FAMILIES = [
|
|
23
25
|
'src/',
|
|
@@ -44,6 +46,12 @@ export const ALLOW_LISTED_PATH_PATTERNS = [
|
|
|
44
46
|
* this write, because the write it opens is source editing.
|
|
45
47
|
*/
|
|
46
48
|
const FAST_LANE_DRIVER = 'peaks-race-code';
|
|
49
|
+
/** The tool names this gate judges. A call under any other name is allowed. */
|
|
50
|
+
export const GATED_TOOL_NAMES = ['Edit', 'Write', 'MultiEdit'];
|
|
51
|
+
/** Is this tool one the gate judges at all? */
|
|
52
|
+
export function isGatedTool(tool) {
|
|
53
|
+
return GATED_TOOL_NAMES.includes(tool);
|
|
54
|
+
}
|
|
47
55
|
/** Pull the target file path from `input.file_path | input.path | input.notebook_path`. */
|
|
48
56
|
export function extractFilePath(input) {
|
|
49
57
|
for (const key of ['file_path', 'path', 'notebook_path']) {
|
|
@@ -53,16 +61,129 @@ export function extractFilePath(input) {
|
|
|
53
61
|
}
|
|
54
62
|
return '';
|
|
55
63
|
}
|
|
64
|
+
/**
|
|
65
|
+
* Does the path belong to one of these families?
|
|
66
|
+
*
|
|
67
|
+
* The comparison folds CASE: every family name is written in lower case, and
|
|
68
|
+
* on a case-insensitive filesystem (Windows, and macOS by default) `SRC/x.ts`
|
|
69
|
+
* IS the file `src/x.ts`, so comparing the case exactly lets the spelling
|
|
70
|
+
* decide the verdict. BOTH lists are folded the same way, because both are
|
|
71
|
+
* judged against the same path: a case variant of an allow-listed file has to
|
|
72
|
+
* reach the same verdict as the file itself, or the fold would only move the
|
|
73
|
+
* inconsistency from one list to the other.
|
|
74
|
+
*
|
|
75
|
+
* THE TRADE-OFF, written down instead of left to look like an oversight: on a
|
|
76
|
+
* case-SENSITIVE filesystem a repository holding BOTH `src/` and `SRC/`
|
|
77
|
+
* refuses the edit under `SRC/` as well. That refusal is accepted on purpose.
|
|
78
|
+
* A wrongly allowed edit is a hole in the gate; a wrongly refused one is an
|
|
79
|
+
* inconvenience the caller can undo. Only the COMPARISON folds case - the
|
|
80
|
+
* path the tool asked for is echoed to the caller exactly as it was spelled,
|
|
81
|
+
* and the family a verdict names is the canonical one, not the folded form.
|
|
82
|
+
*/
|
|
56
83
|
function matchesAny(path, families) {
|
|
84
|
+
const folded = path.toLowerCase();
|
|
57
85
|
for (const fam of families) {
|
|
58
|
-
if (
|
|
86
|
+
if (folded.startsWith(fam.toLowerCase()))
|
|
59
87
|
return fam;
|
|
60
88
|
// also handle ".md" suffix pattern
|
|
61
|
-
if (fam.startsWith('.') &&
|
|
89
|
+
if (fam.startsWith('.') && folded.endsWith(fam.toLowerCase()))
|
|
62
90
|
return fam;
|
|
63
91
|
}
|
|
64
92
|
return null;
|
|
65
93
|
}
|
|
94
|
+
/** Drop every leading `./` segment: `./src/x.ts` and `src/x.ts` are one path. */
|
|
95
|
+
function stripLeadingDotSegments(path) {
|
|
96
|
+
let out = path;
|
|
97
|
+
while (out.startsWith('./'))
|
|
98
|
+
out = out.slice(2);
|
|
99
|
+
return out;
|
|
100
|
+
}
|
|
101
|
+
/**
|
|
102
|
+
* Collapse the `.` and `..` segments of a RELATIVE path, lexically.
|
|
103
|
+
*
|
|
104
|
+
* The base directory does not enter the answer for a path that stays inside
|
|
105
|
+
* it: a `..` cancels the segment before it, for every base. A `..` that would
|
|
106
|
+
* leave the base is KEPT, so the result still reads as "outside", and a path
|
|
107
|
+
* outside the project belongs to no family.
|
|
108
|
+
*/
|
|
109
|
+
function collapseRelativeDotSegments(path) {
|
|
110
|
+
const out = [];
|
|
111
|
+
for (const segment of path.split('/')) {
|
|
112
|
+
if (segment === '' || segment === '.')
|
|
113
|
+
continue;
|
|
114
|
+
if (segment === '..') {
|
|
115
|
+
const last = out.length > 0 ? out[out.length - 1] : null;
|
|
116
|
+
if (last !== null && last !== '..')
|
|
117
|
+
out.pop();
|
|
118
|
+
else
|
|
119
|
+
out.push('..');
|
|
120
|
+
continue;
|
|
121
|
+
}
|
|
122
|
+
out.push(segment);
|
|
123
|
+
}
|
|
124
|
+
return out.join('/');
|
|
125
|
+
}
|
|
126
|
+
/**
|
|
127
|
+
* The path of `target` relative to `root`, when `target` is INSIDE `root`;
|
|
128
|
+
* `null` when it is not — the target is outside the root, or it is the root.
|
|
129
|
+
*/
|
|
130
|
+
function relativizeInsideRoot(target, root) {
|
|
131
|
+
const relativePath = normalizePath(relative(root, target));
|
|
132
|
+
if (relativePath.length === 0)
|
|
133
|
+
return null;
|
|
134
|
+
if (relativePath.startsWith('..') || isAbsolute(relativePath))
|
|
135
|
+
return null;
|
|
136
|
+
return stripLeadingDotSegments(relativePath);
|
|
137
|
+
}
|
|
138
|
+
/**
|
|
139
|
+
* The ONE spelling-independent form of a target path.
|
|
140
|
+
*
|
|
141
|
+
* The deny families are project-relative prefixes (`src/`, `tests/unit/`, …),
|
|
142
|
+
* so how the incoming path happens to be SPELLED must not decide the verdict:
|
|
143
|
+
* `src/x.ts`, `./src/x.ts` and the absolute spelling of that same file are one
|
|
144
|
+
* file and must get one verdict. Without this, the same edit is denied in one
|
|
145
|
+
* spelling and allowed in another — and the allow is the one that happens.
|
|
146
|
+
*
|
|
147
|
+
* - separators fold to `/` (a Windows payload spells `src\x.ts`)
|
|
148
|
+
* - a leading `./` is dropped
|
|
149
|
+
* - a `..` segment is resolved
|
|
150
|
+
* - an ABSOLUTE path inside `projectRoot` becomes project-relative
|
|
151
|
+
* - an absolute path OUTSIDE `projectRoot` stays absolute: the families name
|
|
152
|
+
* THIS project's directories, and a path in another repository is another
|
|
153
|
+
* project's business. That is also what the gate already did with every
|
|
154
|
+
* absolute path, so it is not a widening.
|
|
155
|
+
* - with no `projectRoot` an absolute path cannot be made relative and is
|
|
156
|
+
* left as it is
|
|
157
|
+
*
|
|
158
|
+
* The base a `..` is resolved against is the PROJECT ROOT the caller named,
|
|
159
|
+
* and that is a fact about the caller rather than a guess: the IDE invokes
|
|
160
|
+
* `peaks code-gate --project "<the project directory>"`, and the tool call's
|
|
161
|
+
* own working directory is that same project directory. A `..` that resolves
|
|
162
|
+
* OUTSIDE the root names a file outside the project, so it belongs to no
|
|
163
|
+
* family and is allowed - the same rule an absolute path outside the root
|
|
164
|
+
* follows. The trade-off is written down rather than left implicit: a base
|
|
165
|
+
* chosen wrongly would refuse files of a neighbouring directory, and the
|
|
166
|
+
* project root is the one base both the caller and the tool call agree on.
|
|
167
|
+
*/
|
|
168
|
+
export function normalizeGatePath(filePath, projectRoot) {
|
|
169
|
+
if (filePath.length === 0)
|
|
170
|
+
return '';
|
|
171
|
+
const slashed = normalizePath(filePath);
|
|
172
|
+
const root = typeof projectRoot === 'string' && projectRoot.length > 0 ? resolve(projectRoot) : null;
|
|
173
|
+
if (isAbsolute(slashed)) {
|
|
174
|
+
if (root === null)
|
|
175
|
+
return slashed;
|
|
176
|
+
return relativizeInsideRoot(resolve(slashed), root) ?? slashed;
|
|
177
|
+
}
|
|
178
|
+
if (root === null)
|
|
179
|
+
return collapseRelativeDotSegments(stripLeadingDotSegments(slashed));
|
|
180
|
+
const resolved = resolve(root, slashed);
|
|
181
|
+
const inside = relativizeInsideRoot(resolved, root);
|
|
182
|
+
if (inside !== null)
|
|
183
|
+
return inside;
|
|
184
|
+
// The `..` left the project root: the target is another project's file.
|
|
185
|
+
return normalizePath(resolved);
|
|
186
|
+
}
|
|
66
187
|
/**
|
|
67
188
|
* Pure decision function. Given the tool name + input object, return
|
|
68
189
|
* the gate verdict. Tolerates malformed payloads (allow).
|
|
@@ -72,25 +193,39 @@ function matchesAny(path, families) {
|
|
|
72
193
|
* `null` are the same verdict as before this parameter existed: the
|
|
73
194
|
* hard-blocked families deny. Resolution is the caller's job, so this
|
|
74
195
|
* module keeps no session, lease or filesystem state.
|
|
196
|
+
*
|
|
197
|
+
* `projectRoot` is the root the deny families are relative to. It is what
|
|
198
|
+
* lets an ABSOLUTE path be judged like its relative spelling; without it an
|
|
199
|
+
* absolute path cannot be related to the project and is left alone. It is the
|
|
200
|
+
* project root the CALLER named, not the canonical root above it: a project
|
|
201
|
+
* nested inside a git repository is judged against itself, and the canonical
|
|
202
|
+
* root - where the session and the leases live - is a different question
|
|
203
|
+
* that this parameter does not answer.
|
|
75
204
|
*/
|
|
76
|
-
export function decideGateAction(tool, input, driver) {
|
|
205
|
+
export function decideGateAction(tool, input, driver, projectRoot) {
|
|
77
206
|
// Only gate Edit / Write / MultiEdit.
|
|
78
|
-
if (tool
|
|
207
|
+
if (!isGatedTool(tool)) {
|
|
79
208
|
return { action: 'allow' };
|
|
80
209
|
}
|
|
81
|
-
const
|
|
82
|
-
if (
|
|
210
|
+
const requestedPath = extractFilePath(input);
|
|
211
|
+
if (requestedPath.length === 0) {
|
|
83
212
|
// No path → cannot decide; fail-open (allow). The probe side
|
|
84
213
|
// (`orchestrator-can-do`) handles slice-spec content; this hook
|
|
85
214
|
// handles file paths only.
|
|
86
215
|
return { action: 'allow' };
|
|
87
216
|
}
|
|
217
|
+
// The verdict is about the FILE, not about the spelling of the path that
|
|
218
|
+
// names it, so the path is reduced to the project-relative form the
|
|
219
|
+
// families are written in before anything is matched. The verdict still
|
|
220
|
+
// echoes the path the tool actually asked for.
|
|
221
|
+
const filePath = normalizeGatePath(requestedPath, projectRoot);
|
|
88
222
|
// Allow-list check first — short-circuits any deny, for every driver.
|
|
89
223
|
const allowMatch = matchesAny(filePath, ALLOW_LISTED_PATH_PATTERNS);
|
|
90
224
|
if (allowMatch !== null) {
|
|
91
225
|
return { action: 'allow' };
|
|
92
226
|
}
|
|
93
|
-
// Hard-blocked family check
|
|
227
|
+
// Hard-blocked family check — case-insensitively, because every family name
|
|
228
|
+
// is lower-case and the filesystem holding the file may not be.
|
|
94
229
|
const denyMatch = matchesAny(filePath, HARD_BLOCKED_PATH_FAMILIES);
|
|
95
230
|
if (denyMatch !== null) {
|
|
96
231
|
// A driver that is not the fast lane falls through to the same deny a
|
|
@@ -100,9 +235,9 @@ export function decideGateAction(tool, input, driver) {
|
|
|
100
235
|
return { action: 'allow' };
|
|
101
236
|
}
|
|
102
237
|
const reason = `${denyMatch} (orchestrator's hard-blocked path family)`;
|
|
103
|
-
const message = `PEAKS_CODE_PROHIBITED_DIRECT_EDIT: ${
|
|
238
|
+
const message = `PEAKS_CODE_PROHIBITED_DIRECT_EDIT: ${requestedPath} matches hard-blocked path family ${reason}; ` +
|
|
104
239
|
`orchestrator MUST NOT Edit/Write these directly. Use: peaks sub-agent dispatch rd --prompt '<your task>' --request-id <rid> --project . --batch-id <uuid>`;
|
|
105
|
-
return { action: 'deny', filePath, reason, message };
|
|
240
|
+
return { action: 'deny', filePath: requestedPath, reason, message };
|
|
106
241
|
}
|
|
107
242
|
// Anything not in the deny list → allow (e.g. CHANGELOG, README, top-level files).
|
|
108
243
|
return { action: 'allow' };
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "peaks-loop",
|
|
3
|
-
"version": "4.1.
|
|
3
|
+
"version": "4.1.15",
|
|
4
4
|
"description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
|
|
5
5
|
"author": "SquabbyZ",
|
|
6
6
|
"keywords": [
|
|
@@ -129,10 +129,10 @@
|
|
|
129
129
|
"picomatch": "4.0.7",
|
|
130
130
|
"yaml": "^2.9.1",
|
|
131
131
|
"zod": "^4.6.7",
|
|
132
|
-
"peaks-loop-
|
|
133
|
-
"peaks-loop-shared": "0.0.
|
|
134
|
-
"peaks-loop-
|
|
135
|
-
"peaks-loop-
|
|
132
|
+
"peaks-loop-mut": "0.1.69",
|
|
133
|
+
"peaks-loop-shared": "0.0.104",
|
|
134
|
+
"peaks-loop-internal-runtime": "0.0.55",
|
|
135
|
+
"peaks-loop-shared-channel": "0.0.72"
|
|
136
136
|
},
|
|
137
137
|
"devDependencies": {
|
|
138
138
|
"@changesets/cli": "2.31.1",
|