From 30f17d569ac657e7d1744318f00ba301f6dbc573 Mon Sep 17 00:00:00 2001 From: garrytan Date: Thu, 8 Oct 2026 08:06:30 +0000 Subject: [PATCH 1/4] fix(autoplan): the publication hook approves /autoplan's own Reads after the skill turn Claude Code applies a skill's allowed-tools only to the turn that invoked it. On 2.1.292 the default fork-subagent mode runs reviewers in the background, and the completion notice starts a new turn, so later Reads outside the working directory (the next phase's section file, the close packet) raised permission cards. Skill hooks stay registered for the session, and a PreToolUse "allow" skips the card (reproduced in a PTY on 2.1.292). autoplan/bin/owned-read.ts approves a parent Read only when the guard itself returned no output, and only for this installation's autoplan/sections/*.md (canonical path or the gbrain :user render) or an immutable phase artifact in /.gstack/tmp/autoplan/autoplan--*/ whose repo is the session's project directory or contains it. Denials, unverified allows, child calls and every other path are unchanged. renderSectionBase and userRenderRoot move there with it. Tests that asserted a verified driver Read as {} now expect the approval; autoplan-owned-read covers the shipped shim, the close packet without a journal, verified artifacts through the guard, look-alikes (foreign install, writable copy, symlink alias, other repository, other names) and a guard denial staying a denial. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- autoplan/bin/owned-read.ts | 72 ++++++++++++ autoplan/bin/phase-publication-hook.ts | 20 +--- test/autoplan-bounded-journal.test.ts | 9 +- test/autoplan-long-session-observer.test.ts | 3 +- test/autoplan-owned-read.test.ts | 120 ++++++++++++++++++++ test/autoplan-publication-guard.test.ts | 36 +++--- test/autoplan-publication-hook.test.ts | 7 +- test/autoplan-publication-payload.test.ts | 13 ++- test/helpers/autoplan-guard-fixture.ts | 8 +- test/helpers/touchfiles-data.ts | 6 +- 10 files changed, 241 insertions(+), 53 deletions(-) create mode 100644 autoplan/bin/owned-read.ts create mode 100644 test/autoplan-owned-read.test.ts diff --git a/autoplan/bin/owned-read.ts b/autoplan/bin/owned-read.ts new file mode 100644 index 000000000..2339d01c7 --- /dev/null +++ b/autoplan/bin/owned-read.ts @@ -0,0 +1,72 @@ +/** + * /autoplan's own read-only inputs, approved without a permission card. + * + * Claude Code clears a skill's `allowed-tools` grant when the next turn starts, + * and a background reviewer's completion notice starts one. The skill's hooks + * stay registered for the session, so this hook re-approves exactly the files + * /autoplan itself reads outside the working directory: its installed section + * files, and the immutable phase artifacts in a project's `.gstack/tmp/autoplan/` + * when the session started below the repository root. It never denies; anything + * else keeps Claude Code's own permission check. Skill hooks do not run inside + * subagents, so reviewer inputs live in the project, which needs no approval. + */ +import * as fs from 'node:fs'; +import * as path from 'node:path'; +import * as os from 'node:os'; +import { nativePathSpelling, sameNativePath } from '../../lib/claude-journal-records'; +import { resolveStateRoot } from '../../lib/state-root'; + +/** setup's `${GSTACK_USER_RENDER_DIR:-$GSTACK_STATE_ROOT/render/claude}`, realpath'd. */ +export function userRenderRoot(): string | undefined { + const configured = process.env.GSTACK_USER_RENDER_DIR || path.join(resolveStateRoot(), 'render', 'claude'); + try { return fs.realpathSync(path.resolve(nativePathSpelling(configured))); } catch { return; } +} + +/** scripts/gen-skill-docs.ts rewriteSectionBase, which writes that render. */ +export function renderSectionBase(content: string, linkRoot: string): string { + return content.replace( + /~\/\.claude\/skills\/gstack\/([^\s)`"'*]+\/sections\/)/g, + (_m, p1: string) => `${linkRoot}/${p1}`, + ); +} + +const ARTIFACT_DIR = /^autoplan-(ceo|design|dx|eng)-[^\\/]+$/; +const artifactFiles = (phase: string) => ['methodology.md', 'methodology.json', 'native-prompt.md', 'snapshot.json', + 'source-implementation.md', `${phase}-implementation.md`, 'close-packet.md']; + +/** True only for this installation's autoplan/sections/*.md, or an immutable artifact in + * /.gstack/tmp/autoplan/autoplan--*\/ where is the session's project directory or contains it. */ +export function ownedAutoplanRead(file: unknown, cwd: string, root: string): boolean { + if (typeof file !== 'string') return false; + try { + const requested = nativePathSpelling(path.resolve(cwd, file.replace(/^~(?=[\\/]|$)/, () => os.homedir()))); + const base = path.basename(requested), directory = path.dirname(requested), actual = fs.realpathSync(requested); + if (path.basename(directory) === 'sections' && path.basename(path.dirname(directory)) === 'autoplan') { + const canonical = path.join(root, 'autoplan', 'sections', base); + if (!/^[a-z0-9-]+\.md$/.test(base) || !fs.lstatSync(canonical).isFile()) return false; + if (sameNativePath(actual, canonical)) return true; + const render = userRenderRoot(); + return !!render && sameNativePath(actual, path.join(render, 'autoplan', 'sections', base)) && + fs.readFileSync(actual, 'utf8') === renderSectionBase(fs.readFileSync(canonical, 'utf8'), render); + } + const phase = ARTIFACT_DIR.exec(path.basename(directory))?.[1]; + if (!phase || !artifactFiles(phase).includes(base) || !sameNativePath(actual, requested)) return false; + const stat = fs.lstatSync(requested), store = path.dirname(directory), owner = path.dirname(path.dirname(path.dirname(store))); + const project = fs.realpathSync(nativePathSpelling(process.env.CLAUDE_PROJECT_DIR || cwd)); + return stat.isFile() && sameNativePath(store, path.join(owner, '.gstack', 'tmp', 'autoplan')) && + (sameNativePath(project, owner) || nativePathSpelling(project).startsWith(nativePathSpelling(owner) + path.sep)) && + (process.platform === 'win32' || (stat.mode & 0o777) === 0o444); + } catch { return false; } +} + +export const OWNED_READ_APPROVAL = Object.freeze({ hookSpecificOutput: Object.freeze({ hookEventName: 'PreToolUse', + permissionDecision: 'allow', permissionDecisionReason: '[autoplan] Reading an /autoplan section or phase artifact.' }) }); + +/** The guard's own verdict wins: only a parent Read the guard left without any output is approved. */ +export function approveOwnedRead(value: unknown, output: object, root: string): object { + if (Object.keys(output).length || value === null || typeof value !== 'object') return output; + const input = value as Record; + if (input.tool_name !== 'Read' || input.agent_id || typeof input.cwd !== 'string' || + !ownedAutoplanRead(input.tool_input?.file_path, input.cwd, root)) return output; + return OWNED_READ_APPROVAL; +} diff --git a/autoplan/bin/phase-publication-hook.ts b/autoplan/bin/phase-publication-hook.ts index e069926a3..44a50a85f 100644 --- a/autoplan/bin/phase-publication-hook.ts +++ b/autoplan/bin/phase-publication-hook.ts @@ -11,9 +11,9 @@ import { autoplanPhaseCompletions } from '../../lib/autoplan-phase-publication'; import { nativePathSpelling, ownedNativePath, sameNativePath, type ClaudeParentPublicEvent } from '../../lib/claude-journal-records'; import { ownedRecordLimit, ownedRetainedLimit, type JournalPrefix, type OwnedRead, type OwnedReadMeasure } from '../../lib/claude-owned-journal'; import { readGuardJournal, textResult, DEDUP_REPLY } from './guard-journal'; -import { resolveStateRoot } from '../../lib/state-root'; import { REASONS, reasonCode, reasonText, type Detail, type ReasonCode } from './guard-reasons'; import { logGuardDecision } from './guard-log'; +import { approveOwnedRead, renderSectionBase, userRenderRoot } from './owned-read'; const PHASES = ['ceo', 'design', 'dx', 'eng', 'tasks'] as const; type Phase = typeof PHASES[number]; @@ -129,20 +129,6 @@ function driver(file: unknown, cwd: string, root: string): Phase | undefined { return fail('foreign_install'); } -/** setup's `${GSTACK_USER_RENDER_DIR:-$GSTACK_STATE_ROOT/render/claude}`, realpath'd. */ -function userRenderRoot(): string | undefined { - const configured = process.env.GSTACK_USER_RENDER_DIR || path.join(resolveStateRoot(), 'render', 'claude'); - try { return fs.realpathSync(path.resolve(nativePathSpelling(configured))); } catch { return; } -} - -/** scripts/gen-skill-docs.ts rewriteSectionBase, which writes that render. */ -function renderSectionBase(content: string, linkRoot: string): string { - return content.replace( - /~\/\.claude\/skills\/gstack\/([^\s)`"'*]+\/sections\/)/g, - (_m, p1: string) => `${linkRoot}/${p1}`, - ); -} - interface Consumer { phase: Phase; content?: string; kind: 'Read' | 'Agent' } function artifactName(file: unknown, cwd: string, includeClose = false): Phase | undefined { if (typeof file !== 'string') return; @@ -688,6 +674,10 @@ export function ownedRead(journal: string, owners: string[], input: PublicationH * read. Claude Code's appends never fail a read; a changed prefix is `rewritten`. */ export async function runPublicationHook(value: unknown, root: string): Promise { + return approveOwnedRead(value, await guardOutput(value, root), root); +} + +async function guardOutput(value: unknown, root: string): Promise { let version: string | undefined; try { if (!object(value) || value.hook_event_name !== 'PreToolUse' || typeof value.tool_name !== 'string') return denied('hook_input'); diff --git a/test/autoplan-bounded-journal.test.ts b/test/autoplan-bounded-journal.test.ts index 7b27fc91f..768d50c2a 100644 --- a/test/autoplan-bounded-journal.test.ts +++ b/test/autoplan-bounded-journal.test.ts @@ -11,6 +11,7 @@ import { guardFixture, section, denial, codeOf, ROOT, type GuardFixture } from ' import { ownedRead } from '../autoplan/bin/phase-publication-hook.ts'; import { DEDUP_REPLY } from '../autoplan/bin/guard-journal'; import { readOwnedClaudePublicTranscript, ownedRetainedLimit, OWNED_RETAINED_MAX_BYTES, type OwnedReadMeasure } from '../lib/claude-owned-journal'; +import { OWNED_READ_APPROVAL } from '../autoplan/bin/owned-read'; const RECORD = 32 * 1024, RETAINED = 64 * 1024; const fixtures: GuardFixture[] = []; @@ -52,7 +53,7 @@ const next = (f: GuardFixture) => { f.use('next', 'Read', { file_path: section(' describe('A2: the guard decides on a journal larger than its shrunk bounds', () => { test('a published Phase 1 enters Phase 2; the same journal without the report is denied', async () => { const allowed = make(); allowed.publish(); const input = next(allowed); long(allowed); - expect(await bounded(() => allowed.hook(input))).toEqual({}); + expect(await bounded(() => allowed.hook(input))).toEqual(OWNED_READ_APPROVAL); expect(allowed.log().at(-1)).toMatchObject({ decision: 'allow', disposition: 'allow', path: 'journal' }); const unpublished = make(); const blocked = next(unpublished); long(unpublished); const output = await bounded(() => unpublished.hook(blocked)); @@ -83,7 +84,7 @@ describe('A2: the guard decides on a journal larger than its shrunk bounds', () test('a run started by a typed request and the Skill tool (no /autoplan slash turn) binds its init', async () => { const f = make('ceo', { opening: 'skill' }); f.publish(); const input = next(f); long(f); - expect(await bounded(() => f.hook(input))).toEqual({}); + expect(await bounded(() => f.hook(input))).toEqual(OWNED_READ_APPROVAL); const unpublished = make('ceo', { opening: 'skill' }); const blocked = next(unpublished); long(unpublished); expect(codeOf(await bounded(() => unpublished.hook(blocked)))).toBe('publication_missing'); }); @@ -129,7 +130,7 @@ describe('A2: append-tolerant reads with prefix identity', () => { const grown = fs.statSync(f.transcript).size; for (let i = 0; i < 50 && fs.statSync(f.transcript).size === grown; i++) await Bun.sleep(10); expect(fs.statSync(f.transcript).size).toBeGreaterThan(grown); - expect(await f.hook(input)).toEqual({}); + expect(await f.hook(input)).toEqual(OWNED_READ_APPROVAL); } finally { appender.kill(); await appender.exited; } }); @@ -185,6 +186,6 @@ describe('A2: append-tolerant reads with prefix identity', () => { // A record still being written (no newline yet) is not evidence: the read ends at the last complete line. const partial = make(); partial.publish(); const current = next(partial); long(partial); fs.appendFileSync(partial.transcript, JSON.stringify({ type: 'assistant', sessionId: partial.sessionId }).slice(0, -2)); - expect(await bounded(() => partial.hook(current))).toEqual({}); + expect(await bounded(() => partial.hook(current))).toEqual(OWNED_READ_APPROVAL); }); }); diff --git a/test/autoplan-long-session-observer.test.ts b/test/autoplan-long-session-observer.test.ts index 40226f679..f1aadbe53 100644 --- a/test/autoplan-long-session-observer.test.ts +++ b/test/autoplan-long-session-observer.test.ts @@ -11,6 +11,7 @@ import { randomUUID } from 'node:crypto'; import { guardFixture, section, type GuardFixture } from './helpers/autoplan-guard-fixture'; import { padBeforeCompactBoundary } from './helpers/journal-padding'; import { readPlanCountTranscript } from '../lib/claude-public-transcript'; +import { OWNED_READ_APPROVAL } from '../autoplan/bin/owned-read'; const fixtures: GuardFixture[] = []; const prior = process.env.GSTACK_TRANSCRIPT_TEST_MAX_BYTES; @@ -44,7 +45,7 @@ test('a padded long-session journal: the counting reader refuses it, the guard l process.env.GSTACK_TRANSCRIPT_TEST_MAX_BYTES = String(256 * 1024); const counting = readPlanCountTranscript(path.join(f.cwd, 'config'), f.cwd); expect(counting).toMatchObject({ status: 'error', reason: 'too_large' }); - expect(await f.hook(f.input('next', 'Read', { file_path: section('design-phase.md') }))).toEqual({}); + expect(await f.hook(f.input('next', 'Read', { file_path: section('design-phase.md') }))).toEqual(OWNED_READ_APPROVAL); expect(f.log()).toEqual([expect.objectContaining({ decision: 'allow', disposition: 'allow', code: null, path: 'payload' })]); }); diff --git a/test/autoplan-owned-read.test.ts b/test/autoplan-owned-read.test.ts new file mode 100644 index 000000000..f00323060 --- /dev/null +++ b/test/autoplan-owned-read.test.ts @@ -0,0 +1,120 @@ +/** + * After a background reviewer's completion notice starts a new turn, Claude Code + * no longer applies /autoplan's allowed-tools, so Reads outside the working + * directory raise permission cards. /autoplan writes its phase artifacts in the + * project's `.gstack/tmp/autoplan/`, and the publication hook (registered for + * the whole session) approves exactly /autoplan's own files, leaving every other + * Read, and every guard verdict, to Claude Code. + */ +import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test'; +import * as fs from 'node:fs'; +import * as path from 'node:path'; +import { tmpdir } from 'node:os'; +import { spawnSync } from 'node:child_process'; +import { initializePlan, prepareMethodology, createSnapshot, preparePhaseClose } from '../bin/gstack-autoplan-snapshot'; +import { runPublicationHook } from '../autoplan/bin/phase-publication-hook.ts'; +import { OWNED_READ_APPROVAL } from '../autoplan/bin/owned-read'; +import { guardFixture, section } from './helpers/autoplan-guard-fixture'; + +const ROOT = fs.realpathSync(path.join(import.meta.dir, '..')); +const SHIM = path.join(ROOT, 'autoplan/bin/phase-publication-hook'); +const dirs: string[] = []; +let logHome = '', previous: Record = {}; +beforeAll(() => { + logHome = fs.realpathSync(fs.mkdtempSync(path.join(tmpdir(), 'autoplan-owned-log-'))); + previous = { GSTACK_STATE_ROOT: process.env.GSTACK_STATE_ROOT, GSTACK_HOME: process.env.GSTACK_HOME, CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR }; + process.env.GSTACK_STATE_ROOT = logHome; process.env.GSTACK_HOME = logHome; delete process.env.CLAUDE_PROJECT_DIR; +}); +afterAll(() => { + for (const [k, v] of Object.entries(previous)) if (v === undefined) delete process.env[k]; else process.env[k] = v; + fs.rmSync(logHome, { recursive: true, force: true }); +}); +afterEach(() => { for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true }); }); +const scratch = (prefix: string) => { const d = fs.realpathSync(fs.mkdtempSync(path.join(tmpdir(), prefix))); dirs.push(d); return d; }; + +/** A real Phase 1 close with the restore point and artifacts in `/.gstack/tmp/autoplan/`, as Step 1 places them. */ +function ceoClose() { + const repo = scratch('autoplan-owned-repo-'), store = path.join(repo, '.gstack', 'tmp', 'autoplan'), session = path.join(repo, 'packages', 'app'); + fs.mkdirSync(store, { recursive: true }); fs.mkdirSync(session, { recursive: true }); + const source = path.join(repo, 'PLAN.md'), active = path.join(repo, 'active.md'), restore = path.join(store, 'main-autoplan-restore.md'); + fs.writeFileSync(source, '# Plan: greet\nAdd a greet command.\n'); + initializePlan(source, active, restore); + const skill = path.join(repo, 'SKILL.md'); + fs.writeFileSync(skill, '---\nname: plan-ceo-review\n---\n## Review Sections\nApply every criterion.\n'); + const method = prepareMethodology('ceo', skill, restore).methodologyPath; + const snapshot = createSnapshot('ceo', active, restore, method); + fs.appendFileSync(active, '\nNone: retain the current behavior.\n\n'); + return { repo, session, method, snapshot, packet: preparePhaseClose('ceo', active, snapshot.snapshotPath, restore, method).closePacketPath as string }; +} +const read = (cwd: string, file: string, extra: object = {}) => ({ hook_event_name: 'PreToolUse', session_id: 'parent', cwd, + transcript_path: path.join(cwd, 'no-config', 'projects', 'p', 'parent.jsonl'), tool_name: 'Read', tool_use_id: 'current', + tool_input: { file_path: file }, ...extra }); + +describe('/autoplan owned reads after the skill turn', () => { + test('the shipped hook approves the shared close section and the installed link spelling', () => { + const home = scratch('autoplan-owned-home-'), cwd = scratch('autoplan-owned-cwd-'); + fs.mkdirSync(path.join(home, '.claude', 'skills'), { recursive: true }); + fs.symlinkSync(ROOT, path.join(home, '.claude', 'skills', 'gstack'), 'dir'); + for (const file of [path.join(ROOT, 'autoplan/sections/phase-close.md'), path.join(home, '.claude/skills/gstack/autoplan/sections/phase-close.md')]) { + const child = spawnSync('bash', [SHIM], { input: JSON.stringify(read(cwd, file)), encoding: 'utf8', timeout: 8_000, + env: { ...process.env, HOME: home, PATH: `${path.dirname(process.execPath)}:${process.env.PATH ?? ''}` } }); + expect(child.status).toBe(0); + expect(JSON.parse(child.stdout)).toEqual(OWNED_READ_APPROVAL); + } + }); + + test('a session started below the repository root reads the close packet without a journal or a card', async () => { + const c = ceoClose(); + expect(await runPublicationHook(read(c.session, c.packet), ROOT)).toEqual(OWNED_READ_APPROVAL); + }); + + test('guarded phase artifacts and the next driver are approved once the guard verifies them', async () => { + const f = guardFixture('ceo', { restoreInProject: true }); + try { + const dir = path.dirname(f.snapshot.snapshotPath); + const files = [f.method, path.join(path.dirname(f.method), 'methodology.json'), f.snapshot.snapshotPath, + path.join(dir, 'snapshot.json'), path.join(dir, 'source-implementation.md'), path.join(dir, 'native-prompt.md'), f.packet.closePacketPath]; + for (const [i, file] of files.entries()) { + f.use(`artifact-${i}`, 'Read', { file_path: file }); f.journal(); + expect({ file, output: await f.hook(f.input(`artifact-${i}`, 'Read', { file_path: file })) }).toEqual({ file, output: OWNED_READ_APPROVAL }); + f.readResult(`artifact-${i}`, file); + } + f.publish(); f.use('next', 'Read', { file_path: section('design-phase.md') }); f.journal(); + expect(await f.hook(f.input('next', 'Read', { file_path: section('design-phase.md') }))).toEqual(OWNED_READ_APPROVAL); + // Six guarded artifact Reads and the Phase 2 entry, each a verified allow; the close packet is not a guarded Read. + expect(f.log().map(e => [e.decision, e.disposition])).toEqual(Array(7).fill(['allow', 'allow'])); + } finally { f.cleanup(); } + }); + + test('look-alikes and everything else keep Claude Code\'s own permission check', async () => { + const c = ceoClose(), other = ceoClose(); + const foreign = scratch('autoplan-owned-foreign-'); + fs.mkdirSync(path.join(foreign, 'autoplan', 'sections'), { recursive: true }); + fs.copyFileSync(path.join(ROOT, 'autoplan/sections/phase-close.md'), path.join(foreign, 'autoplan/sections/phase-close.md')); + const store = path.dirname(path.dirname(c.packet)); + const writable = path.join(store, 'autoplan-ceo-copy'), alias = path.join(store, 'autoplan-ceo-alias'); + fs.mkdirSync(writable); fs.copyFileSync(c.packet, path.join(writable, 'close-packet.md')); + fs.chmodSync(path.join(writable, 'close-packet.md'), 0o644); + fs.mkdirSync(alias); fs.symlinkSync(c.packet, path.join(alias, 'close-packet.md')); + fs.writeFileSync(path.join(path.dirname(c.packet), 'notes.md'), 'not an artifact\n', { mode: 0o444 }); + for (const file of [ + other.packet, + path.join(foreign, 'autoplan/sections/phase-close.md'), + path.join(ROOT, 'autoplan/sections/../SKILL.md'), + path.join(ROOT, 'autoplan/sections/manifest.json'), + path.join(ROOT, 'package.json'), + path.join(writable, 'close-packet.md'), + path.join(alias, 'close-packet.md'), + path.join(path.dirname(c.packet), 'notes.md'), + path.join(c.repo, 'PLAN.md'), + ]) expect({ file, output: await runPublicationHook(read(c.session, file), ROOT) }).toEqual({ file, output: {} }); + expect(await runPublicationHook(read(c.session, c.packet, { agent_id: 'reviewer-child' }), ROOT)).toEqual({}); + expect(await runPublicationHook({ ...read(c.session, c.packet), tool_name: 'Bash', tool_input: { command: `cat ${c.packet}` } }, ROOT)).toEqual({}); + }); + + test('a guard denial is never turned into an approval', async () => { + const cwd = scratch('autoplan-owned-deny-'); + const output: any = await runPublicationHook(read(cwd, path.join(ROOT, 'autoplan/sections/design-phase.md')), ROOT); + expect(output.hookSpecificOutput.permissionDecision).toBe('deny'); + }); +}); diff --git a/test/autoplan-publication-guard.test.ts b/test/autoplan-publication-guard.test.ts index c174b8c60..397701a44 100644 --- a/test/autoplan-publication-guard.test.ts +++ b/test/autoplan-publication-guard.test.ts @@ -9,6 +9,7 @@ import { readOwnedClaudePublicTranscript, readPlanCountTranscript, transcriptRea import { prematureAutoplanPhaseEntry } from './helpers/autoplan-method-read-audit'; import captured from './fixtures/autoplan-publication-boundary-361c.json'; import consumption from './fixtures/autoplan-phase-consumption-491.json'; +import { OWNED_READ_APPROVAL, renderSectionBase } from '../autoplan/bin/owned-read'; const ROOT = fs.realpathSync(path.join(import.meta.dir, '..')); // Every guarded decision appends to the guard log; keep it out of the real state root. @@ -167,7 +168,7 @@ describe('Autoplan parent publication guard', () => { expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))) .toMatchObject({ hookSpecificOutput: { permissionDecisionReason: expect.stringContaining('Publish the filled Phase 3') } }); f.events.pop(); f.message('Phase 3 complete.'); f.current(); f.journal(); - expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); for (const phase of ['ceo', 'design', 'dx', 'eng'] as const) @@ -297,7 +298,7 @@ describe('Autoplan parent publication guard', () => { test('native project ownership survives a Bash cd through the installed skill link', async () => { const { f } = changedDirectory(); expect(readOwnedClaudePublicTranscript(f.input.transcript_path, f.input.cwd, f.sessionId).transcript.status).toBe('missing'); - expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); test('native project ownership still requires publication and permits same-phase repair after cd', async () => { @@ -305,7 +306,7 @@ describe('Autoplan parent publication guard', () => { const output: any = await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT)); expect(output.hookSpecificOutput.permissionDecisionReason).toContain('Publish the filled Phase 1'); const same = changedDirectory(false, 'ceo-phase.md'); - expect(await withNativeProjectDirectory(same.f.cwd, () => runPublicationHook(same.f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(same.f.cwd, () => runPublicationHook(same.f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); test('the literal init parser retains Windows drive and UNC identities', () => { @@ -357,7 +358,7 @@ describe('Autoplan parent publication guard', () => { expect(size).toBeGreaterThan(record); await withReadLimit(record, async () => { expect(readOwnedClaudePublicTranscript(f.input.transcript_path, f.input.cwd, f.sessionId).transcript.status).toBe('ready'); - expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); const output: any = await withReadLimit(record - 1, async () => { expect(readOwnedClaudePublicTranscript(f.input.transcript_path, f.input.cwd, f.sessionId).transcript.reason).toBe('too_large'); @@ -404,7 +405,7 @@ describe('Autoplan parent publication guard', () => { // The same actual hook receives native separators in Windows CI. const f = fixture(); f.message(); f.current(); f.journal(); - expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); const command = f.events[0]!.input!.command as string; for (const suffix of ['; true', ' && true', ' | cat']) { f.events[0]!.input!.command = command + suffix; f.journal(); @@ -420,7 +421,7 @@ describe('Autoplan parent publication guard', () => { test('native project ownership preserves the absent-env same-directory adapter', async () => { const f = fixture(); f.message(); f.current(); f.journal(); - expect(await withNativeProjectDirectory(undefined, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(undefined, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); for (const project of ['absent', 'empty', 'relative', 'foreign', 'unnormalized'] as const) { @@ -801,7 +802,7 @@ describe('Autoplan parent publication guard', () => { await withNativeProjectDirectory(f.cwd, () => withPublicationClock(async () => { const started = performance.now(); setTimeout(() => f.journal(), 1_950); - expect(await runPublicationHook(f.input, ROOT)).toEqual({}); + expect(await runPublicationHook(f.input, ROOT)).toEqual(OWNED_READ_APPROVAL); expect(performance.now() - started).toBe(1_950); const decoded = readOwnedClaudePublicTranscript(f.input.transcript_path, f.cwd, f.sessionId); expect(decoded.transcript.status).toBe('ready'); @@ -811,7 +812,7 @@ describe('Autoplan parent publication guard', () => { test('the actual owned native reader and asynchronous hook admit a flushed same-response report', async () => { const f = fixture(); f.message(); f.current(); setTimeout(() => f.journal(), 100); - expect(await runPublicationHook(f.input, ROOT)).toEqual({}); + expect(await runPublicationHook(f.input, ROOT)).toEqual(OWNED_READ_APPROVAL); const decoded = readOwnedClaudePublicTranscript(f.input.transcript_path, f.cwd, f.sessionId); expect(decoded.transcript.status).toBe('ready'); const report = decoded.events.find(e => e.kind === 'message')!, current = decoded.events.find(e => e.kind === 'use' && e.toolUseId === 'next')!; @@ -836,7 +837,7 @@ describe('Autoplan parent publication guard', () => { }); test('an in-flight Read can revisit an earlier established phase', async () => { const f = fixture('design', 'ceo'); f.journal(); - expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual({}); + expect(await withNativeProjectDirectory(f.cwd, () => runPublicationHook(f.input, ROOT))).toEqual(OWNED_READ_APPROVAL); }); // CEO-1 replaced the pending-Read rule: the payload stands in for an unflushed // current call, so a first Phase 1 entry is allowed from it (it needs no prior @@ -915,7 +916,7 @@ describe('Autoplan parent publication guard', () => { const decoded = readOwnedClaudePublicTranscript(f.input.transcript_path, f.cwd, f.sessionId); expect(decoded.events.filter(e => e.kind === 'user_turn')).toHaveLength(kind === 'human' || kind === 'no-end-turn' ? 2 : 1); const result: any = await runPublicationHook(f.input, ROOT); - if (kind === 'human') expect(result).toEqual({}); + if (kind === 'human') expect(result).toEqual(OWNED_READ_APPROVAL); else expect(result.hookSpecificOutput?.permissionDecision).toBe('deny'); }); @@ -932,7 +933,7 @@ describe('Autoplan parent publication guard', () => { const message: any = { ...current, uuid: randomUUID(), message: { role: 'assistant', content: [{ type: 'text', text: 'Phase 1 complete.' }] } }; current.parentUuid = message.uuid; rows.splice(-1, 0, message); fs.writeFileSync(f.input.transcript_path, rows.map(x => JSON.stringify(x)).join('\n') + '\n'); - expect(await runPublicationHook(f.input, ROOT)).toEqual({}); + expect(await runPublicationHook(f.input, ROOT)).toEqual(OWNED_READ_APPROVAL); boundary.logicalParentUuid = randomUUID(); fs.writeFileSync(f.input.transcript_path, rows.map(x => JSON.stringify(x)).join('\n') + '\n'); expect(readOwnedClaudePublicTranscript(f.input.transcript_path, f.cwd, f.sessionId).events.some(e => e.kind === 'use' && e.toolUseId === 'next')).toBe(false); @@ -1229,7 +1230,7 @@ describe('Autoplan native journal roots and Windows spellings', () => { rows[0].parentUuid = chain.at(-1)!.uuid; rows.unshift(...(shape === 'stray-before' ? [attachment(f, null)] : []), ...chain); save(); expect(status(f)).toBe('ready'); - expect(await hook(f)).toEqual({}); + expect(await hook(f)).toEqual(OWNED_READ_APPROVAL); }); test('an attachment root still requires the parent publication', async () => { @@ -1340,10 +1341,7 @@ describe('Autoplan phase entry through the gbrain :user render (#2569)', () => { const linkRoot = path.join(scratch(), 'render', 'claude'); for (const name of [...sections, 'phase-close.md']) { const text = fs.readFileSync(path.join(ROOT, 'autoplan/sections', name), 'utf8'); - const hook = fs.readFileSync(path.join(ROOT, 'autoplan/bin/phase-publication-hook.ts'), 'utf8'); - const fn = hook.slice(hook.indexOf('function renderSectionBase('), hook.indexOf('\n}\n', hook.indexOf('function renderSectionBase(')) + 2); - const ours = new Function(new Bun.Transpiler({ loader: 'ts' }).transformSync(fn) + '\nreturn renderSectionBase;')(); - expect(ours(text, linkRoot)).toBe(rewriteSectionBase(text, linkRoot)); + expect(renderSectionBase(text, linkRoot)).toBe(rewriteSectionBase(text, linkRoot)); } }); @@ -1452,7 +1450,7 @@ describe('Autoplan ownership in a linked git worktree session', () => { test('the repository root owns its linked worktree journal', async () => { const f = fixture(); f.message(); f.current(); f.journal(); const root = repo(); pointer(f.cwd, admin(root, f.cwd)); - expect(await run(f, root)).toEqual({}); + expect(await run(f, root)).toEqual(OWNED_READ_APPROVAL); }); test('a linked worktree journal still requires the parent publication', async () => { @@ -1476,14 +1474,14 @@ describe('Autoplan ownership in a linked git worktree session', () => { // Exactly what git 2.55 `-c worktree.useRelativePaths=true worktree add` writes. fs.writeFileSync(path.join(entry, 'gitdir'), posix(path.relative(entry, path.join(f.cwd, '.git'))) + '\n'); fs.writeFileSync(path.join(f.cwd, '.git'), `gitdir: ${posix(path.relative(f.cwd, entry))}\n`); - expect(await run(f, root)).toEqual({}); + expect(await run(f, root)).toEqual(OWNED_READ_APPROVAL); }); test('an unrelated linked worktree leaves the exact project-directory owner unchanged', async () => { const f = fixture(); f.message(); f.current(); f.journal(); const elsewhere = repo(); fs.mkdirSync(path.join(f.cwd, '.git', 'worktrees', 'session'), { recursive: true }); fs.writeFileSync(path.join(f.cwd, '.git', 'worktrees', 'session', 'gitdir'), posix(path.join(elsewhere, '.git')) + '\n'); - expect(await run(f, f.cwd)).toEqual({}); + expect(await run(f, f.cwd)).toEqual(OWNED_READ_APPROVAL); }); for (const kind of ['no-link', 'worktree-file-only', 'admin-entry-only', 'other-repository', diff --git a/test/autoplan-publication-hook.test.ts b/test/autoplan-publication-hook.test.ts index d33f2b671..de4eebfc9 100644 --- a/test/autoplan-publication-hook.test.ts +++ b/test/autoplan-publication-hook.test.ts @@ -5,6 +5,7 @@ import { tmpdir } from 'node:os'; import { spawnSync } from 'node:child_process'; import { randomUUID } from 'node:crypto'; import { runPublicationHook } from '../autoplan/bin/phase-publication-hook.ts'; +import { OWNED_READ_APPROVAL } from '../autoplan/bin/owned-read'; const ROOT = path.join(import.meta.dir, '..'); // Every guarded decision appends to the guard log; keep it out of the real state root. @@ -34,9 +35,11 @@ function run(bytes: string, shim = SHIM, env = process.env) { } describe('Autoplan hook transport', () => { - test('ordinary project and non-Read tools abstain without a parent journal', () => { + test('ordinary project files and non-Read tools abstain without a parent journal; the close section is approved', () => { expect(run(JSON.stringify({ ...input, tool_name: 'Bash' })).output).toEqual({}); - expect(run(JSON.stringify({ ...input, tool_input: { file_path: path.join(ROOT, 'autoplan/sections/phase-close.md') } })).output).toEqual({}); + expect(run(JSON.stringify({ ...input, tool_input: { file_path: path.join(ROOT, 'package.json') } })).output).toEqual({}); + expect(run(JSON.stringify({ ...input, tool_input: { file_path: path.join(ROOT, 'autoplan/sections/phase-close.md') } })).output) + .toEqual(OWNED_READ_APPROVAL); }); test('invalid input fails closed with one nested native denial', () => { const { child, output } = run('{'); expect(child.status).toBe(0); diff --git a/test/autoplan-publication-payload.test.ts b/test/autoplan-publication-payload.test.ts index 01fa26172..ca7b86446 100644 --- a/test/autoplan-publication-payload.test.ts +++ b/test/autoplan-publication-payload.test.ts @@ -12,6 +12,7 @@ import { guardFixture, section, denial, codeOf, type GuardFixture } from './help import { AGENT_KEYS, CHECKED_CLAUDE_CODE, nativeToolInput, newerThanChecked } from '../autoplan/bin/phase-publication-hook.ts'; import { nativePathSpelling } from '../lib/claude-public-transcript'; import captured from './fixtures/claude-agent-payload-2.1.292.json'; +import { OWNED_READ_APPROVAL } from '../autoplan/bin/owned-read'; const fixtures: GuardFixture[] = []; afterEach(() => { for (const f of fixtures.splice(0)) f.cleanup(); }); @@ -140,9 +141,9 @@ describe('Publication flush: a report counts only once a later journaled record test('after the no-op publication message the transition is allowed on both paths', async () => { const f = make(); f.publish(); f.journal(); - expect(await f.hook(next(f))).toEqual({}); + expect(await f.hook(next(f))).toEqual(OWNED_READ_APPROVAL); f.use('next2', 'Read', { file_path: section('design-phase.md') }); f.journal(); - expect(await f.hook(next(f, 'next2'))).toEqual({}); + expect(await f.hook(next(f, 'next2'))).toEqual(OWNED_READ_APPROVAL); expect(f.log().map(e => e.path)).toEqual(['payload', 'journal']); }); @@ -160,7 +161,7 @@ describe('Publication flush: a report counts only once a later journaled record const f = make(); const m = f.nextMessage(); f.report(m); f.use('denied', 'Read', { file_path: section('design-phase.md') }, m); f.result('denied', { isError: true, content: '(code publication_unflushed, Claude Code 2.1.292)' }); f.journal(); - expect(await f.hook(next(f))).toEqual({}); + expect(await f.hook(next(f))).toEqual(OWNED_READ_APPROVAL); }); test('DX-3: an old-template close (report and next driver in one message) recovers after one denial, no restart', async () => { @@ -170,7 +171,7 @@ describe('Publication flush: a report counts only once a later journaled record expect(codeOf(first)).toBe('publication_unflushed'); f.result('old', { isError: true, content: denial(first) }); f.publish(); f.journal(); - expect(await f.hook(next(f, 'retry-after-publish'))).toEqual({}); + expect(await f.hook(next(f, 'retry-after-publish'))).toEqual(OWNED_READ_APPROVAL); }); }); @@ -184,7 +185,7 @@ describe('ENG-3: one batch rule on both paths', () => { if (order === 'sibling-done') f.readResult('s1', section('design-phase.md'), 1, 50); if (flushed === 'journal') f.use('s2', 'Read', designEntry(f, 51), m); f.journal(); - expect(await f.hook(f.input('s2', 'Read', designEntry(f, 51)))).toEqual({}); + expect(await f.hook(f.input('s2', 'Read', designEntry(f, 51)))).toEqual(OWNED_READ_APPROVAL); }); for (const flushed of ['journal', 'payload'] as const) @@ -231,7 +232,7 @@ describe('ENG-1: a background reviewer keeps the invocation armed', () => { f.add({ kind: 'end_turn', messageId: f.nextMessage() }); f.add({ kind: 'typed', text: 'Thanks, something else now.' }); f.journal(); - expect(await f.hook(f.input('next', 'Read', { file_path: section('design-phase.md') }))).toEqual({}); + expect(await f.hook(f.input('next', 'Read', { file_path: section('design-phase.md') }))).toEqual(OWNED_READ_APPROVAL); }); }); diff --git a/test/helpers/autoplan-guard-fixture.ts b/test/helpers/autoplan-guard-fixture.ts index a10965dd1..52abc1e97 100644 --- a/test/helpers/autoplan-guard-fixture.ts +++ b/test/helpers/autoplan-guard-fixture.ts @@ -24,9 +24,12 @@ export interface Step { /** A completed Phase `phase` (init, entry, close packet Read) with a reviewer snapshot for `phase`. */ /** `opening: 'skill'` starts the run from a typed request and a Skill tool call instead of the /autoplan slash turn. */ -export function guardFixture(phase: Phase = 'ceo', opts: { methodologyLines?: number; version?: string; opening?: 'slash' | 'skill' } = {}) { +/** `restoreInProject` puts the restore point and phase artifacts in the project's `.gstack/tmp/autoplan/`, where /autoplan writes them. */ +export function guardFixture(phase: Phase = 'ceo', opts: { methodologyLines?: number; version?: string; opening?: 'slash' | 'skill'; restoreInProject?: boolean } = {}) { const cwd = fs.realpathSync(fs.mkdtempSync(path.join(tmpdir(), 'autoplan-guard-replay-'))); - const source = path.join(cwd, 'source.md'), active = path.join(cwd, 'active.md'), restore = path.join(cwd, 'restore.md'); + const stateRoot = path.join(cwd, 'state'), restoreDir = opts.restoreInProject ? path.join(cwd, '.gstack', 'tmp', 'autoplan') : cwd; + fs.mkdirSync(restoreDir, { recursive: true }); + const source = path.join(cwd, 'source.md'), active = path.join(cwd, 'active.md'), restore = path.join(restoreDir, 'restore.md'); fs.writeFileSync(source, '# Current plan\nKeep documented behavior.\n'); const init = initializePlan(source, active, restore); const skill = path.join(cwd, 'SKILL.md'); @@ -38,7 +41,6 @@ export function guardFixture(phase: Phase = 'ceo', opts: { methodologyLines?: nu const packet = preparePhaseClose(phase, active, snapshot.snapshotPath, restore, method); const sessionId = randomUUID(), steps: Step[] = []; const transcript = path.join(cwd, 'config', 'projects', 'fixture', `${sessionId}.jsonl`); - const stateRoot = path.join(cwd, 'state'); let message = 0; const nextMessage = () => `msg_fixture${++message}`; const add = (step: Step) => { steps.push(step); return step; }; diff --git a/test/helpers/touchfiles-data.ts b/test/helpers/touchfiles-data.ts index 08726309b..9d6e0f500 100644 --- a/test/helpers/touchfiles-data.ts +++ b/test/helpers/touchfiles-data.ts @@ -86,11 +86,11 @@ export const E2E_TOUCHFILES: Record = { // Real pinned-claude journals (SessionStart hook, /compact, --fork-session) through the /autoplan guard's reader. 'autoplan-journal-drift': ['lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'lib/claude-bin.ts', '.github/docker/Dockerfile.ci', 'test/skill-e2e-autoplan-journal-drift.test.ts'], // Live PTY phase boundary on the pinned Claude Code through /autoplan's own hook block (ENG-18). - 'autoplan-guard-pty': ['autoplan/bin/phase-publication-hook.ts', 'autoplan/bin/phase-publication-hook', 'autoplan/bin/guard-reasons.ts', 'autoplan/bin/guard-log.ts', 'autoplan/SKILL.md', 'autoplan/SKILL.md.tmpl', 'scripts/resolvers/composition.ts', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'autoplan/bin/guard-journal.ts', 'lib/autoplan-phase-publication.ts', 'lib/state-root.ts', 'bin/gstack-autoplan-snapshot.ts', '.github/docker/Dockerfile.ci', 'test/helpers/autoplan-guard-pty.ts', 'test/helpers/claude-pty-runner.ts', 'test/helpers/pty/**', 'test/helpers/hermetic-env.ts', 'test/helpers/auto-decision-state.ts', 'test/helpers/autoplan-artifact-digest.ts', 'test/helpers/autoplan-artifact-permission.ts', 'test/helpers/autoplan-artifact-recorder.ts', 'test/helpers/dx-selected-navigation.ts', 'test/helpers/eng-cache-writer-decision.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/native-auto-decide.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-count-artifacts.ts', 'test/helpers/plan-count-file-permission.ts', 'test/helpers/plan-count-fixture.ts', 'test/helpers/plan-count-pending-exit.ts', 'test/helpers/plan-count-pending-question.ts', 'test/helpers/plan-count-transcript.ts', 'test/helpers/plan-floor-review.ts', 'test/helpers/plan-floor-target.ts', 'test/helpers/plan-scope-selection.ts', 'test/helpers/plan-seed-submission.ts', 'test/helpers/plan-skill-question-events.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/plan-skill-questions.ts', 'test/helpers/pty-screen.ts', 'test/helpers/pty-trust-dialog.ts', 'test/helpers/skill-census.ts', 'test/skill-e2e-autoplan-guard-pty.test.ts'], + 'autoplan-guard-pty': ['autoplan/bin/phase-publication-hook.ts', 'autoplan/bin/owned-read.ts', 'autoplan/bin/phase-publication-hook', 'autoplan/bin/guard-reasons.ts', 'autoplan/bin/guard-log.ts', 'autoplan/SKILL.md', 'autoplan/SKILL.md.tmpl', 'scripts/resolvers/composition.ts', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'autoplan/bin/guard-journal.ts', 'lib/autoplan-phase-publication.ts', 'lib/state-root.ts', 'bin/gstack-autoplan-snapshot.ts', '.github/docker/Dockerfile.ci', 'test/helpers/autoplan-guard-pty.ts', 'test/helpers/claude-pty-runner.ts', 'test/helpers/pty/**', 'test/helpers/hermetic-env.ts', 'test/helpers/auto-decision-state.ts', 'test/helpers/autoplan-artifact-digest.ts', 'test/helpers/autoplan-artifact-permission.ts', 'test/helpers/autoplan-artifact-recorder.ts', 'test/helpers/dx-selected-navigation.ts', 'test/helpers/eng-cache-writer-decision.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/native-auto-decide.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-count-artifacts.ts', 'test/helpers/plan-count-file-permission.ts', 'test/helpers/plan-count-fixture.ts', 'test/helpers/plan-count-pending-exit.ts', 'test/helpers/plan-count-pending-question.ts', 'test/helpers/plan-count-transcript.ts', 'test/helpers/plan-floor-review.ts', 'test/helpers/plan-floor-target.ts', 'test/helpers/plan-scope-selection.ts', 'test/helpers/plan-seed-submission.ts', 'test/helpers/plan-skill-question-events.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/plan-skill-questions.ts', 'test/helpers/pty-screen.ts', 'test/helpers/pty-trust-dialog.ts', 'test/helpers/skill-census.ts', 'test/skill-e2e-autoplan-guard-pty.test.ts'], // A resumed session whose journal is padded past 100 MiB before its compact boundary enters Phase 1 through the guard (CEO-15). - 'autoplan-long-session': ['autoplan/bin/phase-publication-hook.ts', 'autoplan/bin/phase-publication-hook', 'autoplan/bin/guard-reasons.ts', 'autoplan/bin/guard-log.ts', 'autoplan/bin/guard-journal.ts', 'autoplan/SKILL.md', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'bin/gstack-autoplan-snapshot.ts', '.github/docker/Dockerfile.ci', 'test/helpers/autoplan-guard-pty.ts', 'test/helpers/journal-padding.ts', 'test/helpers/claude-pty-runner.ts', 'test/helpers/pty/**', 'test/helpers/auto-decision-state.ts', 'test/helpers/autoplan-artifact-digest.ts', 'test/helpers/autoplan-artifact-permission.ts', 'test/helpers/autoplan-artifact-recorder.ts', 'test/helpers/dx-selected-navigation.ts', 'test/helpers/eng-cache-writer-decision.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/native-auto-decide.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-count-artifacts.ts', 'test/helpers/plan-count-file-permission.ts', 'test/helpers/plan-count-fixture.ts', 'test/helpers/plan-count-pending-exit.ts', 'test/helpers/plan-count-pending-question.ts', 'test/helpers/plan-count-transcript.ts', 'test/helpers/plan-floor-review.ts', 'test/helpers/plan-floor-target.ts', 'test/helpers/plan-scope-selection.ts', 'test/helpers/plan-seed-submission.ts', 'test/helpers/plan-skill-question-events.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/plan-skill-questions.ts', 'test/helpers/pty-screen.ts', 'test/helpers/pty-trust-dialog.ts', 'test/helpers/skill-census.ts', 'test/skill-e2e-autoplan-long-session.test.ts'], + 'autoplan-long-session': ['autoplan/bin/phase-publication-hook.ts', 'autoplan/bin/owned-read.ts', 'autoplan/bin/phase-publication-hook', 'autoplan/bin/guard-reasons.ts', 'autoplan/bin/guard-log.ts', 'autoplan/bin/guard-journal.ts', 'autoplan/SKILL.md', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'bin/gstack-autoplan-snapshot.ts', '.github/docker/Dockerfile.ci', 'test/helpers/autoplan-guard-pty.ts', 'test/helpers/journal-padding.ts', 'test/helpers/claude-pty-runner.ts', 'test/helpers/pty/**', 'test/helpers/auto-decision-state.ts', 'test/helpers/autoplan-artifact-digest.ts', 'test/helpers/autoplan-artifact-permission.ts', 'test/helpers/autoplan-artifact-recorder.ts', 'test/helpers/dx-selected-navigation.ts', 'test/helpers/eng-cache-writer-decision.ts', 'test/helpers/hermetic-skill-runtime.ts', 'test/helpers/native-auto-decide.ts', 'test/helpers/owned-claude-transcript.ts', 'test/helpers/plan-count-artifacts.ts', 'test/helpers/plan-count-file-permission.ts', 'test/helpers/plan-count-fixture.ts', 'test/helpers/plan-count-pending-exit.ts', 'test/helpers/plan-count-pending-question.ts', 'test/helpers/plan-count-transcript.ts', 'test/helpers/plan-floor-review.ts', 'test/helpers/plan-floor-target.ts', 'test/helpers/plan-scope-selection.ts', 'test/helpers/plan-seed-submission.ts', 'test/helpers/plan-skill-question-events.ts', 'test/helpers/plan-skill-question-hook-scope.ts', 'test/helpers/plan-skill-questions.ts', 'test/helpers/pty-screen.ts', 'test/helpers/pty-trust-dialog.ts', 'test/helpers/skill-census.ts', 'test/skill-e2e-autoplan-long-session.test.ts'], // Latest published Claude Code (not the pin): Agent/Read hook payloads vs their journal records, with the guard's own comparison. - 'autoplan-schema-canary': ['autoplan/bin/phase-publication-hook.ts', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'lib/claude-bin.ts', 'test/helpers/schema-canary.ts', 'test/skill-e2e-autoplan-schema-canary.test.ts'], + 'autoplan-schema-canary': ['autoplan/bin/phase-publication-hook.ts', 'autoplan/bin/owned-read.ts', 'lib/claude-public-transcript.ts', 'lib/claude-journal-records.ts', 'lib/claude-owned-journal.ts', 'lib/claude-bin.ts', 'test/helpers/schema-canary.ts', 'test/skill-e2e-autoplan-schema-canary.test.ts'], // P4 first-run scaffold (activation lift) — the detection binary end-to-end // through the real runner, plus the script wiring that gates + maps it From 95fc35e58588cacd9d1e74c38f4e4edb0a6fb2e1 Mon Sep 17 00:00:00 2001 From: garrytan Date: Thu, 8 Oct 2026 08:07:17 +0000 Subject: [PATCH 2/4] fix(autoplan): restore point and phase artifacts live in the project's .gstack/tmp/autoplan/ Skill hooks do not run inside subagents, so a reviewer launched after a background completion notice raised a card for its own input (native-prompt.md under the state root). Step 1 now puts RESTORE_PATH in the repository's git-excluded .gstack/tmp/autoplan/ (added to .git/info/exclude, mode 700), and the snapshot tool writes every phase artifact beside it, so /autoplan and its reviewers read them from the working directory without a card. The guard's bindings are unchanged: they anchor on the restore point's directory. Step 1 still prints the slug, which the old RESTORE_PATH carried. A free test runs the generated Step 1 block twice from a repository subdirectory: the restore point lands in /.gstack/tmp/autoplan/, the exclude line is written once and git status stays clean. The autoplan parity cap rises by the measured bytes (115,270 / 101,979 = 1.1303). Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- autoplan/SKILL.md | 9 +++++---- autoplan/SKILL.md.tmpl | 9 +++++---- test/autoplan-owned-read.test.ts | 18 ++++++++++++++++++ test/helpers/carve-guards.ts | 2 +- 4 files changed, 29 insertions(+), 9 deletions(-) diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index d2601cac3..5ecd023b0 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -672,14 +672,15 @@ Resolve SNAPSHOT_TOOL once: bun -e 'console.log(require("fs").realpathSync(process.argv[1]))' "$HOME/.claude/skills/gstack/bin/gstack-autoplan-snapshot.ts" ``` -Fresh external RESTORE_PATH: +Fresh RESTORE_PATH, beside its phase artifacts in the project's git-excluded `.gstack/tmp/autoplan/`: ```bash SLUG=$(~/.claude/skills/gstack/bin/gstack-slug --get SLUG 2>/dev/null) -GSTACK_STATE_ROOT=$(~/.claude/skills/gstack/bin/gstack-paths --get GSTACK_STATE_ROOT); : "${GSTACK_STATE_ROOT:?gstack-paths failed; reinstall with ./setup or /gstack-upgrade}" -mkdir -p "$GSTACK_STATE_ROOT/projects/$SLUG" +_AP="$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.gstack/tmp/autoplan"; mkdir -p "$_AP" && chmod 700 "$_AP" +_EX=$(git rev-parse --git-path info/exclude 2>/dev/null) && mkdir -p "${_EX%/*}" && { grep -qxF /.gstack/tmp/ "$_EX" 2>/dev/null || echo /.gstack/tmp/ >> "$_EX"; } BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null | tr '/' '-') DATETIME=$(date +%Y%m%d-%H%M%S) -echo "RESTORE_PATH=$GSTACK_STATE_ROOT/projects/$SLUG/${BRANCH}-autoplan-restore-${DATETIME}.md" +echo "SLUG=$SLUG" +echo "RESTORE_PATH=$_AP/${BRANCH}-autoplan-restore-${DATETIME}.md" ``` Before scope/review: diff --git a/autoplan/SKILL.md.tmpl b/autoplan/SKILL.md.tmpl index 287a64b6a..0b04fe490 100644 --- a/autoplan/SKILL.md.tmpl +++ b/autoplan/SKILL.md.tmpl @@ -201,14 +201,15 @@ Send phase announcements and the final approval request in the conversation. Resolve SNAPSHOT_TOOL once: {{AUTOPLAN_SNAPSHOT_TOOL}} -Fresh external RESTORE_PATH: +Fresh RESTORE_PATH, beside its phase artifacts in the project's git-excluded `.gstack/tmp/autoplan/`: ```bash {{SLUG_EVAL}} -GSTACK_STATE_ROOT=$(~/.claude/skills/gstack/bin/gstack-paths --get GSTACK_STATE_ROOT); : "${GSTACK_STATE_ROOT:?gstack-paths failed; reinstall with ./setup or /gstack-upgrade}" -mkdir -p "$GSTACK_STATE_ROOT/projects/$SLUG" +_AP="$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.gstack/tmp/autoplan"; mkdir -p "$_AP" && chmod 700 "$_AP" +_EX=$(git rev-parse --git-path info/exclude 2>/dev/null) && mkdir -p "${_EX%/*}" && { grep -qxF /.gstack/tmp/ "$_EX" 2>/dev/null || echo /.gstack/tmp/ >> "$_EX"; } BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null | tr '/' '-') DATETIME=$(date +%Y%m%d-%H%M%S) -echo "RESTORE_PATH=$GSTACK_STATE_ROOT/projects/$SLUG/${BRANCH}-autoplan-restore-${DATETIME}.md" +echo "SLUG=$SLUG" +echo "RESTORE_PATH=$_AP/${BRANCH}-autoplan-restore-${DATETIME}.md" ``` Before scope/review: diff --git a/test/autoplan-owned-read.test.ts b/test/autoplan-owned-read.test.ts index f00323060..b8d92da5d 100644 --- a/test/autoplan-owned-read.test.ts +++ b/test/autoplan-owned-read.test.ts @@ -112,6 +112,24 @@ describe('/autoplan owned reads after the skill turn', () => { expect(await runPublicationHook({ ...read(c.session, c.packet), tool_name: 'Bash', tool_input: { command: `cat ${c.packet}` } }, ROOT)).toEqual({}); }); + test('Step 1 puts the restore point in the repository\'s git-excluded store, from a subdirectory too', () => { + const skill = fs.readFileSync(path.join(ROOT, 'autoplan/SKILL.md'), 'utf8'); + const start = skill.indexOf('```bash\n', skill.indexOf('Fresh RESTORE_PATH')) + 8; + const block = skill.slice(start, skill.indexOf('\n```', start)); + const home = scratch('autoplan-owned-home-'), repo = scratch('autoplan-owned-git-'), session = path.join(repo, 'packages', 'app'); + fs.mkdirSync(path.join(home, '.claude', 'skills'), { recursive: true }); fs.mkdirSync(session, { recursive: true }); + fs.symlinkSync(ROOT, path.join(home, '.claude', 'skills', 'gstack'), 'dir'); + expect(spawnSync('git', ['init', '-q', '-b', 'main'], { cwd: repo, timeout: 10_000 }).status).toBe(0); + const run = () => spawnSync('bash', ['-c', block], { cwd: session, encoding: 'utf8', timeout: 15_000, env: { ...process.env, HOME: home } }); + const first = run(), second = run(); + expect(first.status).toBe(0); expect(second.status).toBe(0); + const restore = /^RESTORE_PATH=(.+)$/m.exec(first.stdout)?.[1] ?? ''; + expect(path.dirname(restore)).toBe(path.join(repo, '.gstack', 'tmp', 'autoplan')); + expect(path.basename(restore)).toMatch(/-autoplan-restore-\d{8}-\d{6}\.md$/); + expect(fs.readFileSync(path.join(repo, '.git', 'info', 'exclude'), 'utf8').split('\n').filter(l => l === '/.gstack/tmp/')).toHaveLength(1); + expect(spawnSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd: repo, encoding: 'utf8', timeout: 10_000 }).stdout).toBe(''); + }); + test('a guard denial is never turned into an approval', async () => { const cwd = scratch('autoplan-owned-deny-'); const output: any = await runPublicationHook(read(cwd, path.join(ROOT, 'autoplan/sections/design-phase.md')), ROOT); diff --git a/test/helpers/carve-guards.ts b/test/helpers/carve-guards.ts index 746ba8c75..80f641419 100644 --- a/test/helpers/carve-guards.ts +++ b/test/helpers/carve-guards.ts @@ -577,7 +577,7 @@ do not launch the downstream skill or open a browser.`, maxSkeletonBytes: 70_000, // Phase-specific outside coverage, native fallback, and harness guard. minUnionBytes: 85_000, // measured union 86,926 mustContain: ['6 Decision Principles', 'TASTE DECISION', 'USER CHALLENGE', 'consensus', 'Restore Point'], - maxSizeRatio: 1.1295, // Four validated outside invocations replace raw CLI calls; phases keep independent coverage. + Oct 7 wave B3: the Codex probe runs as a command (select-model capture lines, check-sandbox/probe-model/run-with-timeout subcommands) instead of being sourced; measured 114,297 / 101,979 = 1.1208 (2026-10-07). + Oct 7 wave CEO-28/DX-11: review prompts ask for a severity per finding and design proposals use the proposal gate; measured 114,533 / 101,979 = 1.1231 (2026-10-07). + Oct 7 wave guard (CEO-20): conditional `run_in_background` request plus the background-run recovery at each foreground dispatch site, and phase-close publishing each report with the `true autoplan-published ` no-op before the next phase entry in a later message (CEO-1); measured 114,320 / 101,979 = 1.1210 (2026-10-07). Merged with the guard area: measured 115,149 / 101,979 = 1.1291 (2026-10-07). + maxSizeRatio: 1.1305, // Four validated outside invocations replace raw CLI calls; phases keep independent coverage. + Oct 7 wave B3: the Codex probe runs as a command (select-model capture lines, check-sandbox/probe-model/run-with-timeout subcommands) instead of being sourced; measured 114,297 / 101,979 = 1.1208 (2026-10-07). + Oct 7 wave CEO-28/DX-11: review prompts ask for a severity per finding and design proposals use the proposal gate; measured 114,533 / 101,979 = 1.1231 (2026-10-07). + Oct 7 wave guard (CEO-20): conditional `run_in_background` request plus the background-run recovery at each foreground dispatch site, and phase-close publishing each report with the `true autoplan-published ` no-op before the next phase entry in a later message (CEO-1); measured 114,320 / 101,979 = 1.1210 (2026-10-07). Merged with the guard area: measured 115,149 / 101,979 = 1.1291 (2026-10-07). + Oct 8 wave (permission cards after a background reviewer): Step 1 puts RESTORE_PATH, and so every phase artifact, in the project's git-excluded `.gstack/tmp/autoplan/`, which Claude Code reads without a card after the skill turn ends; measured 115,270 / 101,979 = 1.1303 (2026-10-08). }, spec: { skill: 'spec', From ccbe0948fcb699233328d01950cd84c544493ba9 Mon Sep 17 00:00:00 2001 From: garrytan Date: Thu, 8 Oct 2026 08:08:13 +0000 Subject: [PATCH 3/4] test(evals): autoplan-guard-pty fails on any permission card after the reviewer's notice turn The scripted boundary now mirrors Step 1's layout (restore point and artifacts in the project's .gstack/tmp/autoplan/) and continues past the Phase 2 entry to dispatch the Phase 2 reviewer after the CEO reviewer's completion notice. The case asserts four verified guard allows, that the close packet Read, the Phase 2 section Read and the Phase 2 dispatch came after a task-notification turn, that the Phase 2 reviewer read its input, and that no permission card appeared at all. Still one trial on haiku, about 75-85 seconds. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- test/helpers/autoplan-guard-pty.ts | 58 +++++++++++++++++------ test/skill-e2e-autoplan-guard-pty.test.ts | 35 +++++++++----- 2 files changed, 67 insertions(+), 26 deletions(-) diff --git a/test/helpers/autoplan-guard-pty.ts b/test/helpers/autoplan-guard-pty.ts index a8f7128d9..6ec2da015 100644 --- a/test/helpers/autoplan-guard-pty.ts +++ b/test/helpers/autoplan-guard-pty.ts @@ -5,7 +5,9 @@ * carries /autoplan's own PreToolUse hook block and allowed tools. Its body is * a minimal scripted phase boundary: init, Phase 1 entry, a prepared close * packet, the report published with the `true autoplan-published` no-op, then the - * Phase 2 entry in a later message. Outcomes come from the guard decision log. + * Phase 2 entry in a later message and the Phase 2 reviewer. The restore point + * and phase artifacts live in the project's `.gstack/tmp/autoplan/`, as /autoplan + * Step 1 places them. Outcomes come from the guard decision log and the journals. */ import * as fs from 'node:fs'; import * as path from 'node:path'; @@ -30,32 +32,40 @@ export interface GuardSession { readLog(): Array>; /** Content-bounded journal summary for a failure message: tool names, inputs' first keys, result heads. */ journalSummary(): string[]; + /** Parent tool calls from the first background completion notice on, the notice count, and reviewers' successful Read paths. */ + noticeEvidence(): { notices: number; afterNotice: string[]; reviewerReads: string[] }; cleanup(): void; } export function prepareGuardSession(apiKey: string | undefined): GuardSession { const base = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ap-guard-pty-'))); const home = path.join(base, 'home'), config = path.join(home, '.claude'), project = path.join(base, 'project'); - const stateRoot = path.join(base, 'state'), artifacts = path.join(base, 'artifacts'); + const stateRoot = path.join(base, 'state'), artifacts = path.join(project, '.gstack', 'tmp', 'autoplan'); for (const dir of [config, project, stateRoot, artifacts, path.join(config, 'skills')]) fs.mkdirSync(dir, { recursive: true }); fs.symlinkSync(ROOT, path.join(config, 'skills', 'gstack'), 'dir'); fs.writeFileSync(path.join(config, '.claude.json'), JSON.stringify(buildSeedConfig({ apiKey, trustedDirs: [project] }))); - const source = path.join(project, 'PLAN.md'), active = path.join(artifacts, 'active.md'), restore = path.join(artifacts, 'restore.md'); + const source = path.join(project, 'PLAN.md'), active = path.join(project, 'ACTIVE.md'), restore = path.join(artifacts, 'restore.md'); fs.writeFileSync(source, '# Plan: greet\nAdd a greet command that prints "hello".\n'); // Stands in for the CEO review the scripted boundary skips: methodology, - // checkpoint, accepted block and close packet, made after the model's own init. - const review = path.join(artifacts, 'review-ceo.ts'), reviewSkill = path.join(artifacts, 'ceo-skill', 'SKILL.md'); - fs.mkdirSync(path.dirname(reviewSkill)); - fs.writeFileSync(reviewSkill, '---\nname: plan-ceo-review\n---\n## Review Sections\nApply every current review criterion.\n'); + // checkpoint, accepted block and close packet, made after the model's own init, + // then the Phase 2 reviewer input, so no helper Bash runs after the first notice. + const review = path.join(base, 'review.ts'), skills = path.join(base, 'review-skills'); + for (const name of ['plan-ceo-review', 'plan-design-review']) { + fs.mkdirSync(path.join(skills, name), { recursive: true }); + fs.writeFileSync(path.join(skills, name, 'SKILL.md'), `---\nname: ${name}\n---\n## Review Sections\nApply every current review criterion.\n`); + } fs.writeFileSync(review, `import { appendFileSync, writeFileSync } from 'node:fs'; import { prepareMethodology, createSnapshot, preparePhaseClose } from ${JSON.stringify(path.join(ROOT, 'bin', 'gstack-autoplan-snapshot.ts'))}; -const [active, restore, skill] = ${JSON.stringify([active, restore, reviewSkill])}; -const method = prepareMethodology('ceo', skill, restore).methodologyPath; +const [active, restore, skills, artifacts] = ${JSON.stringify([active, restore, skills, artifacts])}; +const method = prepareMethodology('ceo', skills + '/plan-ceo-review/SKILL.md', restore).methodologyPath; const snapshot = createSnapshot('ceo', active, restore, method), checkpoint = snapshot.snapshotPath; -writeFileSync(${JSON.stringify(path.join(artifacts, 'dispatch.txt'))}, snapshot.nativeDispatchPrompt); +writeFileSync(artifacts + '/dispatch-ceo.txt', snapshot.nativeDispatchPrompt); appendFileSync(active, '\\nNone: retain the current behavior.\\n\\n'); -console.log(preparePhaseClose('ceo', active, checkpoint, restore, method).closePacketPath); +const close = preparePhaseClose('ceo', active, checkpoint, restore, method).closePacketPath; +const design = prepareMethodology('design', skills + '/plan-design-review/SKILL.md', restore).methodologyPath; +writeFileSync(artifacts + '/dispatch-design.txt', createSnapshot('design', active, restore, design).nativeDispatchPrompt); +console.log(close); `); const tool = path.join(ROOT, 'bin', 'gstack-autoplan-snapshot.ts'); @@ -65,15 +75,19 @@ console.log(preparePhaseClose('ceo', active, checkpoint, restore, method).closeP `1. Run this Bash command alone: bun "${tool}" init "${source}" "${active}" "${restore}"`, `2. Read the file ${path.join(sections, 'ceo-phase.md')} with offset 1 and limit 20.`, `3. Run this Bash command alone: bun "${review}"`, - `4. Run this Bash command alone: cat "${path.join(artifacts, 'dispatch.txt')}"`, + `4. Run this Bash command alone: cat "${path.join(artifacts, 'dispatch-ceo.txt')}"`, '5. Call the Agent tool once with these inputs: prompt = the exact, complete output of step 4 (every line, unchanged), ' + 'description "CEO review", subagent_type "general-purpose", and run_in_background false. Include run_in_background even ' + - 'if the tool schema lacks it. If the agent runs in the background, wait for its completion notification.', + 'if the tool schema lacks it. If the agent runs in the background, end your turn and wait for its completion notification.', '6. Read the file whose path step 3 printed, completely (no offset or limit).', '7. In one message, write exactly this line as your own text: **Phase 1 complete.** and make exactly one tool call in that ' + 'same message: the Bash command `true autoplan-published ceo`.', `8. In a later message, Read the file ${path.join(sections, 'design-phase.md')} with offset 1 and limit 20.`, - '9. Reply with the single word DONE. If any tool call is denied, quote the denial text and stop.', + `9. Run this Bash command alone: cat "${path.join(artifacts, 'dispatch-design.txt')}"`, + '10. Call the Agent tool once with these inputs: prompt = the exact, complete output of step 9 (every line, unchanged), ' + + 'description "Design review", subagent_type "general-purpose". If the agent runs in the background, end your turn and wait ' + + 'for its completion notification.', + '11. Reply with the single word DONE. If any tool call is denied, quote the denial text and stop.', ].join('\n'); const skillDir = path.join(project, '.claude', 'skills', GUARD_SKILL); fs.mkdirSync(skillDir, { recursive: true }); @@ -96,6 +110,22 @@ console.log(preparePhaseClose('ceo', active, checkpoint, restore, method).closeP : b.type === 'text' ? `text ${String(b.text).slice(0, 80)}` : b.type); }))); }, + noticeEvidence: () => { + const projects = path.join(config, 'projects'), sub = `${path.sep}subagents${path.sep}`; + const files = fs.existsSync(projects) ? fs.readdirSync(projects, { recursive: true }).map(String) + .filter(f => f.endsWith('.jsonl')).map(f => path.join(projects, f)) : []; + const rows = (file: string): any[] => fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line)); + const blocks = (rs: any[], type: string): any[] => rs.flatMap(r => Array.isArray(r.message?.content) ? r.message.content.filter((b: any) => b.type === type) : []); + const parent = files.filter(f => !f.includes(sub)).flatMap(rows); + const notice = parent.findIndex(r => r.origin?.kind === 'task-notification'); + const afterNotice = notice < 0 ? [] : blocks(parent.slice(notice), 'tool_use') + .map(b => `${b.name} ${b.input?.file_path ?? b.input?.command ?? b.input?.description ?? ''}`); + const reviewerReads = files.filter(f => f.includes(sub)).flatMap(f => { + const rs = rows(f), ok = new Set(blocks(rs, 'tool_result').filter(b => !b.is_error).map(b => b.tool_use_id)); + return blocks(rs, 'tool_use').filter(b => b.name === 'Read' && ok.has(b.id)).map(b => String(b.input?.file_path)); + }); + return { notices: parent.filter(r => r.origin?.kind === 'task-notification').length, afterNotice, reviewerReads }; + }, readLog: () => fs.existsSync(log) ? fs.readFileSync(log, 'utf8').trim().split('\n').filter(Boolean).map(line => JSON.parse(line)) : [], cleanup: () => fs.rmSync(base, { recursive: true, force: true }), }; diff --git a/test/skill-e2e-autoplan-guard-pty.test.ts b/test/skill-e2e-autoplan-guard-pty.test.ts index 030c32abd..b875eb58b 100644 --- a/test/skill-e2e-autoplan-guard-pty.test.ts +++ b/test/skill-e2e-autoplan-guard-pty.test.ts @@ -4,12 +4,18 @@ * On the pinned Claude Code, in an interactive PTY session with default * settings, a project skill carrying /autoplan's own hook block enters Phase 1, * dispatches the CEO reviewer, reads a prepared close packet, publishes the Phase 1 report in a message - * whose only tool call is `true autoplan-published ceo`, and enters Phase 2 in a - * later message. The reviewer dispatch sends run_in_background, which the + * whose only tool call is `true autoplan-published ceo`, enters Phase 2 in a + * later message and dispatches the Phase 2 reviewer. The reviewer dispatch sends run_in_background, which the * 2.1.29x default fork-subagent schema strips. Claude Code 2.1.29x can write a tool call to the journal only * after PreToolUse returns, so this is where the guard's payload path and its * flush rule meet the real CLI. The outcome is read from the guard decision - * log, never the screen; the no-op must run without a permission prompt. + * log, never the screen. + * + * The reviewer runs in the background, so its completion notice starts a new + * turn and Claude Code stops applying the skill's allowed tools. Every later + * Read of /autoplan's own files (the close packet and the Phase 2 reviewer's + * input in the project's .gstack/tmp/autoplan/, the installed Phase 2 section) + * must still raise no permission card. */ import { expect } from 'bun:test'; import { describeIfSelected, testIfSelected } from './helpers/e2e-helpers'; @@ -34,29 +40,34 @@ describeIfSelected('autoplan publication guard live PTY', ['autoplan-guard-pty'] await Bun.sleep(1_000); const log = s.readLog(); if (phase1Ms === null && log.length) phase1Ms = Math.round(performance.now() - started); - // A permission card is recorded and approved; the no-op must never raise one (DX-13). + // A permission card is recorded and approved so the run can finish; any card fails the case. const screen = await session.currentScreen(); if (/Do you want to proceed\?/.test(screen) && /❯\s*1\.\s*Yes/.test(screen)) { prompts.push(screen); await selectPtyNumberedOption(session, 1); await Bun.sleep(1_500); } - if (log.some(e => e.decision === 'deny') || log.length >= 3) break; + if (log.some(e => e.decision === 'deny') || (log.length >= 4 && s.noticeEvidence().notices >= 2)) break; if (session.exited()) break; } await Bun.sleep(3_000); - const log = s.readLog(); - const summary = { prompts: prompts.length, phase1Ms, totalMs: Math.round(performance.now() - started), + const log = s.readLog(), evidence = s.noticeEvidence(); + const summary = { prompts: prompts.length, phase1Ms, totalMs: Math.round(performance.now() - started), evidence, decisions: log.map(e => ({ decision: e.decision, code: e.code, path: e.path, version: e.claude_code_version })) }; console.log(`[autoplan-guard-pty] ${JSON.stringify(summary)}`); - if (log.length !== 3 || log.some(e => e.decision === 'deny')) + if (log.length !== 4 || log.some(e => e.decision === 'deny') || prompts.length) console.log(`[autoplan-guard-pty] journal:\n${s.journalSummary().join('\n')}\n[autoplan-guard-pty] screen:\n${session.visibleText().slice(-2_000)}`); for (const prompt of prompts) console.log(`[autoplan-guard-pty] permission card approved:\n${prompt}`); - expect(prompts.filter(p => p.replace(/\s+/g, '').includes('autoplan-published'))).toEqual([]); expect(log.filter(e => e.decision === 'deny')).toEqual([]); - // Phase 1 entry, the CEO reviewer dispatch (Cause A: run_in_background sent, stripped from the payload) - // and the Phase 2 transition: three guarded allows, each verified (not an unverified allow). - expect(log.map(e => [e.decision, e.disposition])).toEqual([['allow', 'allow'], ['allow', 'allow'], ['allow', 'allow']]); + // Phase 1 entry, the CEO reviewer dispatch (Cause A: run_in_background sent, stripped from the payload), + // the Phase 2 transition and the Phase 2 reviewer dispatch: four guarded allows, each verified. + expect(log.map(e => [e.decision, e.disposition])).toEqual(Array(4).fill(['allow', 'allow'])); + // The CEO reviewer's notice started a new turn before the close packet, the Phase 2 entry and the Phase 2 dispatch. + expect(evidence.afterNotice.filter(c => /^Read .*close-packet\.md$/.test(c))).not.toEqual([]); + expect(evidence.afterNotice.filter(c => /^Read .*autoplan\/sections\/design-phase\.md$/.test(c))).not.toEqual([]); + expect(evidence.afterNotice).toContain('Agent Design review'); + expect(evidence.reviewerReads.filter(f => /\.gstack\/tmp\/autoplan\/autoplan-design-[^/]+\/native-prompt\.md$/.test(f))).not.toEqual([]); + expect(prompts).toEqual([]); } finally { await session.close(); s.cleanup(); From efed592e0b10e5a23795ff12be9bfd54c3a6216f Mon Sep 17 00:00:00 2001 From: garrytan Date: Thu, 8 Oct 2026 08:08:28 +0000 Subject: [PATCH 4/4] docs(autoplan): permission cards after a background reviewer, and where /autoplan keeps its files Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- docs/autoplan-guard-troubleshooting.md | 30 ++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/docs/autoplan-guard-troubleshooting.md b/docs/autoplan-guard-troubleshooting.md index f2bbf073e..c67193ccc 100644 --- a/docs/autoplan-guard-troubleshooting.md +++ b/docs/autoplan-guard-troubleshooting.md @@ -299,6 +299,36 @@ completion notice. Wait for that notice before closing the phase. A background reviewer keeps the invocation armed, so a typed message while it runs does not end `/autoplan`. +### Permission cards after a background reviewer + +A skill's `allowed-tools` applies only to the turn that invoked it, and a +background reviewer's completion notice starts a new turn. From then on Claude +Code's normal permission rules apply, so Reads outside the session's working +directory can show a card, and in Manual mode so do Bash commands that are not +read-only. Skill hooks stay registered for the whole session but do not run +inside subagents. + +`/autoplan` therefore keeps its own files readable without a card: + +- The restore point and every phase artifact (methodology, reviewer input, + snapshots, close packet) live in the project's `.gstack/tmp/autoplan/`, which + Step 1 adds to `.git/info/exclude`. Claude Code reads files in the working + directory without a card, for `/autoplan` and for its reviewer subagents. A + `git clean -x` deletes them, restore point included. +- The publication hook approves `/autoplan`'s own Reads outside the working + directory: this installation's `autoplan/sections/*.md`, and the immutable + artifacts in `/.gstack/tmp/autoplan/` when the session started in a + subdirectory of the repository. It approves nothing else, and never a call + the guard denies. + +A session started in a repository subdirectory still shows a card when a +reviewer reads its input: subagents run without the skill's hook. Start the +session at the repository root, or answer the card with "Yes, allow reading +from ... during this session". In Manual mode, `/autoplan`'s Bash commands +after the first background reviewer also show cards; auto mode, the default +starting mode on current Claude Code for supported models, sends them to its +classifier instead. + ## Supported journal roots The guard accepts exactly one root per journal file: