@papillon6814/pi-gh 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Papillon6814
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# pi-gh
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Piの会話から、共通YAMLに沿ったGitHub Issue案・ラベル変更を検証し、画面で承認した内容だけ実行するPi拡張です。MIT。CLIのbinは提供しません。既存gh-issueflowは削除・変更不要です。
+
+## 要件と導入
+- Node.js >=22.19.0、Pi 1.0.4、GitHub CLI gh。実機検証はmacOS。
+- 変更には通常のgh認証が必要です。認証情報・tokenをこの拡張へ渡す設定はありません。
+- 通常Piへ導入: `pi install npm:@papillon6814/pi-gh@0.1.1`。Profileを使わない通常の共通導入の例です。
+- pi-profileのDevelopmentだけで使う: `pi-profile packages add --profile developer npm:@papillon6814/pi-gh@0.1.1`、`pi-profile packages install --profile developer`。共通settingsへは追加しません。
+- ソース利用時は先に `npm install --ignore-scripts && npm run build`。Piホスト提供APIはpeerで、配布に本体を含めません。
+
+## ツール
+| 名前 | 主な入力 | 動作 |
+|---|---|---|
+| gh_issue_validate | draftPath、template/templatePath | オフラインの構造/policy検証 |
+| gh_issue_preview | 同上 | マスク済みプレビューとdigest。ラベル付きはremote確認 |
+| gh_issue_submit | 同上 | TUIで人間確認後にIssue作成 |
+| gh_labels_validate | changePath | オフラインの構造検証 |
+| gh_labels_preview | changePath | 対象・before/after・影響対象・digest |
+| gh_labels_apply | changePath | TUI確認後にラベル変更 |
+| gh_issue_form | template/templatePath | GitHub Issue FormのYAML文字列を返す。ファイル上書きなし |
+
+パスは作業ディレクトリ基準。標準templateはtask（既定）/parent。独自templatePathと同時指定はできません。examplesは架空のexample/demoなので、実行前に対象repoと内容を直してください。
+
+## 操作の流れ
+1. 案JSONを用意しvalidate。
+2. previewを読み、必要なら案・template・policyを直す。
+3. submit/applyを呼び、Piの確認画面で対象と内容を確認。上下/Pageキーで全文を読めます。
+4. 既定はCancel。左右でApproveを明示選択してEnter。Escape/Ctrl-Cは取消。
+
+初版ではTUIのローカル人間確認が必要です。RPC、print/JSON、子エージェントは変更を拒否します。読み取りツールとフォーム生成はUIなしでも使えます。外部変更ツールはmodel-onlyで、codemodeスクリプトから呼べません。承認hashやapprovedフラグをモデルから渡す経路はありません。
+
+入力bytes/template/policyとremote identity/stateを承認後にも再検査します。変更・取消・会話切替・tree移動・reload/shutdownで旧承認は使えません。承認は保存・再開・別sessionへ引き継ぎません。GitHub APIの検査とwriteの間の競合を完全には防げないため、同じ対象の並行編集は避けてください。
+
+## 入力とモデルpolicy
+templates/parent.yml、task.ymlが正本、formsは生成物です。fieldsのrequired/options/順序/制限とpolicies/models.ymlを読み直します。担当はmodel/thinking/reason、上位tierはupperTierApprovalを含めます。配布モデル表は例で、実際の利用可能性や予算承認を保証しません。upperTierApprovalの文字列だけで人間の真正な課金承認は証明できません。
+
+Issue JSONはversion/template/repo/title/fields/agents、任意labelsとparentIssue。labelsは既存ラベルのみで、暗黙に作成しません。ラベル変更はversion:1とrepo、operationがissue-labels/label-create/label-edit/label-delete。詳しい例はexamples/labels-*.jsonです。指定外ラベルは維持し、PRへのissue-labelsは拒否します。
+
+## 安全境界と結果
+秘密情報検出はヒューリスティックです。raw inputだけでなくdecoded文字列・object key・remote metadataをマスクし、候補があれば変更を拒否します。秘密漏洩ゼロや自由なbashからの直接gh実行防止を保証するものではありません。
+
+未知/重複JSON・YAMLキー、独自tag/alias、32段超階層、外部policy参照、入力1MiB超を拒否。policyのsymlink/descriptor検査を維持します。ghはshellなし、固定argv/stdin、GH_HOST=github.comで起動。60秒期限、各stdio1MiB、cleanup猶予100ms、POSIX所有process groupを停止します。Windowsの子孫全体停止は保証しません。
+
+ラベル一覧・影響対象は各100ページ/合計1MiBまで。上限・権限不足・検査失敗では変更しません。改名・削除・説明/色編集の影響を確認します。
+
+結果はvalidated/preview/generated/created/applied/noop/rejected/not-started/unknown。unknownは既に変更済みの可能性があるため、GitHubを手動確認し、再preview・再承認してください。自動再試行・自動取消はありません。既存コアのIssue URL検証と、ラベル付きIssue/ラベル変更の事後確認を維持しています。
+
+既存Issue本文/タイトル編集、sub-issue、assignee/Project、一括操作は対象外です。
+
+## 開発・検証
+`npm run build`、`npm run typecheck`、`npm test`。元コアの回帰はtest/core、承認・lifecycleはservice tests、ツール/UIはextension testsです。
+`python3 scripts/test-pi-gh-cli.py --pi /absolute/path/to/pi`は合成HOME、偽gh、loopbackモデルだけで実Piを検証します。実アカウントや実GitHubへ投稿しません。
+`npm pack`にはentry、compiled core、templates、架空examples、README、LICENSEだけを含めます。docs/test/認証は含めません。

package/dist/src/core/approval.d.ts

@@ -0,0 +1,2 @@
+import type { Preview, ValidatedIssue } from './types.js';
+export declare function createPreview(issue: ValidatedIssue): Preview;

package/dist/src/core/approval.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import { renderIssue } from './render.js';
+import { maskSecrets } from './secrets.js';
+function canonical(value) {
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    if (typeof value === 'object' && value !== null)
+        return '{' + Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b, 'en')).map(([k, v]) => JSON.stringify(k) + ':' + canonical(v)).join(',') + '}';
+    return JSON.stringify(value);
+}
+export function createPreview(issue) {
+    const rendered = renderIssue(issue);
+    const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+    const digest = sha(canonical({ formatVersion: 1, host: 'github.com', ...rendered, agents: issue.draft.agents, inputs: [issue.draftInput, ...issue.bundle.inputs].map(i => ({ path: i.path, sha256: sha(i.bytes) })) }));
+    let sensitive = false;
+    const mask = (v) => { const m = maskSecrets(v); sensitive ||= m.sensitive; return m.text; };
+    for (const i of [issue.draftInput, ...issue.bundle.inputs])
+        mask(i.bytes.toString('utf8'));
+    const agents = {};
+    for (const [name, a] of Object.entries(issue.draft.agents))
+        agents[mask(name)] = { model: mask(a.model), thinking: mask(a.thinking), reason: mask(a.reason), ...(a.upperTierApproval === undefined ? {} : { upperTierApproval: mask(a.upperTierApproval) }) };
+    const title = mask(rendered.title), body = mask(rendered.body), repo = mask(rendered.repo);
+    const labels = issue.draft.labels?.map(mask);
+    return { repo, title, body, agents, digest, sensitive, ...(labels === undefined ? {} : { labels }) };
+}

package/dist/src/core/data.d.ts

@@ -0,0 +1,19 @@
+import type { CapturedInput } from './types.js';
+export type ParsedData = null | boolean | number | string | ParsedData[] | {
+    [key: string]: ParsedData;
+};
+export declare const MAX_BYTES = 1048576;
+export declare class DataError extends Error {
+    readonly code: string;
+    readonly field: string;
+    constructor(code: string, field: string, message: string);
+}
+export declare function fail(code: string, field: string, message: string): never;
+export declare function record(value: unknown): value is Record<string, unknown>;
+export declare function keys(value: Record<string, unknown>, allowed: readonly string[], field: string): void;
+export declare function nonblank(value: unknown): value is string;
+export declare function validId(value: unknown): value is string;
+export declare function capture(file: string, allowedRoot?: string): Promise<CapturedInput>;
+export declare function text(bytes: Buffer): string;
+export declare function parseYaml(bytes: Buffer): ParsedData;
+export declare function parseJson(bytes: Buffer): ParsedData;

package/dist/src/core/data.js

@@ -0,0 +1,136 @@
+import { open, realpath, stat as pathStat } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { resolve, relative, isAbsolute, sep } from 'node:path';
+import { parseAllDocuments, isAlias, isMap, isSeq } from 'yaml';
+export const MAX_BYTES = 1048576;
+export class DataError extends Error {
+    code;
+    field;
+    constructor(code, field, message) {
+        super(message);
+        this.code = code;
+        this.field = field;
+        this.name = 'DataError';
+    }
+}
+export function fail(code, field, message) { throw new DataError(code, field, message); }
+export function record(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
+export function keys(value, allowed, field) {
+    for (const k of Object.keys(value))
+        if (!allowed.includes(k))
+            fail('UNKNOWN_KEY', field, 'Unknown property.');
+}
+export function nonblank(value) { return typeof value === 'string' && value.trim().length > 0; }
+export function validId(value) { return typeof value === 'string' && /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(value) && !['constructor', 'prototype', '__proto__'].includes(value); }
+export async function capture(file, allowedRoot) {
+    let handle;
+    try {
+        const path = await realpath(resolve(file));
+        const contained = (candidate) => {
+            if (!allowedRoot)
+                return;
+            const rel = relative(allowedRoot, candidate);
+            if (!rel || rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel))
+                fail('POLICY_OUTSIDE', '', 'Policy resolves outside template directory.');
+        };
+        contained(path);
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        const before = await handle.stat();
+        if (!before.isFile())
+            fail('INPUT_TYPE', '', 'Input must be a regular file.');
+        if (before.size > MAX_BYTES)
+            fail('INPUT_LIMIT', '', 'Input exceeds 1 MiB.');
+        const verifyLocation = async () => {
+            if (allowedRoot && await realpath(allowedRoot) !== allowedRoot)
+                fail('INPUT_CHANGED', '', 'Template root changed during capture.');
+            const currentPath = await realpath(resolve(file));
+            contained(currentPath);
+            if (currentPath !== path)
+                fail('INPUT_CHANGED', '', 'Input location changed during capture.');
+            const current = await pathStat(currentPath);
+            if (current.dev !== before.dev || current.ino !== before.ino)
+                fail('INPUT_CHANGED', '', 'Input identity changed during capture.');
+        };
+        await verifyLocation(); // Validate the opened descriptor before reading bytes.
+        const bytes = Buffer.alloc(MAX_BYTES + 1);
+        let length = 0;
+        while (length < bytes.length) {
+            const part = await handle.read(bytes, length, bytes.length - length, null);
+            if (!part.bytesRead)
+                break;
+            length += part.bytesRead;
+        }
+        if (length > MAX_BYTES)
+            fail('INPUT_LIMIT', '', 'Input exceeds 1 MiB.');
+        await verifyLocation();
+        const after = await handle.stat();
+        if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+            fail('INPUT_CHANGED', '', 'Input changed during capture.');
+        return { path, bytes: Buffer.from(bytes.subarray(0, length)) };
+    }
+    catch (e) {
+        if (e instanceof DataError)
+            throw e;
+        return fail('INPUT_READ', '', 'Unable to read input file.');
+    }
+    finally {
+        await handle?.close();
+    }
+}
+export function text(bytes) {
+    if (bytes.length > MAX_BYTES)
+        fail('INPUT_LIMIT', '', 'Input exceeds 1 MiB.');
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        fail('ENCODING', '', 'Input must be UTF-8.');
+    }
+}
+export function parseYaml(bytes) {
+    try {
+        const docs = parseAllDocuments(text(bytes), { uniqueKeys: true, prettyErrors: false, strict: true });
+        if (docs.length !== 1)
+            fail('YAML_DOCUMENT', '', 'Exactly one YAML document is required.');
+        const doc = docs[0];
+        if (doc.errors.length || doc.warnings.length)
+            fail('YAML_INVALID', '', 'Invalid YAML or duplicate keys.');
+        const stack = [{ node: doc.contents, depth: 0 }];
+        const tags = new Set(['tag:yaml.org,2002:str', 'tag:yaml.org,2002:int', 'tag:yaml.org,2002:float', 'tag:yaml.org,2002:bool', 'tag:yaml.org,2002:null', 'tag:yaml.org,2002:map', 'tag:yaml.org,2002:seq']);
+        while (stack.length) {
+            const { node, depth } = stack.pop();
+            if (depth > 32)
+                fail('INPUT_DEPTH', '', 'Input nesting exceeds 32.');
+            if (isAlias(node))
+                fail('YAML_ALIAS', '', 'YAML aliases are not supported.');
+            if (record(node) && typeof node.tag === 'string' && !tags.has(node.tag))
+                fail('YAML_TAG', '', 'Custom YAML tags are not supported.');
+            if (isMap(node))
+                for (const pair of node.items) {
+                    stack.push({ node: pair.key, depth: depth + 1 }, { node: pair.value, depth: depth + 1 });
+                }
+            else if (isSeq(node))
+                for (const item of node.items)
+                    stack.push({ node: item, depth: depth + 1 });
+        }
+        return doc.toJS({ maxAliasCount: 0 });
+    }
+    catch (e) {
+        if (e instanceof DataError)
+            throw e;
+        fail('YAML_INVALID', '', 'Invalid YAML.');
+    }
+}
+export function parseJson(bytes) {
+    try {
+        const raw = text(bytes);
+        const value = JSON.parse(raw);
+        parseYaml(bytes); // JSON syntax is a YAML subset; detect decoded duplicate keys.
+        return value;
+    }
+    catch (e) {
+        if (e instanceof DataError)
+            throw e;
+        fail('JSON_INVALID', '', 'Invalid JSON.');
+    }
+}

package/dist/src/core/draft.d.ts

@@ -0,0 +1,6 @@
+import type { CapturedInput, TemplateBundle, ValidatedIssue, ValidationProblem } from './types.js';
+export declare function loadDraft(path: string): Promise<CapturedInput>;
+export declare function validateDraft(input: CapturedInput, bundle: TemplateBundle): {
+    issue?: ValidatedIssue;
+    problems: ValidationProblem[];
+};

package/dist/src/core/draft.js

@@ -0,0 +1,92 @@
+import { capture, parseJson, record, keys, nonblank, fail, DataError } from './data.js';
+import { validateLabelNames } from './labels-input.js';
+export async function loadDraft(path) { return capture(path); }
+function string(value, f, path) {
+    if (!nonblank(value))
+        fail('FIELD_REQUIRED', path, 'Expected nonblank text.');
+    if (f.type === 'string' && /[\r\n]/.test(value))
+        fail('FIELD_SINGLE_LINE', path, 'Expected a single line.');
+    const n = Array.from(value).length;
+    if ((f.minLength !== undefined && n < f.minLength) || (f.maxLength !== undefined && n > f.maxLength))
+        fail('FIELD_LENGTH', path, 'Text length is outside allowed range.');
+    if (f.options && !f.options.includes(value))
+        fail('FIELD_OPTION', path, 'Value is not an allowed option.');
+}
+function field(value, f) {
+    if (['string', 'text'].includes(f.type)) {
+        string(value, f, 'fields.' + f.id);
+        return;
+    }
+    if (!Array.isArray(value) || (f.required && !value.length) || (f.minItems !== undefined && value.length < f.minItems) || (f.maxItems !== undefined && value.length > f.maxItems))
+        fail('FIELD_ITEMS', 'fields.' + f.id, 'Invalid list size or type.');
+    if (f.type === 'string-list') {
+        for (const v of value)
+            string(v, { ...f, type: 'text' }, 'fields.' + f.id);
+        return;
+    }
+    const seen = new Set();
+    for (const v of value) {
+        if (!record(v))
+            fail('CRITERION_INVALID', 'fields.' + f.id, 'Criterion must be an object.');
+        keys(v, ['id', 'requirement', 'verification', 'expectedResult'], 'fields.' + f.id);
+        for (const k of ['id', 'requirement', 'verification', 'expectedResult'])
+            if (!nonblank(v[k]))
+                fail('CRITERION_REQUIRED', 'fields.' + f.id, 'All criterion attributes are required.');
+        const id = v.id;
+        if (seen.has(id))
+            fail('CRITERION_DUPLICATE', 'fields.' + f.id, 'Duplicate criterion ID.');
+        seen.add(id);
+    }
+}
+export function validateDraft(input, bundle) {
+    try {
+        const value = parseJson(input.bytes);
+        const t = bundle.template;
+        if (!record(value))
+            fail('DRAFT_TYPE', '', 'Draft must be an object.');
+        keys(value, ['version', 'template', 'repo', 'title', 'parentIssue', 'labels', 'fields', 'agents'], 'draft');
+        if (value.version !== 1 || value.template !== t.id)
+            fail('DRAFT_TEMPLATE', 'template', 'Draft template does not match.');
+        if (typeof value.repo !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9-]{0,99}\/[a-zA-Z0-9_.][a-zA-Z0-9_.-]{0,99}$/.test(value.repo) || value.repo.endsWith('/.') || value.repo.endsWith('/..'))
+            fail('DRAFT_REPO', 'repo', 'Expected OWNER/REPO.');
+        if (!nonblank(value.title) || /[\r\n\u0000-\u001f\u007f]/.test(value.title) || Array.from(value.title).length > 256)
+            fail('DRAFT_TITLE', 'title', 'Expected a nonblank single-line title up to 256 characters.');
+        if (value.labels !== undefined)
+            validateLabelNames(value.labels);
+        if (t.kind === 'task' && (!Number.isSafeInteger(value.parentIssue) || value.parentIssue < 1))
+            fail('DRAFT_PARENT', 'parentIssue', 'A positive parent issue is required.');
+        if (t.kind === 'parent' && value.parentIssue !== undefined)
+            fail('DRAFT_PARENT', 'parentIssue', 'Parent issue must not specify a parent.');
+        if (!record(value.fields))
+            fail('DRAFT_FIELDS', 'fields', 'Fields must be an object.');
+        keys(value.fields, t.fields.map(f => f.id), 'fields');
+        for (const f of t.fields) {
+            const present = Object.hasOwn(value.fields, f.id);
+            if (!present && !f.required)
+                continue;
+            field(present ? value.fields[f.id] : undefined, f);
+        }
+        if (!record(value.agents))
+            fail('DRAFT_AGENTS', 'agents', 'Agents must be an object.');
+        keys(value.agents, t.agents, 'agents');
+        for (const agent of t.agents) {
+            const a = Object.hasOwn(value.agents, agent) ? value.agents[agent] : undefined;
+            if (!record(a))
+                fail('AGENT_REQUIRED', 'agents.' + agent, 'Agent assignment is required.');
+            keys(a, ['model', 'thinking', 'reason', 'upperTierApproval'], 'agents.' + agent);
+            if (!nonblank(a.model) || !nonblank(a.thinking) || !nonblank(a.reason))
+                fail('AGENT_REQUIRED', 'agents.' + agent, 'Model, thinking and reason are required.');
+            const profile = bundle.policy.agents[agent]?.find(p => p.model === a.model && p.thinking === a.thinking);
+            if (!profile)
+                fail('AGENT_PROFILE', 'agents.' + agent, 'Model/thinking combination is not allowed for this agent.');
+            if (profile.tier === 'upper' && !nonblank(a.upperTierApproval))
+                fail('AGENT_APPROVAL', 'agents.' + agent, 'Upper profile requires an approval record.');
+            if (a.upperTierApproval !== undefined && !nonblank(a.upperTierApproval))
+                fail('AGENT_APPROVAL', 'agents.' + agent, 'Approval record must be nonblank.');
+        }
+        return { issue: { draft: value, bundle, draftInput: input }, problems: [] };
+    }
+    catch (e) {
+        return { problems: [e instanceof DataError ? { code: e.code, path: e.field, message: e.message } : { code: 'INPUT_INVALID', path: '', message: 'Invalid input.' }] };
+    }
+}

package/dist/src/core/forms.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateBundle } from './types.js';
+export declare function renderForm(bundle: TemplateBundle): string;
+export declare function writeForm(path: string, content: string, overwrite?: boolean): Promise<void>;

package/dist/src/core/forms.js

@@ -0,0 +1,54 @@
+import { stringify } from 'yaml';
+import { open } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { fail, DataError } from './data.js';
+export function renderForm(bundle) {
+    const { template: t, policy: p } = bundle, body = [{ type: 'markdown', attributes: { value: 'このフォームは共通YAMLから生成されています。CLIの全検査（担当別の条件・上位承認等）をGitHub上で強制するものではありません。モデル利用承認と投稿承認を別途確認してください。' } }];
+    const ids = new Set();
+    const add = (f) => {
+        if (f.id) {
+            if (ids.has(f.id))
+                fail('FORM_ID_COLLISION', '', 'Generated form IDs collide.');
+            ids.add(f.id);
+        }
+        body.push(f);
+    };
+    if (t.kind === 'task')
+        add({ type: 'input', id: 'parent-issue', attributes: { label: '親Issue', description: '同じrepositoryの親Issue番号' }, validations: { required: true } });
+    for (const f of t.fields) {
+        const id = 'field-' + f.id.toLowerCase();
+        let type = f.type === 'string' ? 'input' : 'textarea';
+        if (f.options)
+            type = 'dropdown';
+        add({ type, id, attributes: { label: f.label, ...(f.description ? { description: f.description } : {}), ...(f.options ? { options: f.options, ...(f.type === 'string-list' ? { multiple: true } : {}) } : {}),
+                ...(!f.options && ['string-list', 'criteria'].includes(f.type) ? { description: (f.description ?? '') + '\nJSON配列で入力してください。criteriaの各要素: id, requirement, verification, expectedResult。' } : {}) }, validations: { required: f.required } });
+    }
+    for (const agent of t.agents) {
+        const prefix = 'agent-' + agent.toLowerCase(), profiles = p.agents[agent];
+        add({ type: 'dropdown', id: prefix + '-profile', attributes: { label: agent + ' モデル / thinking', options: profiles.map(x => x.model + ' / ' + x.thinking + ' (' + x.tier + ')') }, validations: { required: true } });
+        add({ type: 'textarea', id: prefix + '-reason', attributes: { label: agent + ' 選定理由' }, validations: { required: true } });
+        if (profiles.some(x => x.tier === 'upper'))
+            add({ type: 'textarea', id: prefix + '-approval', attributes: { label: agent + ' 上位利用の承認記録', description: 'upperを選ぶ場合はユーザー承認の参照・説明が必要。basicの場合は不要。' }, validations: { required: false } });
+    }
+    return stringify({ name: t.name, description: t.description, body });
+}
+export async function writeForm(path, content, overwrite = false) {
+    let handle;
+    try {
+        handle = await open(path, overwrite ? constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW : constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        if (!(await handle.stat()).isFile())
+            fail('OUTPUT_TYPE', '', 'Output must be a regular file.');
+        if (overwrite)
+            await handle.truncate(0);
+        await handle.writeFile(content, 'utf8');
+        await handle.sync();
+    }
+    catch (e) {
+        if (e instanceof DataError)
+            throw e;
+        fail('OUTPUT_WRITE', '', 'Cannot write output; existing files need --overwrite and symlinks are refused.');
+    }
+    finally {
+        await handle?.close();
+    }
+}

package/dist/src/core/gh-process.d.ts

@@ -0,0 +1,13 @@
+export type GhOptions = {
+    ghExecutable?: string;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    beforeStart?: () => boolean;
+};
+export type GhResult = {
+    status: 'ok' | 'not-started' | 'unknown';
+    stdout: string;
+};
+export declare function runGh(args: string[], body: string, options?: GhOptions): Promise<GhResult>;

package/dist/src/core/gh-process.js

@@ -0,0 +1,55 @@
+import { spawn } from 'node:child_process';
+export function runGh(args, body, options = {}) {
+    const timeout = options.timeoutMs ?? 60000, max = options.maxOutputBytes ?? 1048576;
+    if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 60000 || !Number.isSafeInteger(max) || max < 1 || max > 1048576 || Buffer.byteLength(body) > 1048576)
+        return Promise.resolve({ status: 'not-started', stdout: '' });
+    return new Promise(resolve => {
+        const group = process.platform !== 'win32';
+        let child;
+        try {
+            if (options.signal?.aborted || options.beforeStart?.() === false || options.signal?.aborted)
+                return resolve({ status: 'not-started', stdout: '' });
+            child = spawn(options.ghExecutable ?? 'gh', args, { shell: false, detached: group, env: { ...process.env, ...options.env, GH_HOST: 'github.com' }, stdio: ['pipe', 'pipe', 'pipe'] });
+        }
+        catch {
+            return resolve({ status: 'not-started', stdout: '' });
+        }
+        let started = false, failed = false, settled = false, stopping = false, stdoutBytes = 0, stderrBytes = 0;
+        const chunks = [];
+        let cleanup;
+        const signal = (kind) => { try {
+            if (group && child.pid)
+                process.kill(-child.pid, kind);
+            else
+                child.kill(kind);
+        }
+        catch { /* Owned process already gone. */ } };
+        const finish = (status) => { if (settled)
+            return; settled = true; clearTimeout(timer); if (cleanup)
+            clearTimeout(cleanup); options.signal?.removeEventListener('abort', abort); if (stopping && started)
+            signal('SIGKILL'); child.stdin.destroy(); child.stdout.destroy(); child.stderr.destroy(); resolve({ status, stdout: Buffer.concat(chunks).toString('utf8') }); };
+        const abort = () => { if (settled || stopping)
+            return; stopping = true; failed = true; if (started)
+            signal('SIGTERM'); cleanup = setTimeout(() => { if (started)
+            signal('SIGKILL'); finish(started ? 'unknown' : 'not-started'); }, 100); };
+        const timer = setTimeout(abort, timeout);
+        child.once('spawn', () => { started = true; if (stopping)
+            signal('SIGTERM'); });
+        child.once('error', () => { failed = true; if (!started)
+            finish('not-started');
+        else
+            abort(); });
+        child.stdout.on('data', (b) => { stdoutBytes += b.length; if (stdoutBytes > max)
+            return abort(); chunks.push(b); });
+        child.stderr.on('data', (b) => { stderrBytes += b.length; if (stderrBytes > max)
+            abort(); });
+        child.stdin.on('error', abort);
+        child.stdout.on('error', abort);
+        child.stderr.on('error', abort);
+        child.once('close', (code, signal) => finish(!started ? 'not-started' : !failed && code === 0 && !signal ? 'ok' : 'unknown'));
+        options.signal?.addEventListener('abort', abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        child.stdin.end(body);
+    });
+}

package/dist/src/core/issue-labels.d.ts

@@ -0,0 +1,9 @@
+import { GhClient, type Repository, type Label } from './labels-github.js';
+import type { Preview, ValidatedIssue, SubmitOutcome } from './types.js';
+import type { GhOptions } from './gh-process.js';
+export type IssueLabelPreview = Preview & {
+    labelState?: Label[];
+    repository?: Repository;
+};
+export declare function createIssuePreview(issue: ValidatedIssue, options?: GhOptions, client?: GhClient): Promise<IssueLabelPreview>;
+export declare function submitLabelledIssue(issue: ValidatedIssue, digest: string, options?: GhOptions): Promise<SubmitOutcome>;

package/dist/src/core/issue-labels.js

@@ -0,0 +1,52 @@
+import { createPreview } from './approval.js';
+import { GhClient, repositoryLabels, requireLabels, parseIssue, readIssue, repositoryIdentity } from './labels-github.js';
+import { sha } from './labels-approval.js';
+import { renderIssue } from './render.js';
+import { maskDecodedSecrets } from './secrets.js';
+import { record, parseJson } from './data.js';
+export async function createIssuePreview(issue, options = {}, client) {
+    const base = createPreview(issue);
+    if (!issue.draft.labels?.length || base.sensitive)
+        return base;
+    const gh = client ?? new GhClient(issue.draft.repo, options);
+    const repository = await repositoryIdentity(gh);
+    const labels = requireLabels(await repositoryLabels(gh), issue.draft.labels);
+    const masked = maskDecodedSecrets({ repository, labels });
+    const state = masked.value;
+    return { ...base, repository: state.repository, labels: state.labels.map(l => l.name), labelState: state.labels, digest: sha(JSON.stringify({ version: 1, host: 'github.com', issueDigest: base.digest, repository, labels })), sensitive: base.sensitive || masked.sensitive };
+}
+export async function submitLabelledIssue(issue, digest, options = {}) {
+    const client = new GhClient(issue.draft.repo, options);
+    let preview;
+    try {
+        preview = await createIssuePreview(issue, options, client);
+    }
+    catch {
+        return { status: 'rejected', problems: [{ code: 'LABEL_PREFLIGHT', path: 'labels', message: 'Cannot confirm requested labels. No Issue created.' }] };
+    }
+    if (preview.sensitive)
+        return { status: 'rejected', problems: [{ code: 'SENSITIVE', path: 'labels', message: 'Remove secret candidates before submission.' }] };
+    if (preview.digest !== digest)
+        return { status: 'rejected', problems: [{ code: 'APPROVAL_MISMATCH', path: '', message: 'Input or labels changed; preview and approve again.' }] };
+    const fixed = renderIssue(issue);
+    const result = await client.request('POST', 'issues', { title: fixed.title, body: fixed.body, labels: preview.labels });
+    if (result.status === 'not-started')
+        return { status: 'not-started', message: 'Issue creation process did not start.' };
+    const uncertain = { status: 'unknown', message: 'Issue creation outcome is uncertain. Check GitHub manually before retrying.' };
+    if (result.status !== 'ok')
+        return uncertain;
+    try {
+        const raw = parseJson(Buffer.from(result.stdout));
+        const created = parseIssue(raw, fixed.repo);
+        if (!record(raw) || raw.title !== fixed.title || raw.body !== fixed.body || created.identity.kind !== 'issue')
+            return uncertain;
+        const current = await readIssue(client, created.identity.number);
+        const confirmed = await client.read('issues/' + created.identity.number);
+        if (current.identity.id !== created.identity.id || current.identity.node_id !== created.identity.node_id || JSON.stringify(current.labels) !== JSON.stringify(preview.labelState) || !record(confirmed) || confirmed.title !== fixed.title || confirmed.body !== fixed.body)
+            return { ...uncertain, candidateUrl: created.identity.url };
+        return { status: 'created', url: created.identity.url };
+    }
+    catch {
+        return uncertain;
+    }
+}

package/dist/src/core/labels-apply.d.ts

@@ -0,0 +1,12 @@
+import type { CapturedInput, ValidationProblem } from './types.js';
+import type { GhOptions } from './gh-process.js';
+export type LabelOutcome = {
+    status: 'applied' | 'noop';
+} | {
+    status: 'rejected';
+    problems: ValidationProblem[];
+} | {
+    status: 'not-started' | 'unknown';
+    message: string;
+};
+export declare function applyLabelChange(input: CapturedInput, digest: string, options?: GhOptions): Promise<LabelOutcome>;