/** Config written to ~/.claude/teams/<id>/config.json when Agent Teams is available. */
export interface AgentTeamConfig {
    /** Unique team identifier — matches the directory name under ~/.claude/teams/. */
    id: string;
    /** Human-readable name surfaced in the Claude Code UI. */
    name: string;
    /** List of teammates in this team. */
    teammates: AgentTeamMember[];
    /** ISO-8601 timestamp when the team was created. */
    createdAt: string;
}
/** A single teammate entry within an AgentTeamConfig. */
export interface AgentTeamMember {
    /** Unique ID within the team. */
    id: string;
    /** Role label — maps to a Planu TeammateInfo model. */
    role: string;
    /** Model name (e.g. "claude-sonnet-4-6"). */
    model: string;
    /** Optional spec ID this teammate is responsible for. */
    specId?: string;
    /** Current teammate status. */
    status: 'idle' | 'running' | 'completed' | 'failed';
}
/** Events emitted by Claude Code over the stdio protocol. */
export type NativeHookEventType = 'TaskCreated' | 'TaskCompleted' | 'TeammateIdle' | 'PostToolUse' | 'PreCompaction';
/** A raw event from the Claude Code stdio hook protocol. */
export interface NativeHookEvent {
    /** Discriminated union tag. */
    type: NativeHookEventType;
    /** ISO-8601 timestamp from the host. */
    timestamp: string;
    /** Arbitrary payload — shape depends on type. */
    payload: NativeHookPayload;
}
/** Payload variants for each NativeHookEventType. */
export type NativeHookPayload = TaskCreatedPayload | TaskCompletedPayload | TeammateIdlePayload | PostToolUsePayload | PreCompactionPayload;
export interface TaskCreatedPayload {
    kind: 'TaskCreated';
    taskId: string;
    description: string;
    /** Planu spec ID if the task was spawned for a spec. */
    specId?: string;
}
export interface TaskCompletedPayload {
    kind: 'TaskCompleted';
    taskId: string;
    /** Exit code: 0 = success, non-zero = failure. */
    exitCode: number;
}
export interface TeammateIdlePayload {
    kind: 'TeammateIdle';
    teammateId: string;
    teamId: string;
}
export interface PostToolUsePayload {
    kind: 'PostToolUse';
    toolName: string;
    toolInputJson: string;
    toolOutputJson: string;
}
export interface PreCompactionPayload {
    kind: 'PreCompaction';
    projectPath: string;
    /** Estimated remaining context budget in tokens. */
    remainingTokens?: number;
}
/** Context passed to enterPlanModeIfSupported(). */
export interface PlanModeGateContext {
    /** The SDD flow stage triggering the gate. */
    stage: string;
    /** Planu spec ID that is being planned. */
    specId: string;
    /** Whether the spec has been approved yet. */
    specApproved: boolean;
    /** Host-level feature detection result. */
    hostSupportsPlanMode: boolean;
}
/** Return value of enterPlanModeIfSupported(). */
export interface PlanModeGateResult {
    /** Whether plan mode was entered. */
    entered: boolean;
    /** Hint to include in the MCP tool response payload. */
    modeHint?: 'plan';
    /** Human-readable message. */
    message: string;
}
/** Decision emitted by the spec-sanctity hook. */
export interface SanctityHookDecision {
    /** Whether the write should be blocked. */
    blocked: boolean;
    /** The file path that was evaluated. */
    filePath: string;
    /** Error message displayed when blocking; undefined when allowed. */
    errorMessage?: string;
}
/** Options for runPrecompactionDrain(). */
export interface PrecompactionDrainOptions {
    /** Whether to skip side-effecting writes (for dry-run tests). */
    dryRun?: boolean;
    /** Branch patterns allowed for autopush (default: feat/*, fix/*, chore/*). */
    autopushBranches?: string[];
}
/** Minimal line-emitting source for native hook subscriptions (subset of EventEmitter). */
export interface LineEmitter {
    on(event: 'line', handler: (line: string) => void): void;
    removeListener(event: 'line', handler: (line: string) => void): void;
}
/** Awaiter token returned alongside the plan-mode hint. */
export interface ExitPlanModeAwaiter {
    /** Resolves when the host signals ExitPlanMode (or times out). */
    promise: Promise<void>;
    /** True once resolved. */
    isResolved(): boolean;
    /** Manually resolve (used in tests and timeout paths). */
    resolve(): void;
}
/** Summary returned by runPrecompactionDrain(). */
export interface PrecompactionDrainReport {
    /** Number of learning entries written to MEMORY.md fragments. */
    learningsFlushed: number;
    /** Whether session-context.md was written successfully. */
    sessionContextWritten: boolean;
    /** Result of the autopush attempt. */
    autopushResult: PrecompactionAutopushSummary;
    /** Overall human-readable status line. */
    humanSummary: string;
}
/** Compact autopush summary for the drain report. */
export type PrecompactionAutopushSummary = {
    pushed: true;
    ref: string;
    commitsPushed: number;
} | {
    pushed: false;
    reason: string;
};
//# sourceMappingURL=claude-code-runtime.d.ts.map