limit hook policy gate to checkpoint writes

2842d49→main·

pfleidi·2w ago·2 files·+96 added/-39 removed

Keep SessionStart warning-only and let non-writing lifecycle hooks dispatch when checkpoint policy cannot be satisfied.

This preserves TurnStart session initialization and context injection while still blocking hooks that directly write checkpoint data.

Sessions

07130ba2ded6View transcript

Changes

2

• cmd/entire/cli

• Mhook_registry.go+51/-30

• Mhook_registry_test.go+45/-9

158 unmodified lines

159
160
161
162
162
163
164
165
12 unmodified lines

178
179
180
181
182
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
184
197
185
186
199
200
201
202
203
204
205
206
207
208
209
210
211
187
188
189
190
191
192
193
194
195
196
197
198
199
218
200
201
202
203
17 unmodified lines

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265

158 unmodified lines

return fmt.Errorf("failed to parse hook event: %w", parseErr)
}

checkpointWritingNilEventHook := event == nil && agentName == agent.AgentNameClaudeCode && hookName == claudecode.HookNamePostTodo
claudePostTodoCheckpointHook := event == nil && agentName == agent.AgentNameClaudeCode && hookName == claudecode.HookNamePostTodo
eventType := agent.EventType(0)

if event != nil
12 unmodified lines

eventType = event.Type
}

if event != nil || checkpointWritingNilEventHook {
    policy, err := agentHookPolicy(ctx, worktreeRoot)
if eventType == agent.SessionStart {
    skipSessionStart, err := shouldSkipSessionStartForPolicy(ctx, cmd.ErrOrStderr(), ag, worktreeRoot)
    if err != nil {
        logging.Warn(ctx, "checkpoint policy read failed for agent hook",
            slog.String("error", err.Error()))
        if eventType == agent.SessionStart {
            // Let the agent start; the warning explains that checkpoint capture is
            // disabled until the policy can be read.
            if err := writeUnsupportedPolicySessionStartWarning(cmd.ErrOrStderr(), ag, sessionStartPolicyReadErrorWarning(err)); err != nil {
                span.RecordError(err)
                return err
            }
            return nil
        }
        fmt.Fprint(cmd.ErrOrStderr(), agentCheckpointCaptureDisabledReadErrorMessage(err))
        span.RecordError(err)
        return NewSilentError(err)
        return err
    }
    if shouldSkipAgentHookForPolicy(policy) {
        if eventType == agent.SessionStart {
            // Let the agent start; the warning explains that checkpoint capture is
            // disabled until the CLI is upgraded.
            if err := writeUnsupportedPolicySessionStartWarning(cmd.ErrOrStderr(), ag, sessionStartPolicyWarning(policy)); err != nil {
                span.RecordError(err)
                return err
            }
            return nil
        }
        fmt.Fprint(cmd.ErrOrStderr(), agentCheckpointCaptureDisabledMessage(policy))
        span.RecordError(errUnsupportedCheckpointPolicy)
        return NewSilentError(errUnsupportedCheckpointPolicy)
    if skipSessionStart {
        return nil
    }
} else if hookWritesCheckpointData(eventType, claudePostTodoCheckpointHook) {
    if err := rejectUnsupportedCheckpointWritePolicy(ctx, cmd.ErrOrStderr(), worktreeRoot); err != nil {
        span.RecordError(err)
        return err
    }
}

if event != nil {
    // Lifecycle event — use the generic dispatcher
    hookErr = DispatchLifecycleEvent(ctx, ag, event)
} else if checkpointWritingNilEventHook {
} else if claudePostTodoCheckpointHook {
    // PostTodo is Claude-specific: creates incremental checkpoints during subagent execution
    hookErr = handleClaudeCodePostTodo(ctx)
}
17 unmodified lines

return !checkpointpolicy.CanSatisfyPolicy(policy)
}

func shouldSkipSessionStartForPolicy(ctx context.Context, errW io.Writer, ag agent.Agent, worktreeRoot string) (bool, error) {
    policy, err := agentHookPolicy(ctx, worktreeRoot)
    if err != nil {
        logging.Warn(ctx, "checkpoint policy read failed for agent hook",
            slog.String("error", err.Error()))
        // Let the agent start; the warning explains that checkpoint capture is
        // disabled until the policy can be read.
        return true, writeUnsupportedPolicySessionStartWarning(errW, ag, sessionStartPolicyReadErrorWarning(err))
    }
    if shouldSkipAgentHookForPolicy(policy) {
        // Let the agent start; the warning explains that checkpoint capture is
        // disabled until the CLI is upgraded.
        return true, writeUnsupportedPolicySessionStartWarning(errW, ag, sessionStartPolicyWarning(policy))
    }
    return false, nil
}

func rejectUnsupportedCheckpointWritePolicy(ctx context.Context, errW io.Writer, worktreeRoot string) error {
    policy, err := agentHookPolicy(ctx, worktreeRoot)
    if err != nil {
        logging.Warn(ctx, "checkpoint policy read failed for agent hook",
            slog.String("error", err.Error()))
        fmt.Fprint(errW, agentCheckpointCaptureDisabledReadErrorMessage(err))
        return NewSilentError(err)
    }
    if shouldSkipAgentHookForPolicy(policy) {
        fmt.Fprint(errW, agentCheckpointCaptureDisabledMessage(policy))
        return NewSilentError(errUnsupportedCheckpointPolicy)
    }
    return nil
}

func hookWritesCheckpointData(eventType agent.EventType, claudePostTodoCheckpointHook bool) bool {
    if claudePostTodoCheckpointHook {
        return true
    }
    return eventType == agent.TurnEnd || eventType == agent.SubagentEnd
}

func sessionStartPolicyWarning(policy checkpointpolicy.Policy) string {
    message := "Entire CLI is enabled, but this repository's checkpoint policy requires a newer Entire CLI. No Entire checkpoints will be created for this session until you upgrade."
    details := strings.TrimSpace(checkpointpolicy.UnsupportedPolicyMessage(policy, versioncheck.UpdateCommandForCurrentBinary(versioninfo.Version)))